Analysis Run

{"no_findings":false,"summary":"Bytecode is call-heavy with 33 low-level CALL sites using computed targets/values. Some CALL paths are reachable without detected auth checks and can flow to state writes, which raises access-control and reentrancy concerns (bytecode-only analysis is inherently uncertain).","findings":[{"severity":"medium","category":"access_control","title":"Potentially unguarded arbitrary CALL/ETH transfer entrypoints","exploit_scenario":"If any externally callable function routes user-controlled calldata into these low-level CALLs without a strict caller check, an attacker could instruct the contract to call arbitrary targets with ETH, draining contract balance or triggering unintended external interactions. The detector validation sometimes resolved targets to the contract itself, so exposure depends on the actual ABI and how targets are sourced.","recommendation":"Confirm which selectors/entrypoints reach CALL sites and ensure strict access control or target/value allowlisting. If this is intended as an executor, enforce role checks and consider limiting value or target ranges.","evidence":"33 CALL callsites with computed target/value (returndata_check unknown). Examples at pc 0x3ee, 0x42f, 0x4d7. Detector flagged “Untrusted CALL target/value reachable” and “ETH value transfer possible”; validation was inconclusive about whether targets always vary or are self-calls.","locations":["pc:0x3ee","pc:0x42f","pc:0x4d7","pc:0x530","pc:0x575"]},{"severity":"low","category":"reentrancy","title":"External CALLs can reach state writes without a detected reentrancy guard","exploit_scenario":"If any CALL target is untrusted, it could reenter before later SSTOREs along the same control flow and manipulate contract state (e.g., repeated updates or invariant breaks). Evidence is indirect due to bytecode-only analysis.","recommendation":"Apply checks-effects-interactions and/or a reentrancy guard around CALL paths that can reach SSTORE. Consider constraining call targets to trusted contracts if reentrancy is not intended.","evidence":"CFG reachability shows a CALL at pc 0x8be can reach SSTORE blocks at pc 0x1176/0x1146. No explicit guard detected in auth.guards; CALL targets are computed per callsite metadata.","locations":["pc:0x8be","pc:0x1146","pc:0x1176"]}]}

OpenAI Codex v0.77.0 (research preview)
--------
workdir: /tmp/codex-i7ao1p3r
model: gpt-5.2-codex
provider: openai
approval: never
sandbox: read-only
reasoning effort: high
reasoning summaries: auto
session id: 019baa5c-9e23-7270-af32-eeda19def01a
--------
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
**Checking for BYTECODE_BUNDLE.json**
exec
/bin/bash -lc ls in /tmp/codex-i7ao1p3r succeeded in 7ms:
BYTECODE_BUNDLE.json
codex-output-schema.json

thinking
**Reading bundle information**
exec
/bin/bash -lc 'cat BYTECODE_BUNDLE.json' in /tmp/codex-i7ao1p3r succeeded in 16ms:
{
  "analysis_artifact": {
    "address": "0x80aa81029df9afdc70a621c86d7a81d7e9ed7e3a",
    "artifact_hash": "0x2e8f7706875eea253500d2777cca6f7e4e477a7612f7d83aef8bdccd8f15d5ea",
    "artifact_json": {
      "auth": {
        "guards": []
      },
      "basic_blocks": [
        {
          "end_pc": 10,
          "hash": "0x44b9496415b5809b15099b83c849935ad9891afc24dcc2240de0222f3d58d087",
          "opcodes": [
            "PUSH1",
            "PUSH1",
            "MSTORE",
            "CALLDATASIZE",
            "ISZERO",
            "PUSH2",
            "JUMPI"

thinking
**Planning JSON analysis approach**
exec
/bin/bash -lc "python - <<'PY'
import json,sys
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
print(data.keys())
print('detector_findings',len(data.get('detector_findings',[])))
print('analysis_artifact keys',data['analysis_artifact'].keys())
print('heuristics',data.get('heuristics_summary'))
PY" in /tmp/codex-i7ao1p3r succeeded in 44ms:
dict_keys(['analysis_artifact', 'analysis_run', 'artifact', 'capability_graph', 'detector_findings', 'heuristics_summary'])
detector_findings 2
analysis_artifact keys dict_keys(['address', 'artifact_hash', 'artifact_json', 'block_number', 'chain_id', 'codehash', 'created_at', 'id', 'updated_at', 'version'])
heuristics {'create2_count': 0, 'delegatecall_count': 0, 'flags': ['call_family_heavy'], 'selfdestruct_count': 0}

thinking
**Investigating call patterns and vulnerabilities**

I’m focusing on analyzing various callsites, especially those involving CALL instructions with ETH value, to understand if calls to the contract itself count as risks or false positives. I want to explore the capability_graph and analysis_run data structures in Python to clarify resolved call targets and detect genuine vulnerabilities from bytecode.
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
# print top-level keys and types lengths
for k in ['analysis_run','artifact','capability_graph']:
    print(k, type(data.get(k)).__name__)
PY" in /tmp/codex-i7ao1p3r succeeded in 36ms:
analysis_run dict
artifact dict
capability_graph dict

thinking
**Inspecting capability_graph**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
cap=data['capability_graph']
print(cap.keys())
print('nodes',len(cap.get('nodes',[])),'edges',len(cap.get('edges',[])))
# list some nodes types counts
from collections import Counter
c=Counter(n.get('type') for n in cap.get('nodes',[]))
print('node types',c.most_common(10))
# check if storage slots included
slots=[n for n in cap.get('nodes',[]) if n.get('type') in ('storage_slot','storage')]
print('storage slots',len(slots))
PY" in /tmp/codex-i7ao1p3r succeeded in 29ms:
dict_keys(['address', 'block_number', 'chain_id', 'codehash', 'created_at', 'graph_hash', 'graph_json', 'id', 'updated_at', 'version'])
nodes 0 edges 0
node types []
storage slots 0

thinking
**Inspecting analysis_artifact contents**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
artifact=data['artifact']
print(artifact.keys())
print('artifact_json keys',artifact['artifact_json'].keys())
PY" in /tmp/codex-i7ao1p3r exited 1 in 72ms:
dict_keys(['codehash', 'compiler_json', 'implementation_address', 'is_proxy', 'runtime_bytecode', 'verified_source'])
Traceback (most recent call last):
  File "<stdin>", line 6, in <module>
KeyError: 'artifact_json'

thinking
**Inspecting analysis_run structure**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
run=data['analysis_run']
print(run.keys())
for k in run.keys():
    if isinstance(run[k], dict):
        print(k, run[k].keys())
    elif isinstance(run[k], list):
        print(k, 'len', len(run[k]))
PY" in /tmp/codex-i7ao1p3r succeeded in 28ms:
dict_keys(['address', 'block_number', 'chain_id', 'child_links', 'created_at', 'id', 'parent_links', 'status', 'updated_at'])
child_links len 0
parent_links len 0

thinking
**Planning artifact_json parsing**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import Counter
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
art=data['analysis_artifact']['artifact_json']
print(art.keys())
# find keys that include 'storage'
print([k for k in art.keys() if 'storage' in k.lower()])
PY" in /tmp/codex-i7ao1p3r succeeded in 38ms:
dict_keys(['auth', 'basic_blocks', 'callsites', 'cfg_edges', 'cfg_hash', 'dispatcher_type', 'function_entries', 'functions', 'selectors', 'sinks', 'storage', 'version'])
['storage']

thinking
**Inspecting storage details**
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'].get('storage',{})
print(storage.keys())
# show some storage slots
slots=storage.get('slots',[])
print('slots',len(slots))
print('first slots',slots[:10])
# show mappings patterns
print('mappings',len(storage.get('mappings',[])))
print('arrays',len(storage.get('arrays',[])))
PY" in /tmp/codex-i7ao1p3r succeeded in 41ms:
dict_keys(['keccak_count', 'reads', 'slots', 'writes'])
slots 81
first slots [{'op': 'SLOAD', 'pc': 175, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000002'}, {'op': 'SLOAD', 'pc': 237, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000001'}, {'op': 'SLOAD', 'pc': 285, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000009'}, {'op': 'SLOAD', 'pc': 316, 'slot': '0x000000000000000000000000000000000000000000000000000000000000000b'}, {'op': 'SLOAD', 'pc': 319, 'slot': '0x000000000000000000000000000000000000000000000000000000000000000c'}, {'op': 'SLOAD', 'pc': 342, 'slot': '0x000000000000000000000000000000000000000000000000000000000000000a'}, {'op': 'SLOAD', 'pc': 371, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000000'}, {'op': 'SLOAD', 'pc': 374, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000002'}, {'op': 'SLOAD', 'pc': 377, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000008'}, {'op': 'SLOAD', 'pc': 380, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000009'}]
mappings 0
arrays 0

thinking
**Examining access control checks**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import Counter
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
art=data['analysis_artifact']['artifact_json']
print('dispatcher_type',art.get('dispatcher_type'))
print('selectors count',len(art.get('selectors',[])))
print('selectors',art.get('selectors')[:10])
print('function_entries',len(art.get('function_entries',[])))
print('functions count',len(art.get('functions',[])))
# show function entries
print('function_entries sample',art.get('function_entries')[:10])
PY" in /tmp/codex-i7ao1p3r succeeded in 61ms:
dispatcher_type selector_jump_table
selectors count 13
selectors ['0x303bdbe8', '0x52c665bd', '0x66b87b2a', '0x6c0f79b6', '0x729048ef', '0x72de5b2f', '0x7b76ac91', '0x91ff2c86', '0xa17ca4f3', '0xbbfff47d']
function_entries 13
functions count 13
function_entries sample [{'entry_pc': None, 'selector': '0x303bdbe8'}, {'entry_pc': 1723366186, 'selector': '0x52c665bd'}, {'entry_pc': 1812953526, 'selector': '0x66b87b2a'}, {'entry_pc': 1922058479, 'selector': '0x6c0f79b6'}, {'entry_pc': 1927174959, 'selector': '0x729048ef'}, {'entry_pc': 2071374993, 'selector': '0x72de5b2f'}, {'entry_pc': 2449419398, 'selector': '0x7b76ac91'}, {'entry_pc': 2709300467, 'selector': '0x91ff2c86'}, {'entry_pc': 3154113661, 'selector': '0xa17ca4f3'}, {'entry_pc': 3360626597, 'selector': '0xbbfff47d'}]

thinking
**Analyzing callsites and entry points**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
art=data['analysis_artifact']['artifact_json']
cs=art.get('callsites',[])
print('callsites',len(cs))
print('sample',cs[:5])
PY" in /tmp/codex-i7ao1p3r succeeded in 38ms:
callsites 33
sample [{'opcode': 'CALL', 'pc': 1006, 'returndata_checked': None, 'target_expression_category': 'computed', 'value_expression_category': 'computed'}, {'opcode': 'CALL', 'pc': 1071, 'returndata_checked': None, 'target_expression_category': 'computed', 'value_expression_category': 'computed'}, {'opcode': 'CALL', 'pc': 1239, 'returndata_checked': None, 'target_expression_category': 'computed', 'value_expression_category': 'computed'}, {'opcode': 'CALL', 'pc': 1328, 'returndata_checked': None, 'target_expression_category': 'computed', 'value_expression_category': 'computed'}, {'opcode': 'CALL', 'pc': 1397, 'returndata_checked': None, 'target_expression_category': 'computed', 'value_expression_category': 'computed'}]

thinking
**Analyzing callsites and surrounding bytecode**
exec
/bin/bash -lc "python - <<'PY'
import json
from bisect import bisect
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
# build list with start,end,opcodes
# It seems basic_blocks are in list but maybe unsorted; sort by start_pc
blocks_sorted=sorted(blocks,key=lambda b:b['start_pc'])

# index block containing pc

def block_for_pc(pc):
    # linear search due to small size? but maybe thousands. use loop.
    for b in blocks_sorted:
        if b['start_pc']<=pc<=b['end_pc']:
            return b
    return None

for pc in [1006,1071,1239,1328,1397]:
    b=block_for_pc(pc)
    print('pc',pc,'block',b['start_pc'] if b else None,'-',b['end_pc'] if b else None)
    if b:
        print(b['opcodes'])
PY" in /tmp/codex-i7ao1p3r succeeded in 29ms:
pc 1006 block 746 - 1022
['JUMPDEST', 'PUSH1', 'OP_80', 'MLOAD', 'PUSH1', 'PUSH1', 'OP_80', 'CALLDATALOAD', 'PUSH1', 'OP_81', 'OP_81', 'ADD', 'CALLDATALOAD', 'PUSH1', 'OP_81', 'ADD', 'OP_85', 'OP_90', 'DIV', 'OP_85', 'MUL', 'OP_86', 'ADD', 'OP_85', 'ADD', 'OP_90', 'OP_96', 'MSTORE', 'OP_85', 'OP_85', 'MSTORE', 'PUSH2', 'OP_95', 'OP_81', 'CALLDATALOAD', 'OP_95', 'OP_91', 'OP_94', 'PUSH1', 'OP_94', 'OP_92', 'OP_93', 'OP_90', 'OP_92', 'ADD', 'OP_91', 'OP_81', 'OP_90', 'OP_84', 'ADD', 'OP_83', 'OP_82', 'OP_80', 'OP_82', 'OP_84', 'CALLDATACOPY', 'POP', 'POP', 'PUSH1', 'OP_80', 'MLOAD', 'PUSH1', 'OP_97', 'CALLDATALOAD', 'OP_80', 'OP_8A', 'ADD', 'CALLDATALOAD', 'PUSH1', 'OP_81', 'ADD', 'OP_8A', 'OP_90', 'DIV', 'OP_8A', 'MUL', 'OP_83', 'ADD', 'OP_8A', 'ADD', 'OP_90', 'OP_93', 'MSTORE', 'OP_82', 'OP_82', 'MSTORE', 'OP_96', 'OP_98', 'OP_97', 'PUSH1', 'OP_97', 'OP_91', 'OP_96', 'POP', 'PUSH1', 'OP_91', 'OP_90', 'OP_91', 'ADD', 'OP_94', 'POP', 'OP_90', 'OP_92', 'POP', 'OP_82', 'OP_91', 'POP', 'OP_84', 'ADD', 'OP_83', 'OP_82', 'OP_80', 'OP_82', 'OP_84', 'CALLDATACOPY', 'POP', 'OP_94', 'OP_96', 'POP', 'POP', 'OP_93', 'CALLDATALOAD', 'OP_93', 'POP', 'POP', 'POP', 'POP', 'PUSH1', 'SLOAD', 'PUSH1', 'MLOAD', 'PUSH32', 'OP_81', 'MSTORE', 'PUSH1', 'PUSH1', 'OP_82', 'OP_81', 'ADD', 'OP_82', 'OP_81', 'MSTORE', 'OP_87', 'MLOAD', 'PUSH1', 'OP_85', 'ADD', 'MSTORE', 'OP_87', 'MLOAD', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'OP_95', 'OP_90', 'OP_95', 'AND', 'OP_94', 'PUSH4', 'OP_94', 'OP_89', 'OP_94', 'OP_92', 'OP_93', 'OP_84', 'OP_93', 'PUSH1', 'OP_92', 'OP_90', 'OP_92', 'ADD', 'OP_92', 'OP_86', 'OP_83', 'ADD', 'OP_92', 'OP_90', 'OP_91', 'OP_82', 'OP_91', 'OP_85', 'OP_91', 'OP_83', 'OP_91', 'OP_86', 'OP_91', 'PUSH1', 'OP_91', 'PUSH1', 'OP_85', 'ADD', 'DIV', 'PUSH1', 'MUL', 'PUSH1', 'ADD', 'CALL', 'POP', 'OP_90', 'POP', 'OP_90', 'OP_81', 'ADD', 'OP_90', 'PUSH1', 'AND', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
pc 1071 block 1048 - 1076
['JUMPDEST', 'POP', 'OP_92', 'POP', 'POP', 'POP', 'PUSH1', 'PUSH1', 'MLOAD', 'OP_80', 'OP_83', 'SUB', 'OP_81', 'PUSH1', 'OP_87', 'PUSH2', 'GAS', 'SUB', 'CALL', 'ISZERO', 'PUSH2', 'JUMPI']
pc 1239 block 1102 - 1255
['PUSH1', 'PUSH1', 'POP', 'PUSH1', 'ADD', 'PUSH1', 'OP_90', 'SLOAD', 'OP_90', 'PUSH2', 'EXP', 'OP_90', 'DIV', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'AND', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'AND', 'PUSH4', 'CALLER', 'OP_85', 'OP_85', 'PUSH1', 'PUSH1', 'MLOAD', 'OP_85', 'PUSH1', 'PUSH1', 'EXP', 'MUL', 'OP_81', 'MSTORE', 'PUSH1', 'ADD', 'OP_80', 'OP_85', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'AND', 'OP_81', 'MSTORE', 'PUSH1', 'ADD', 'OP_80', 'PUSH1', 'ADD', 'OP_80', 'PUSH1', 'ADD', 'OP_84', 'OP_81', 'MSTORE', 'PUSH1', 'ADD', 'OP_83', 'OP_81', 'SUB', 'OP_83', 'MSTORE', 'OP_86', 'OP_81', 'OP_81', 'MLOAD', 'OP_81', 'MSTORE', 'PUSH1', 'ADD', 'OP_91', 'POP', 'OP_80', 'MLOAD', 'OP_90', 'PUSH1', 'ADD', 'OP_90', 'OP_80', 'OP_83', 'OP_83', 'OP_82', 'OP_90', 'PUSH1', 'PUSH1', 'PUSH1', 'OP_84', 'PUSH1', 'ADD', 'DIV', 'PUSH1', 'MUL', 'PUSH1', 'ADD', 'CALL', 'POP', 'OP_90', 'POP', 'OP_90', 'OP_81', 'ADD', 'OP_90', 'PUSH1', 'AND', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
pc 1328 block 1281 - 1344
['JUMPDEST', 'POP', 'OP_83', 'OP_81', 'SUB', 'OP_82', 'MSTORE', 'OP_85', 'OP_81', 'OP_81', 'MLOAD', 'OP_81', 'MSTORE', 'PUSH1', 'ADD', 'OP_91', 'POP', 'OP_80', 'MLOAD', 'OP_90', 'PUSH1', 'ADD', 'OP_90', 'OP_80', 'OP_83', 'OP_83', 'OP_82', 'OP_90', 'PUSH1', 'PUSH1', 'PUSH1', 'OP_84', 'PUSH1', 'ADD', 'DIV', 'PUSH1', 'MUL', 'PUSH1', 'ADD', 'CALL', 'POP', 'OP_90', 'POP', 'OP_90', 'OP_81', 'ADD', 'OP_90', 'PUSH1', 'AND', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
pc 1397 block 1370 - 1402
['JUMPDEST', 'POP', 'OP_96', 'POP', 'POP', 'POP', 'POP', 'POP', 'POP', 'POP', 'PUSH1', 'PUSH1', 'MLOAD', 'OP_80', 'OP_83', 'SUB', 'OP_81', 'PUSH1', 'OP_87', 'PUSH2', 'GAS', 'SUB', 'CALL', 'ISZERO', 'PUSH2', 'JUMPI']

thinking
**Analyzing bytecode for access control and reentrancy risks**

I'm inspecting the bytecode to find access control checks near the big dispatcher and calls, trying to locate owner guards or revert conditions. I plan to analyze storage writes (SSTORE) in relation to external calls to assess potential reentrancy vulnerabilities since there’s no automatic guard detection available. Let's dig into the storage writes next to see if reentrancy hazards might exist.
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
storage=data['analysis_artifact']['artifact_json']['storage']
print('writes',len(storage.get('writes',[])))
print(storage.get('writes')[:20])
PY" in /tmp/codex-i7ao1p3r exited 1 in 35ms:
Traceback (most recent call last):
  File "<stdin>", line 5, in <module>
TypeError: object of type 'int' has no len()

thinking
**Checking storage.writes type**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
storage=data['analysis_artifact']['artifact_json']['storage']
print(storage['writes'].__class__, storage['writes'])
print(storage['reads'].__class__, storage['reads'])
PY" in /tmp/codex-i7ao1p3r succeeded in 30ms:
<class 'int'> 21
<class 'int'> 69

thinking
**Clarifying storage slot operations**
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']
stores=[s for s in slots if s.get('op')=='SSTORE']
print('SSTORE slots',len(stores))
print(stores[:10])
PY" in /tmp/codex-i7ao1p3r succeeded in 29ms:
SSTORE slots 13
[{'op': 'SSTORE', 'pc': 1667, 'slot': '0x00000000000000000000000000000000000000000000000000470de4df820000'}, {'op': 'SSTORE', 'pc': 1672, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000032'}, {'op': 'SSTORE', 'pc': 1684, 'slot': '0x0000000000000000000000000000000000000000000000008ac7230489e80000'}, {'op': 'SSTORE', 'pc': 1710, 'slot': '0x000000000000000000000000000000000000000000000000000000000034bc00'}, {'op': 'SSTORE', 'pc': 3153, 'slot': '0x0000000000000000000000000000000000000000000000000000000000001271'}, {'op': 'SSTORE', 'pc': 4560, 'slot': '0x000000000000000000000000000000000000000000000000008e1bc9bf040000'}, {'op': 'SSTORE', 'pc': 4565, 'slot': '0x0000000000000000000000000000000000000000000000000000000000000019'}, {'op': 'SSTORE', 'pc': 4611, 'slot': '0x00000000000000000000000000000000000000000000000000766c7d74835555'}, {'op': 'SSTORE', 'pc': 4616, 'slot': '0x000000000000000000000000000000000000000000000000000000000000001e'}, {'op': 'SSTORE', 'pc': 4662, 'slot': '0x000000000000000000000000000000000000000000000000006581901ab9b6db'}]

thinking
**Analyzing slot constants and SSTORE order**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
blocks_sorted=sorted(blocks,key=lambda b:b['start_pc'])
# mapping

def block_for_pc(pc):
    for b in blocks_sorted:
        if b['start_pc']<=pc<=b['end_pc']:
            return b
    return None

# list SSTORE pcs
slots=data['analysis_artifact']['artifact_json']['storage']['slots']
stores=[s for s in slots if s.get('op')=='SSTORE']
for s in stores:
    pc=s['pc']
    b=block_for_pc(pc)
    print('SSTORE pc',pc,'block',b['start_pc'] if b else None,'-',b['end_pc'] if b else None)
    if b:
        print('opcodes',b['opcodes'])
PY" in /tmp/codex-i7ao1p3r succeeded in 29ms:
SSTORE pc 1667 block 1654 - 1714
opcodes ['JUMPDEST', 'PUSH7', 'PUSH1', 'OP_90', 'OP_81', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE', 'PUSH8', 'PUSH1', 'SSTORE', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH3', 'TIMESTAMP', 'ADD', 'PUSH1', 'SSTORE', 'PUSH1', 'SSTORE', 'PUSH3', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH1', 'SSTORE', 'JUMP']
SSTORE pc 1672 block 1654 - 1714
opcodes ['JUMPDEST', 'PUSH7', 'PUSH1', 'OP_90', 'OP_81', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE', 'PUSH8', 'PUSH1', 'SSTORE', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH3', 'TIMESTAMP', 'ADD', 'PUSH1', 'SSTORE', 'PUSH1', 'SSTORE', 'PUSH3', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH1', 'SSTORE', 'JUMP']
SSTORE pc 1684 block 1654 - 1714
opcodes ['JUMPDEST', 'PUSH7', 'PUSH1', 'OP_90', 'OP_81', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE', 'PUSH8', 'PUSH1', 'SSTORE', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH3', 'TIMESTAMP', 'ADD', 'PUSH1', 'SSTORE', 'PUSH1', 'SSTORE', 'PUSH3', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH1', 'SSTORE', 'JUMP']
SSTORE pc 1710 block 1654 - 1714
opcodes ['JUMPDEST', 'PUSH7', 'PUSH1', 'OP_90', 'OP_81', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE', 'PUSH8', 'PUSH1', 'SSTORE', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH3', 'TIMESTAMP', 'ADD', 'PUSH1', 'SSTORE', 'PUSH1', 'SSTORE', 'PUSH3', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH1', 'SSTORE', 'JUMP']
SSTORE pc 3153 block 3147 - 3154
opcodes ['PUSH2', 'TIMESTAMP', 'PUSH1', 'SSTORE', 'JUMP']
SSTORE pc 4560 block 4550 - 4565
opcodes ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE']
SSTORE pc 4565 block 4550 - 4565
opcodes ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE']
SSTORE pc 4611 block 4601 - 4616
opcodes ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE']
SSTORE pc 4616 block 4601 - 4616
opcodes ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE']
SSTORE pc 4662 block 4652 - 4667
opcodes ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE']

thinking
**Analyzing call and storage guard checks**

I’m trying to understand if the low-level CALL instructions have proper access control by looking for CALLER checks near or preceding these call sites. I want to map SSTORE and CALL operations to their respective function guards by examining control flow and storage checks to decide if any unchecked, potentially risky external calls or ETH transfers exist.
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
# find callsite blocks
call_pcs=set(cs['pc'] for cs in data['analysis_artifact']['artifact_json']['callsites'])
call_blocks=[]
for b in blocks:
    if any(op=='CALL' for op in b['opcodes']):
        call_blocks.append(b)
print('call blocks',len(call_blocks))
# check if CALLER appears in same block
count_with_caller=0
for b in call_blocks:
    if 'CALLER' in b['opcodes']:
        count_with_caller+=1
print('call blocks with CALLER',count_with_caller)
# list some call blocks opcodes containing CALLER
sample=[]
for b in call_blocks:
    if 'CALLER' in b['opcodes']:
        sample.append((b['start_pc'],b['end_pc'],b['opcodes'][:20]))
print('sample',sample[:3])
PY" in /tmp/codex-i7ao1p3r succeeded in 31ms:
call blocks 33
call blocks with CALLER 15
sample [(1102, 1255, ['PUSH1', 'PUSH1', 'POP', 'PUSH1', 'ADD', 'PUSH1', 'OP_90', 'SLOAD', 'OP_90', 'PUSH2', 'EXP', 'OP_90', 'DIV', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'AND', 'PUSH1']), (1779, 1863, ['JUMPDEST', 'PUSH1', 'SLOAD', 'PUSH1', 'OP_80', 'MLOAD', 'PUSH1', 'PUSH1', 'EXP', 'PUSH4', 'MUL', 'OP_81', 'MSTORE', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'CALLER', 'OP_81']), (1877, 1954, ['PUSH1', 'OP_80', 'MLOAD', 'PUSH1', 'SLOAD', 'PUSH1', 'PUSH1', 'EXP', 'PUSH4', 'MUL', 'OP_82', 'MSTORE', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'CALLER', 'OP_81', 'AND'])]

thinking
**Searching for caller guard checks**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
# find blocks with CALLER and EQ and JUMPI (guard)
res=[]
for b in blocks:
    ops=b['opcodes']
    if 'CALLER' in ops and 'EQ' in ops and 'JUMPI' in ops:
        res.append(b)
print('guard-like blocks',len(res))
print('sample',[(b['start_pc'],b['end_pc'],b['opcodes']) for b in res[:5]])
PY" in /tmp/codex-i7ao1p3r succeeded in 75ms:
guard-like blocks 4
sample [(273, 305, ['JUMPDEST', 'PUSH2', 'PUSH1', 'CALLDATALOAD', 'PUSH1', 'CALLDATALOAD', 'PUSH1', 'SLOAD', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'OP_90', 'OP_81', 'AND', 'CALLER', 'OP_90', 'OP_91', 'AND', 'EQ', 'PUSH2', 'JUMPI']), (464, 630, ['JUMPDEST', 'PUSH1', 'OP_80', 'MLOAD', 'PUSH1', 'PUSH1', 'OP_80', 'CALLDATALOAD', 'PUSH1', 'OP_81', 'OP_81', 'ADD', 'CALLDATALOAD', 'PUSH1', 'OP_81', 'ADD', 'OP_85', 'OP_90', 'DIV', 'OP_85', 'MUL', 'OP_86', 'ADD', 'OP_85', 'ADD', 'OP_90', 'OP_96', 'MSTORE', 'OP_85', 'OP_85', 'MSTORE', 'PUSH2', 'OP_95', 'OP_81', 'CALLDATALOAD', 'OP_95', 'OP_91', 'OP_94', 'PUSH1', 'OP_94', 'OP_92', 'OP_93', 'OP_90', 'OP_92', 'ADD', 'OP_91', 'OP_81', 'OP_90', 'OP_84', 'ADD', 'OP_83', 'OP_82', 'OP_80', 'OP_82', 'OP_84', 'CALLDATACOPY', 'POP', 'POP', 'PUSH1', 'OP_80', 'MLOAD', 'PUSH1', 'OP_97', 'CALLDATALOAD', 'OP_80', 'OP_8A', 'ADD', 'CALLDATALOAD', 'PUSH1', 'OP_81', 'ADD', 'OP_8A', 'OP_90', 'DIV', 'OP_8A', 'MUL', 'OP_83', 'ADD', 'OP_8A', 'ADD', 'OP_90', 'OP_93', 'MSTORE', 'OP_82', 'OP_82', 'MSTORE', 'OP_96', 'OP_98', 'OP_97', 'PUSH1', 'OP_97', 'OP_91', 'OP_96', 'POP', 'PUSH1', 'OP_91', 'OP_90', 'OP_91', 'ADD', 'OP_94', 'POP', 'OP_90', 'OP_92', 'POP', 'OP_82', 'OP_91', 'POP', 'OP_84', 'ADD', 'OP_83', 'OP_82', 'OP_80', 'OP_82', 'OP_84', 'CALLDATACOPY', 'POP', 'OP_94', 'OP_96', 'POP', 'POP', 'OP_93', 'CALLDATALOAD', 'OP_93', 'POP', 'POP', 'PUSH1', 'CALLDATALOAD', 'OP_91', 'POP', 'POP', 'PUSH1', 'SLOAD', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'OP_90', 'OP_81', 'AND', 'CALLER', 'OP_90', 'OP_91', 'AND', 'EQ', 'PUSH2', 'JUMPI']), (635, 664, ['JUMPDEST', 'PUSH2', 'PUSH1', 'CALLDATALOAD', 'PUSH1', 'SLOAD', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'OP_90', 'OP_81', 'AND', 'CALLER', 'OP_90', 'OP_91', 'AND', 'EQ', 'PUSH2', 'JUMPI']), (1422, 1447, ['JUMPDEST', 'PUSH2', 'PUSH1', 'SLOAD', 'CALLER', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'OP_90', 'OP_81', 'AND', 'OP_91', 'AND', 'EQ', 'PUSH2', 'JUMPI'])]

thinking
**Analyzing caller guard and control flow**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
edges=data['analysis_artifact']['artifact_json']['cfg_edges']
print('edges',len(edges))
print('sample',edges[:10])
# Build adjacency for quick look
adj=defaultdict(list)
for e in edges:
    adj[e['src']].append(e['dst'])
print('nodes',len(adj))
# list some edges from guard block 464-630 etc if exists
# need block ids? edges maybe by block hash? check
print('edge keys',edges[0].keys())
PY" in /tmp/codex-i7ao1p3r exited 1 in 34ms:
edges 205
sample [{'from': 'bb:0', 'to': 'bb:163', 'type': 'control_flow'}, {'from': 'bb:0', 'to': 'bb:11', 'type': 'control_flow_fallthrough'}, {'from': 'bb:11', 'to': 'bb:165', 'type': 'control_flow'}, {'from': 'bb:11', 'to': 'bb:31', 'type': 'control_flow_fallthrough'}, {'from': 'bb:31', 'to': 'bb:190', 'type': 'control_flow'}, {'from': 'bb:31', 'to': 'bb:42', 'type': 'control_flow_fallthrough'}, {'from': 'bb:42', 'to': 'bb:273', 'type': 'control_flow'}, {'from': 'bb:42', 'to': 'bb:53', 'type': 'control_flow_fallthrough'}, {'from': 'bb:53', 'to': 'bb:310', 'type': 'control_flow'}, {'from': 'bb:53', 'to': 'bb:64', 'type': 'control_flow_fallthrough'}]
Traceback (most recent call last):
  File "<stdin>", line 11, in <module>
KeyError: 'src'

thinking
**Examining block IDs and mappings**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
print(blocks[0].keys())
print(blocks[0])
# check if blocks have id
has_id=sum(1 for b in blocks if 'id' in b)
print('blocks with id',has_id,'of',len(blocks))
PY" in /tmp/codex-i7ao1p3r succeeded in 61ms:
dict_keys(['end_pc', 'hash', 'opcodes', 'start_pc'])
{'end_pc': 10, 'hash': '0x44b9496415b5809b15099b83c849935ad9891afc24dcc2240de0222f3d58d087', 'opcodes': ['PUSH1', 'PUSH1', 'MSTORE', 'CALLDATASIZE', 'ISZERO', 'PUSH2', 'JUMPI'], 'start_pc': 0}
blocks with id 0 of 175

thinking
**Analyzing control flow graph edges**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
# map start_pc->opcodes
block_ops={b['start_pc']:b['opcodes'] for b in blocks}
# identify guard blocks (caller+eq+jumpi)
import re
guard_blocks=set()
for b in blocks:
    ops=b['opcodes']
    if 'CALLER' in ops and 'EQ' in ops and 'JUMPI' in ops:
        guard_blocks.add(b['start_pc'])

# call blocks start_pc list
call_blocks=set()
for b in blocks:
    if 'CALL' in b['opcodes']:
        call_blocks.add(b['start_pc'])

edges=data['analysis_artifact']['artifact_json']['cfg_edges']
# build preds
preds=defaultdict(list)
for e in edges:
    # e keys: from,to
    frm=int(e['from'].split(':')[1])
    to=int(e['to'].split(':')[1])
    preds[to].append(frm)

# for each call block, check if any immediate predecessor is guard block
call_guarded=[]
call_unguarded=[]
for cb in sorted(call_blocks):
    predset=preds.get(cb,[])
    if any(p in guard_blocks for p in predset):
        call_guarded.append(cb)
    else:
        call_unguarded.append(cb)
print('guard blocks',sorted(guard_blocks))
print('call blocks',len(call_blocks))
print('call blocks with guard pred',len(call_guarded))
print('call blocks without guard pred',len(call_unguarded))
print('sample unguarded',call_unguarded[:10])
PY" in /tmp/codex-i7ao1p3r succeeded in 28ms:
guard blocks [273, 464, 635, 1422]
call blocks 33
call blocks with guard pred 2
call blocks without guard pred 31
sample unguarded [746, 1048, 1102, 1281, 1370, 1470, 1779, 1877, 2000, 2135]

thinking
**Evaluating contract call and guard patterns**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
art=data['analysis_artifact']['artifact_json']
print('sinks',art.get('sinks'))
PY" in /tmp/codex-i7ao1p3r succeeded in 33ms:
sinks {'call': 33, 'create': 0, 'create2': 0, 'delegatecall': 0, 'selfdestruct': 0, 'staticcall': 0, 'upgrade_slot_write_suspected': False}

thinking
**Analyzing reentrancy risk via control flow**

I'm considering checking for reentrancy vulnerabilities by analyzing if any storage write (SSTORE) occurs after an external call (CALL) within the same or reachable blocks in the control flow graph. I'll approximate this by computing reachability from call blocks to SSTORE blocks using BFS, focusing on whether state changes follow external calls without intermediate returns, which might signal potential reentrancy risks.
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict, deque
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
# Build graph
edges=data['analysis_artifact']['artifact_json']['cfg_edges']
adj=defaultdict(list)
for e in edges:
    frm=int(e['from'].split(':')[1])
    to=int(e['to'].split(':')[1])
    adj[frm].append(to)
# Identify call blocks and sstore blocks
call_blocks=[b['start_pc'] for b in blocks if 'CALL' in b['opcodes']]
sstore_blocks=[b['start_pc'] for b in blocks if 'SSTORE' in b['opcodes']]
call_blocks=set(call_blocks)
sstore_blocks=set(sstore_blocks)

# BFS from each call block to see if sstore reachable (limited to avoid huge)
reachable_calls=[]
for cb in call_blocks:
    seen=set([cb])
    dq=deque([cb])
    found=False
    while dq and not found:
        cur=dq.popleft()
        for nxt in adj.get(cur,[]):
            if nxt in seen: continue
            if nxt in sstore_blocks:
                found=True
                break
            seen.add(nxt)
            dq.append(nxt)
    if found:
        reachable_calls.append(cb)

print('call blocks',len(call_blocks))
print('sstore blocks',len(sstore_blocks))
print('call blocks that can reach sstore',len(reachable_calls))
print('sample',sorted(reachable_calls)[:10])
PY" in /tmp/codex-i7ao1p3r succeeded in 44ms:
call blocks 33
sstore blocks 9
call blocks that can reach sstore 15
sample [2238, 2386, 2467, 2572, 2671, 2710, 2818, 2935, 3366, 3466]

thinking
**Analyzing call-to-sstore block relations**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict, deque
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
# Graph
edges=data['analysis_artifact']['artifact_json']['cfg_edges']
adj=defaultdict(list)
for e in edges:
    frm=int(e['from'].split(':')[1])
    to=int(e['to'].split(':')[1])
    adj[frm].append(to)

call_blocks=[b['start_pc'] for b in blocks if 'CALL' in b['opcodes']]
sstore_blocks=[b['start_pc'] for b in blocks if 'SSTORE' in b['opcodes']]
call_blocks=set(call_blocks); sstore_blocks=set(sstore_blocks)

# Find one path from a call block to a sstore block

def find_path(start, targets, max_nodes=2000):
    dq=deque([start])
    prev={start: None}
    while dq:
        cur=dq.popleft()
        if cur in targets and cur"'!=start:
            # build path
            path=[]
            while cur is not None:
                path.append(cur)
                cur=prev[cur]
            return list(reversed(path))
        for nxt in adj.get(cur,[]):
            if nxt not in prev:
                prev[nxt]=cur
                dq.append(nxt)
    return None

# pick a call block with reachable sstore
for cb in sorted(call_blocks):
    path=find_path(cb,sstore_blocks)
    if path:
        print('"'call block',cb,'-> sstore',path[-1],'path',path[:5],'... len',len(path))
        break
PY" in /tmp/codex-i7ao1p3r succeeded in 43ms:
call block 2238 -> sstore 4470 path [2238, 2344, 2367, 2386, 2467] ... len 18

thinking
**Analyzing SSTORE block references**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
sstore_blocks=sorted({b['start_pc'] for b in blocks if 'SSTORE' in b['opcodes']})
print('sstore blocks',sstore_blocks)
PY" in /tmp/codex-i7ao1p3r succeeded in 56ms:
sstore blocks [1654, 3147, 4422, 4470, 4514, 4550, 4601, 4652, 4703]

thinking
**Checking SSTORE opcode locations**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks={b['start_pc']:b for b in data['analysis_artifact']['artifact_json']['basic_blocks']}
for pc in [4422,4470,4514,4550,4601,4652,4703]:
    b=blocks[pc]
    print(pc,b['opcodes'])
PY" in /tmp/codex-i7ao1p3r succeeded in 31ms:
4422 ['JUMPDEST', 'PUSH1', 'OP_80', 'SLOAD', 'PUSH20', 'NOT', 'OP_90', 'OP_81', 'AND', 'OP_83', 'OR', 'OP_90', 'OP_91', 'SSTORE', 'PUSH1', 'OP_80', 'SLOAD', 'OP_90', 'OP_91', 'AND', 'OP_82', 'OR', 'OP_90', 'SSTORE', 'POP', 'JUMP']
4470 ['JUMPDEST', 'POP', 'PUSH1', 'SLOAD', 'PUSH1', 'SLOAD', 'TIMESTAMP', 'OP_91', 'OP_90', 'OP_91', 'SUB', 'OP_81', 'SUB', 'PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH1', 'SLOAD', 'PUSH3', 'OP_91', 'OP_90', 'OP_92', 'SUB', 'DIV', 'PUSH1', 'ADD', 'OP_90', 'OP_81', 'OP_90', 'LT', 'ISZERO', 'PUSH2', 'JUMPI']
4514 ['PUSH1', 'OP_81', 'OP_90', 'SSTORE', 'PUSH1', 'OP_81', 'LT', 'OP_80', 'ISZERO', 'OP_90', 'PUSH2', 'JUMPI']
4550 ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE']
4601 ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE']
4652 ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE']
4703 ['PUSH7', 'PUSH1', 'SSTORE', 'PUSH1', 'PUSH1', 'SSTORE', 'POP', 'JUMP']

thinking
**Analyzing SSTORE and call blocks**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks={b['start_pc']:b for b in data['analysis_artifact']['artifact_json']['basic_blocks']}
for pc in [2238,2386,2467]:
    b=blocks.get(pc)
    if b:
        print(pc,b['opcodes'][:40])
PY" in /tmp/codex-i7ao1p3r succeeded in 72ms:
2238 ['JUMPDEST', 'PUSH1', 'SLOAD', 'PUSH1', 'OP_80', 'MLOAD', 'OP_87', 'MLOAD', 'PUSH1', 'OP_89', 'OP_81', 'ADD', 'MLOAD', 'PUSH32', 'OP_84', 'MSTORE', 'OP_93', 'MLOAD', 'OP_91', 'OP_97', 'POP', 'OP_92', 'OP_95', 'POP', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'OP_93', 'OP_90', 'OP_93', 'AND', 'OP_92', 'PUSH4', 'OP_92', 'PUSH1', 'OP_83', 'OP_81', 'ADD']
2386 ['JUMPDEST', 'PUSH1', 'SLOAD', 'PUSH1', 'OP_80', 'MLOAD', 'PUSH1', 'PUSH1', 'EXP', 'PUSH4', 'MUL', 'OP_81', 'MSTORE', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'CALLER', 'OP_81', 'AND', 'PUSH1', 'OP_83', 'ADD', 'MSTORE', 'OP_91', 'MLOAD', 'OP_92', 'OP_90', 'OP_91', 'AND', 'OP_91', 'PUSH4', 'OP_91', 'PUSH1', 'OP_81', 'OP_81', 'ADD', 'OP_92', 'PUSH1']
2467 ['POP', 'PUSH1', 'OP_80', 'MLOAD', 'OP_80', 'MLOAD', 'PUSH1', 'SLOAD', 'PUSH1', 'PUSH1', 'EXP', 'PUSH4', 'MUL', 'OP_83', 'MSTORE', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'CALLER', 'OP_81', 'AND', 'PUSH1', 'OP_85', 'ADD', 'MSTORE', 'OP_93', 'MLOAD', 'OP_91', 'OP_95', 'POP', 'OP_88', 'OP_94', 'OP_93', 'AND', 'OP_92', 'OP_91', 'PUSH1', 'OP_81']

thinking
**Checking full call block opcodes**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks={b['start_pc']:b for b in data['analysis_artifact']['artifact_json']['basic_blocks']}
print(blocks[2238]['opcodes'])
PY" in /tmp/codex-i7ao1p3r succeeded in 40ms:
['JUMPDEST', 'PUSH1', 'SLOAD', 'PUSH1', 'OP_80', 'MLOAD', 'OP_87', 'MLOAD', 'PUSH1', 'OP_89', 'OP_81', 'ADD', 'MLOAD', 'PUSH32', 'OP_84', 'MSTORE', 'OP_93', 'MLOAD', 'OP_91', 'OP_97', 'POP', 'OP_92', 'OP_95', 'POP', 'PUSH1', 'PUSH1', 'PUSH1', 'EXP', 'SUB', 'OP_93', 'OP_90', 'OP_93', 'AND', 'OP_92', 'PUSH4', 'OP_92', 'PUSH1', 'OP_83', 'OP_81', 'ADD', 'OP_93', 'OP_91', 'OP_92', 'OP_91', 'OP_82', 'OP_90', 'SUB', 'ADD', 'OP_81', 'PUSH1', 'OP_87', 'PUSH2', 'GAS', 'SUB', 'CALL', 'ISZERO', 'PUSH2', 'JUMPI']

thinking
**Analyzing call blocks for security risks**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict, deque
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
# graph edges
edges=data['analysis_artifact']['artifact_json']['cfg_edges']
adj=defaultdict(list)
for e in edges:
    frm=int(e['from'].split(':')[1])
    to=int(e['to'].split(':')[1])
    adj[frm].append(to)

# guard blocks
guard_blocks=set()
for b in blocks:
    ops=b['opcodes']
    if 'CALLER' in ops and 'EQ' in ops and 'JUMPI' in ops:
        guard_blocks.add(b['start_pc'])

call_blocks=[b['start_pc'] for b in blocks if 'CALL' in b['opcodes']]

# BFS from entry without passing through guard blocks (except if guard is entry?)
entry=0
# precompute reachable without guards
seen=set([entry])
dq=deque([entry])
while dq:
    cur=dq.popleft()
    for nxt in adj.get(cur,[]):
        if nxt in seen: continue
        if nxt in guard_blocks:  # stop at guards
            continue
        seen.add(nxt)
        dq.append(nxt)

# call blocks reachable without any guard
unguarded_calls=[cb for cb in call_blocks if cb in seen]
print('unguarded call blocks reachable from entry without guard',len(unguarded_calls))
print(sorted(unguarded_calls)[:10])
PY" in /tmp/codex-i7ao1p3r succeeded in 66ms:
unguarded call blocks reachable from entry without guard 10
[746, 1048, 1102, 1281, 1370, 1779, 1877, 2000, 3171, 3265]

thinking
**Analyzing unguarded external calls and reentrancy risks**

I'm examining reachable call blocks without detected guards, indicating some calls might be unprotected. I plan to highlight potential external calls with computed targets and ETH value transfer, noting severity conservatively due to uncertainty. I'll gather evidence by listing callsite PCs, noting absence of clear reentrancy guards where calls precede state changes, and mention computed call values to support findings.
exec
/bin/bash -lc "python - <<'PY'
pcs=[1006,1071,1239,1328,1397,2238,2386,2467,3171,3265,3748]
print({pc:hex(pc) for pc in pcs})
PY" in /tmp/codex-i7ao1p3r succeeded in 22ms:
{1006: '0x3ee', 1071: '0x42f', 1239: '0x4d7', 1328: '0x530', 1397: '0x575', 2238: '0x8be', 2386: '0x952', 2467: '0x9a3', 3171: '0xc63', 3265: '0xcc1', 3748: '0xea4'}

thinking
**Noting store pcs for conversion**
exec
/bin/bash -lc "python - <<'PY'
pcs=[1654,3147,4422,4470,4514,4550,4601,4652,4703]
print({pc:hex(pc) for pc in pcs})
PY" in /tmp/codex-i7ao1p3r succeeded in 55ms:
{1654: '0x676', 3147: '0xc4b', 4422: '0x1146', 4470: '0x1176', 4514: '0x11a2', 4550: '0x11c6', 4601: '0x11f9', 4652: '0x122c', 4703: '0x125f'}

thinking
**Analyzing reentrancy and access control risks**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict, deque
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
blocks=data['analysis_artifact']['artifact_json']['basic_blocks']
# graph
edges=data['analysis_artifact']['artifact_json']['cfg_edges']
adj=defaultdict(list)
for e in edges:
    frm=int(e['from'].split(':')[1])
    to=int(e['to'].split(':')[1])
    adj[frm].append(to)
# guard blocks

guard_blocks=set()
for b in blocks:
    ops=b['opcodes']
    if 'CALLER' in ops and 'EQ' in ops and 'JUMPI' in ops:
        guard_blocks.add(b['start_pc'])

sstore_blocks={b['start_pc'] for b in blocks if 'SSTORE' in b['opcodes']}
# BFS from entry without guard
entry=0
seen=set([entry])
dq=deque([entry])
while dq:
    cur=dq.popleft()
    for nxt in adj.get(cur,[]):
        if nxt in seen: continue
        if nxt in guard_blocks: continue
        seen.add(nxt)
        dq.append(nxt)

unguarded_sstores=[s for s in sstore_blocks if s in seen]
print('unguarded sstore blocks reachable from entry without guard',unguarded_sstores)
PY" in /tmp/codex-i7ao1p3r succeeded in 80ms:
unguarded sstore blocks reachable from entry without guard []

thinking
**Analyzing low-level CALL risks and reentrancy**

I'm examining the contract bytecode for risks involving low-level CALLs with computed targets and values, noting that several of these calls might occur without explicit access control guards. This raises concerns about arbitrary external calls and ETH transfers if the call targets are user-influenced. I'm also noting possible reentrancy vulnerabilities where external CALLs precede state updates without reentrancy guards. While a number of calls appear internal or to self, the potential for bypassing protections through crafted calls remains, so I’ll include detailed findings with evidence and uncertainty about some target resolutions.
codex
{"no_findings":false,"summary":"Bytecode is call-heavy with 33 low-level CALL sites using computed targets/values. Some CALL paths are reachable without detected auth checks and can flow to state writes, which raises access-control and reentrancy concerns (bytecode-only analysis is inherently uncertain).","findings":[{"severity":"medium","category":"access_control","title":"Potentially unguarded arbitrary CALL/ETH transfer entrypoints","exploit_scenario":"If any externally callable function routes user-controlled calldata into these low-level CALLs without a strict caller check, an attacker could instruct the contract to call arbitrary targets with ETH, draining contract balance or triggering unintended external interactions. The detector validation sometimes resolved targets to the contract itself, so exposure depends on the actual ABI and how targets are sourced.","recommendation":"Confirm which selectors/entrypoints reach CALL sites and ensure strict access control or target/value allowlisting. If this is intended as an executor, enforce role checks and consider limiting value or target ranges.","evidence":"33 CALL callsites with computed target/value (returndata_check unknown). Examples at pc 0x3ee, 0x42f, 0x4d7. Detector flagged “Untrusted CALL target/value reachable” and “ETH value transfer possible”; validation was inconclusive about whether targets always vary or are self-calls.","locations":["pc:0x3ee","pc:0x42f","pc:0x4d7","pc:0x530","pc:0x575"]},{"severity":"low","category":"reentrancy","title":"External CALLs can reach state writes without a detected reentrancy guard","exploit_scenario":"If any CALL target is untrusted, it could reenter before later SSTOREs along the same control flow and manipulate contract state (e.g., repeated updates or invariant breaks). Evidence is indirect due to bytecode-only analysis.","recommendation":"Apply checks-effects-interactions and/or a reentrancy guard around CALL paths that can reach SSTORE. Consider constraining call targets to trusted contracts if reentrancy is not intended.","evidence":"CFG reachability shows a CALL at pc 0x8be can reach SSTORE blocks at pc 0x1176/0x1146. No explicit guard detected in auth.guards; CALL targets are computed per callsite metadata.","locations":["pc:0x8be","pc:0x1146","pc:0x1176"]}]}
tokens used
59,037

{
    "codex": {
        "ran_at": "2026-01-11T00:07:31.039538+00:00",
        "returncode": 0
    },
    "project": {
        "mode": "bytecode",
        "bytecode_length": 9858,
        "bytecode_truncated": false,
        "capability_graph_present": true,
        "analysis_artifact_present": true
    },
    "summary": "Bytecode is call-heavy with 33 low-level CALL sites using computed targets/values. Some CALL paths are reachable without detected auth checks and can flow to state writes, which raises access-control and reentrancy concerns (bytecode-only analysis is inherently uncertain).",
    "raw_final": {
        "summary": "Bytecode is call-heavy with 33 low-level CALL sites using computed targets/values. Some CALL paths are reachable without detected auth checks and can flow to state writes, which raises access-control and reentrancy concerns (bytecode-only analysis is inherently uncertain).",
        "findings": [
            {
                "title": "Potentially unguarded arbitrary CALL/ETH transfer entrypoints",
                "category": "access_control",
                "evidence": "33 CALL callsites with computed target/value (returndata_check unknown). Examples at pc 0x3ee, 0x42f, 0x4d7. Detector flagged \u201cUntrusted CALL target/value reachable\u201d and \u201cETH value transfer possible\u201d; validation was inconclusive about whether targets always vary or are self-calls.",
                "severity": "medium",
                "locations": [
                    "pc:0x3ee",
                    "pc:0x42f",
                    "pc:0x4d7",
                    "pc:0x530",
                    "pc:0x575"
                ],
                "recommendation": "Confirm which selectors/entrypoints reach CALL sites and ensure strict access control or target/value allowlisting. If this is intended as an executor, enforce role checks and consider limiting value or target ranges.",
                "exploit_scenario": "If any externally callable function routes user-controlled calldata into these low-level CALLs without a strict caller check, an attacker could instruct the contract to call arbitrary targets with ETH, draining contract balance or triggering unintended external interactions. The detector validation sometimes resolved targets to the contract itself, so exposure depends on the actual ABI and how targets are sourced."
            },
            {
                "title": "External CALLs can reach state writes without a detected reentrancy guard",
                "category": "reentrancy",
                "evidence": "CFG reachability shows a CALL at pc 0x8be can reach SSTORE blocks at pc 0x1176/0x1146. No explicit guard detected in auth.guards; CALL targets are computed per callsite metadata.",
                "severity": "low",
                "locations": [
                    "pc:0x8be",
                    "pc:0x1146",
                    "pc:0x1176"
                ],
                "recommendation": "Apply checks-effects-interactions and/or a reentrancy guard around CALL paths that can reach SSTORE. Consider constraining call targets to trusted contracts if reentrancy is not intended.",
                "exploit_scenario": "If any CALL target is untrusted, it could reenter before later SSTOREs along the same control flow and manipulate contract state (e.g., repeated updates or invariant breaks). Evidence is indirect due to bytecode-only analysis."
            }
        ],
        "no_findings": false
    },
    "no_findings": false,
    "schema_version": 1
}

00000000: PUSH1 0x60
00000002: PUSH1 0x40
00000004: MSTORE
00000005: CALLDATASIZE
00000006: ISZERO
00000007: PUSH2 0x00a3
0000000a: JUMPI
0000000b: PUSH1 0xe0
0000000d: PUSH1 0x02
0000000f: EXP
00000010: PUSH1 0x00
00000012: CALLDATALOAD
00000013: DIV
00000014: PUSH4 0x303bdbe8
00000019: DUP2
0000001a: EQ
0000001b: PUSH2 0x00a5
0000001e: JUMPI
0000001f: DUP1
00000020: PUSH4 0x52c665bd
00000025: EQ
00000026: PUSH2 0x00be
00000029: JUMPI
0000002a: DUP1
0000002b: PUSH4 0x66b87b2a
00000030: EQ
00000031: PUSH2 0x0111
00000034: JUMPI
00000035: DUP1
00000036: PUSH4 0x6c0f79b6
0000003b: EQ
0000003c: PUSH2 0x0136
0000003f: JUMPI
00000040: DUP1
00000041: PUSH4 0x729048ef
00000046: EQ
00000047: PUSH2 0x014f
0000004a: JUMPI
0000004b: DUP1
0000004c: PUSH4 0x72de5b2f
00000051: EQ
00000052: PUSH2 0x016d
00000055: JUMPI
00000056: DUP1
00000057: PUSH4 0x7b76ac91
0000005c: EQ
0000005d: PUSH2 0x01b2
00000060: JUMPI
00000061: DUP1
00000062: PUSH4 0x91ff2c86
00000067: EQ
00000068: PUSH2 0x01bb
0000006b: JUMPI
0000006c: DUP1
0000006d: PUSH4 0xa17ca4f3
00000072: EQ
00000073: PUSH2 0x01d0
00000076: JUMPI
00000077: DUP1
00000078: PUSH4 0xbbfff47d
0000007d: EQ
0000007e: PUSH2 0x027b
00000081: JUMPI
00000082: DUP1
00000083: PUSH4 0xc84f17a5
00000088: EQ
00000089: PUSH2 0x029d
0000008c: JUMPI
0000008d: DUP1
0000008e: PUSH4 0xe1b0d5e6
00000093: EQ
00000094: PUSH2 0x02ea
00000097: JUMPI
00000098: DUP1
00000099: PUSH4 0xe1c7392a
0000009e: EQ
0000009f: PUSH2 0x058e
000000a2: JUMPI
000000a3: JUMPDEST
000000a4: STOP
000000a5: JUMPDEST
000000a6: PUSH2 0x05ac
000000a9: PUSH1 0x04
000000ab: CALLDATALOAD
000000ac: JUMPDEST
000000ad: PUSH1 0x02
000000af: SLOAD
000000b0: PUSH1 0x00
000000b2: SWAP1
000000b3: DUP3
000000b4: LT
000000b5: ISZERO
000000b6: PUSH2 0x0c5a
000000b9: JUMPI
000000ba: PUSH2 0x0002
000000bd: JUMP
000000be: JUMPDEST
000000bf: PUSH2 0x05be
000000c2: PUSH1 0x04
000000c4: CALLDATALOAD
000000c5: JUMPDEST
000000c6: PUSH1 0x40
000000c8: PUSH1 0x40
000000ca: MLOAD
000000cb: SWAP1
000000cc: DUP2
000000cd: ADD
000000ce: PUSH1 0x40
000000d0: MSTORE
000000d1: DUP1
000000d2: PUSH1 0x02
000000d4: SWAP1
000000d5: JUMPDEST
000000d6: PUSH1 0x00
000000d8: DUP2
000000d9: MSTORE
000000da: PUSH1 0x20
000000dc: ADD
000000dd: SWAP1
000000de: PUSH1 0x01
000000e0: SWAP1
000000e1: SUB
000000e2: SWAP1
000000e3: DUP2
000000e4: PUSH2 0x00d5
000000e7: JUMPI
000000e8: POP
000000e9: POP
000000ea: PUSH1 0x01
000000ec: DUP1
000000ed: SLOAD
000000ee: PUSH8 0x0de0b6b3a7640000
000000f7: DUP1
000000f8: DUP6
000000f9: MOD
000000fa: SWAP3
000000fb: DUP4
000000fc: DUP7
000000fd: SUB
000000fe: SWAP2
000000ff: SWAP1
00000100: SWAP2
00000101: DIV
00000102: SWAP1
00000103: SWAP2
00000104: MUL
00000105: SWAP1
00000106: DUP2
00000107: LT
00000108: ISZERO
00000109: PUSH2 0x06d8
0000010c: JUMPI
0000010d: PUSH2 0x0002
00000110: JUMP
00000111: JUMPDEST
00000112: PUSH2 0x00a3
00000115: PUSH1 0x04
00000117: CALLDATALOAD
00000118: PUSH1 0x24
0000011a: CALLDATALOAD
0000011b: PUSH1 0x09
0000011d: SLOAD
0000011e: PUSH1 0x01
00000120: PUSH1 0xa0
00000122: PUSH1 0x02
00000124: EXP
00000125: SUB
00000126: SWAP1
00000127: DUP2
00000128: AND
00000129: CALLER
0000012a: SWAP1
0000012b: SWAP2
0000012c: AND
0000012d: EQ
0000012e: PUSH2 0x10d2
00000131: JUMPI
00000132: PUSH2 0x0002
00000135: JUMP
00000136: JUMPDEST
00000137: PUSH2 0x05e2
0000013a: PUSH1 0x0b
0000013c: SLOAD
0000013d: PUSH1 0x0c
0000013f: SLOAD
00000140: PUSH1 0x01
00000142: PUSH1 0xa0
00000144: PUSH1 0x02
00000146: EXP
00000147: SUB
00000148: SWAP2
00000149: DUP3
0000014a: AND
0000014b: SWAP2
0000014c: AND
0000014d: DUP3
0000014e: JUMP
0000014f: JUMPDEST
00000150: PUSH1 0x40
00000152: DUP1
00000153: MLOAD
00000154: PUSH1 0x0a
00000156: SLOAD
00000157: PUSH1 0x01
00000159: PUSH1 0xa0
0000015b: PUSH1 0x02
0000015d: EXP
0000015e: SUB
0000015f: AND
00000160: DUP2
00000161: MSTORE
00000162: SWAP1
00000163: MLOAD
00000164: SWAP1
00000165: DUP2
00000166: SWAP1
00000167: SUB
00000168: PUSH1 0x20
0000016a: ADD
0000016b: SWAP1
0000016c: RETURN
0000016d: JUMPDEST
0000016e: PUSH2 0x0611
00000171: PUSH1 0x00
00000173: SLOAD
00000174: PUSH1 0x02
00000176: SLOAD
00000177: PUSH1 0x08
00000179: SLOAD
0000017a: PUSH1 0x09
0000017c: SLOAD
0000017d: PUSH1 0x01
0000017f: SLOAD
00000180: PUSH1 0x03
00000182: SLOAD
00000183: PUSH1 0x04
00000185: SLOAD
00000186: PUSH1 0x05
00000188: SLOAD
00000189: PUSH1 0x06
0000018b: SLOAD
0000018c: PUSH1 0x07
0000018e: SLOAD
0000018f: PUSH1 0x0a
00000191: SLOAD
00000192: SWAP6
00000193: SWAP9
00000194: SWAP8
00000195: SWAP5
00000196: SWAP7
00000197: SWAP4
00000198: SWAP6
00000199: SWAP3
0000019a: SWAP5
0000019b: SWAP2
0000019c: SWAP4
0000019d: SWAP1
0000019e: SWAP3
0000019f: PUSH1 0x01
000001a1: PUSH1 0xa0
000001a3: PUSH1 0x02
000001a5: EXP
000001a6: SUB
000001a7: SWAP3
000001a8: DUP4
000001a9: AND
000001aa: SWAP3
000001ab: SWAP2
000001ac: DUP3
000001ad: AND
000001ae: SWAP2
000001af: AND
000001b0: DUP12
000001b1: JUMP
000001b2: JUMPDEST
000001b3: PUSH2 0x05ac
000001b6: PUSH1 0x0d
000001b8: SLOAD
000001b9: DUP2
000001ba: JUMP
000001bb: JUMPDEST
000001bc: PUSH2 0x00a3
000001bf: JUMPDEST
000001c0: PUSH1 0x07
000001c2: SLOAD
000001c3: PUSH1 0x00
000001c5: SWAP1
000001c6: DUP2
000001c7: EQ
000001c8: PUSH2 0x0c63
000001cb: JUMPI
000001cc: PUSH2 0x0002
000001cf: JUMP
000001d0: JUMPDEST
000001d1: PUSH1 0x40
000001d3: DUP1
000001d4: MLOAD
000001d5: PUSH1 0x20
000001d7: PUSH1 0x24
000001d9: DUP1
000001da: CALLDATALOAD
000001db: PUSH1 0x04
000001dd: DUP2
000001de: DUP2
000001df: ADD
000001e0: CALLDATALOAD
000001e1: PUSH1 0x1f
000001e3: DUP2
000001e4: ADD
000001e5: DUP6
000001e6: SWAP1
000001e7: DIV
000001e8: DUP6
000001e9: MUL
000001ea: DUP7
000001eb: ADD
000001ec: DUP6
000001ed: ADD
000001ee: SWAP1
000001ef: SWAP7
000001f0: MSTORE
000001f1: DUP6
000001f2: DUP6
000001f3: MSTORE
000001f4: PUSH2 0x00a3
000001f7: SWAP6
000001f8: DUP2
000001f9: CALLDATALOAD
000001fa: SWAP6
000001fb: SWAP2
000001fc: SWAP5
000001fd: PUSH1 0x44
000001ff: SWAP5
00000200: SWAP3
00000201: SWAP4
00000202: SWAP1
00000203: SWAP3
00000204: ADD
00000205: SWAP2
00000206: DUP2
00000207: SWAP1
00000208: DUP5
00000209: ADD
0000020a: DUP4
0000020b: DUP3
0000020c: DUP1
0000020d: DUP3
0000020e: DUP5
0000020f: CALLDATACOPY
00000210: POP
00000211: POP
00000212: PUSH1 0x40
00000214: DUP1
00000215: MLOAD
00000216: PUSH1 0x20
00000218: SWAP8
00000219: CALLDATALOAD
0000021a: DUP1
0000021b: DUP11
0000021c: ADD
0000021d: CALLDATALOAD
0000021e: PUSH1 0x1f
00000220: DUP2
00000221: ADD
00000222: DUP11
00000223: SWAP1
00000224: DIV
00000225: DUP11
00000226: MUL
00000227: DUP4
00000228: ADD
00000229: DUP11
0000022a: ADD
0000022b: SWAP1
0000022c: SWAP4
0000022d: MSTORE
0000022e: DUP3
0000022f: DUP3
00000230: MSTORE
00000231: SWAP7
00000232: SWAP9
00000233: SWAP8
00000234: PUSH1 0x64
00000236: SWAP8
00000237: SWAP2
00000238: SWAP7
00000239: POP
0000023a: PUSH1 0x24
0000023c: SWAP2
0000023d: SWAP1
0000023e: SWAP2
0000023f: ADD
00000240: SWAP5
00000241: POP
00000242: SWAP1
00000243: SWAP3
00000244: POP
00000245: DUP3
00000246: SWAP2
00000247: POP
00000248: DUP5
00000249: ADD
0000024a: DUP4
0000024b: DUP3
0000024c: DUP1
0000024d: DUP3
0000024e: DUP5
0000024f: CALLDATACOPY
00000250: POP
00000251: SWAP5
00000252: SWAP7
00000253: POP
00000254: POP
00000255: SWAP4
00000256: CALLDATALOAD
00000257: SWAP4
00000258: POP
00000259: POP
0000025a: PUSH1 0x84
0000025c: CALLDATALOAD
0000025d: SWAP2
0000025e: POP
0000025f: POP
00000260: PUSH1 0x09
00000262: SLOAD
00000263: PUSH1 0x01
00000265: PUSH1 0xa0
00000267: PUSH1 0x02
00000269: EXP
0000026a: SUB
0000026b: SWAP1
0000026c: DUP2
0000026d: AND
0000026e: CALLER
0000026f: SWAP1
00000270: SWAP2
00000271: AND
00000272: EQ
00000273: PUSH2 0x0eeb
00000276: JUMPI
00000277: PUSH2 0x0002
0000027a: JUMP
0000027b: JUMPDEST
0000027c: PUSH2 0x00a3
0000027f: PUSH1 0x04
00000281: CALLDATALOAD
00000282: PUSH1 0x08
00000284: SLOAD
00000285: PUSH1 0x01
00000287: PUSH1 0xa0
00000289: PUSH1 0x02
0000028b: EXP
0000028c: SUB
0000028d: SWAP1
0000028e: DUP2
0000028f: AND
00000290: CALLER
00000291: SWAP1
00000292: SWAP2
00000293: AND
00000294: EQ
00000295: PUSH2 0x1146
00000298: JUMPI
00000299: PUSH2 0x0002
0000029c: JUMP
0000029d: JUMPDEST
0000029e: PUSH2 0x00a3
000002a1: JUMPDEST
000002a2: PUSH1 0x40
000002a4: PUSH1 0x40
000002a6: MLOAD
000002a7: SWAP1
000002a8: DUP2
000002a9: ADD
000002aa: PUSH1 0x40
000002ac: MSTORE
000002ad: DUP1
000002ae: PUSH1 0x02
000002b0: SWAP1
000002b1: JUMPDEST
000002b2: PUSH1 0x00
000002b4: DUP2
000002b5: MSTORE
000002b6: PUSH1 0x20
000002b8: ADD
000002b9: SWAP1
000002ba: PUSH1 0x01
000002bc: SWAP1
000002bd: SUB
000002be: SWAP1
000002bf: DUP2
000002c0: PUSH2 0x02b1
000002c3: JUMPI
000002c4: POP
000002c5: POP
000002c6: PUSH1 0x06
000002c8: SLOAD
000002c9: PUSH1 0x00
000002cb: SWAP1
000002cc: DUP2
000002cd: SWAP1
000002ce: DUP2
000002cf: SWAP1
000002d0: DUP2
000002d1: SWAP1
000002d2: TIMESTAMP
000002d3: LT
000002d4: DUP1
000002d5: PUSH2 0x02e0
000002d8: JUMPI
000002d9: POP
000002da: PUSH1 0x07
000002dc: SLOAD
000002dd: DUP2
000002de: EQ
000002df: ISZERO
000002e0: JUMPDEST
000002e1: ISZERO
000002e2: PUSH2 0x06f3
000002e5: JUMPI
000002e6: PUSH2 0x0002
000002e9: JUMP
000002ea: JUMPDEST
000002eb: PUSH1 0x40
000002ed: DUP1
000002ee: MLOAD
000002ef: PUSH1 0x20
000002f1: PUSH1 0x24
000002f3: DUP1
000002f4: CALLDATALOAD
000002f5: PUSH1 0x04
000002f7: DUP2
000002f8: DUP2
000002f9: ADD
000002fa: CALLDATALOAD
000002fb: PUSH1 0x1f
000002fd: DUP2
000002fe: ADD
000002ff: DUP6
00000300: SWAP1
00000301: DIV
00000302: DUP6
00000303: MUL
00000304: DUP7
00000305: ADD
00000306: DUP6
00000307: ADD
00000308: SWAP1
00000309: SWAP7
0000030a: MSTORE
0000030b: DUP6
0000030c: DUP6
0000030d: MSTORE
0000030e: PUSH2 0x00a3
00000311: SWAP6
00000312: DUP2
00000313: CALLDATALOAD
00000314: SWAP6
00000315: SWAP2
00000316: SWAP5
00000317: PUSH1 0x44
00000319: SWAP5
0000031a: SWAP3
0000031b: SWAP4
0000031c: SWAP1
0000031d: SWAP3
0000031e: ADD
0000031f: SWAP2
00000320: DUP2
00000321: SWAP1
00000322: DUP5
00000323: ADD
00000324: DUP4
00000325: DUP3
00000326: DUP1
00000327: DUP3
00000328: DUP5
00000329: CALLDATACOPY
0000032a: POP
0000032b: POP
0000032c: PUSH1 0x40
0000032e: DUP1
0000032f: MLOAD
00000330: PUSH1 0x20
00000332: SWAP8
00000333: CALLDATALOAD
00000334: DUP1
00000335: DUP11
00000336: ADD
00000337: CALLDATALOAD
00000338: PUSH1 0x1f
0000033a: DUP2
0000033b: ADD
0000033c: DUP11
0000033d: SWAP1
0000033e: DIV
0000033f: DUP11
00000340: MUL
00000341: DUP4
00000342: ADD
00000343: DUP11
00000344: ADD
00000345: SWAP1
00000346: SWAP4
00000347: MSTORE
00000348: DUP3
00000349: DUP3
0000034a: MSTORE
0000034b: SWAP7
0000034c: SWAP9
0000034d: SWAP8
0000034e: PUSH1 0x64
00000350: SWAP8
00000351: SWAP2
00000352: SWAP7
00000353: POP
00000354: PUSH1 0x24
00000356: SWAP2
00000357: SWAP1
00000358: SWAP2
00000359: ADD
0000035a: SWAP5
0000035b: POP
0000035c: SWAP1
0000035d: SWAP3
0000035e: POP
0000035f: DUP3
00000360: SWAP2
00000361: POP
00000362: DUP5
00000363: ADD
00000364: DUP4
00000365: DUP3
00000366: DUP1
00000367: DUP3
00000368: DUP5
00000369: CALLDATACOPY
0000036a: POP
0000036b: SWAP5
0000036c: SWAP7
0000036d: POP
0000036e: POP
0000036f: SWAP4
00000370: CALLDATALOAD
00000371: SWAP4
00000372: POP
00000373: POP
00000374: POP
00000375: POP
00000376: PUSH1 0x0b
00000378: SLOAD
00000379: PUSH1 0x40
0000037b: MLOAD
0000037c: PUSH32 0xa5d87c4000000000000000000000000000000000000000000000000000000000
0000039d: DUP2
0000039e: MSTORE
0000039f: PUSH1 0x20
000003a1: PUSH1 0x04
000003a3: DUP3
000003a4: DUP2
000003a5: ADD
000003a6: DUP3
000003a7: DUP2
000003a8: MSTORE
000003a9: DUP8
000003aa: MLOAD
000003ab: PUSH1 0x24
000003ad: DUP6
000003ae: ADD
000003af: MSTORE
000003b0: DUP8
000003b1: MLOAD
000003b2: PUSH1 0x01
000003b4: PUSH1 0xa0
000003b6: PUSH1 0x02
000003b8: EXP
000003b9: SUB
000003ba: SWAP6
000003bb: SWAP1
000003bc: SWAP6
000003bd: AND
000003be: SWAP5
000003bf: PUSH4 0xa5d87c40
000003c4: SWAP5
000003c5: DUP10
000003c6: SWAP5
000003c7: SWAP3
000003c8: SWAP4
000003c9: DUP5
000003ca: SWAP4
000003cb: PUSH1 0x44
000003cd: SWAP3
000003ce: SWAP1
000003cf: SWAP3
000003d0: ADD
000003d1: SWAP3
000003d2: DUP7
000003d3: DUP4
000003d4: ADD
000003d5: SWAP3
000003d6: SWAP1
000003d7: SWAP2
000003d8: DUP3
000003d9: SWAP2
000003da: DUP6
000003db: SWAP2
000003dc: DUP4
000003dd: SWAP2
000003de: DUP7
000003df: SWAP2
000003e0: PUSH1 0x00
000003e2: SWAP2
000003e3: PUSH1 0x1f
000003e5: DUP6
000003e6: ADD
000003e7: DIV
000003e8: PUSH1 0x0f
000003ea: MUL
000003eb: PUSH1 0x03
000003ed: ADD
000003ee: CALL
000003ef: POP
000003f0: SWAP1
000003f1: POP
000003f2: SWAP1
000003f3: DUP2
000003f4: ADD
000003f5: SWAP1
000003f6: PUSH1 0x1f
000003f8: AND
000003f9: DUP1
000003fa: ISZERO
000003fb: PUSH2 0x0418
000003fe: JUMPI
000003ff: DUP1
00000400: DUP3
00000401: SUB
00000402: DUP1
00000403: MLOAD
00000404: PUSH1 0x01
00000406: DUP4
00000407: PUSH1 0x20
00000409: SUB
0000040a: PUSH2 0x0100
0000040d: EXP
0000040e: SUB
0000040f: NOT
00000410: AND
00000411: DUP2
00000412: MSTORE
00000413: PUSH1 0x20
00000415: ADD
00000416: SWAP2
00000417: POP
00000418: JUMPDEST
00000419: POP
0000041a: SWAP3
0000041b: POP
0000041c: POP
0000041d: POP
0000041e: PUSH1 0x20
00000420: PUSH1 0x40
00000422: MLOAD
00000423: DUP1
00000424: DUP4
00000425: SUB
00000426: DUP2
00000427: PUSH1 0x00
00000429: DUP8
0000042a: PUSH2 0x61da
0000042d: GAS
0000042e: SUB
0000042f: CALL
00000430: ISZERO
00000431: PUSH2 0x0002
00000434: JUMPI
00000435: POP
00000436: POP
00000437: PUSH1 0x40
00000439: MLOAD
0000043a: MLOAD
0000043b: PUSH1 0x00
0000043d: EQ
0000043e: ISZERO
0000043f: SWAP1
00000440: POP
00000441: PUSH2 0x06d2
00000444: JUMPI
00000445: DUP4
00000446: PUSH1 0x00
00000448: EQ
00000449: ISZERO
0000044a: PUSH2 0x06b3
0000044d: JUMPI
0000044e: PUSH1 0x0b
00000450: PUSH1 0x00
00000452: POP
00000453: PUSH1 0x00
00000455: ADD
00000456: PUSH1 0x00
00000458: SWAP1
00000459: SLOAD
0000045a: SWAP1
0000045b: PUSH2 0x0100
0000045e: EXP
0000045f: SWAP1
00000460: DIV
00000461: PUSH1 0x01
00000463: PUSH1 0xa0
00000465: PUSH1 0x02
00000467: EXP
00000468: SUB
00000469: AND
0000046a: PUSH1 0x01
0000046c: PUSH1 0xa0
0000046e: PUSH1 0x02
00000470: EXP
00000471: SUB
00000472: AND
00000473: PUSH4 0x48a1eadc
00000478: CALLER
00000479: DUP6
0000047a: DUP6
0000047b: PUSH1 0x00
0000047d: PUSH1 0x40
0000047f: MLOAD
00000480: DUP6
00000481: PUSH1 0xe0
00000483: PUSH1 0x02
00000485: EXP
00000486: MUL
00000487: DUP2
00000488: MSTORE
00000489: PUSH1 0x04
0000048b: ADD
0000048c: DUP1
0000048d: DUP6
0000048e: PUSH1 0x01
00000490: PUSH1 0xa0
00000492: PUSH1 0x02
00000494: EXP
00000495: SUB
00000496: AND
00000497: DUP2
00000498: MSTORE
00000499: PUSH1 0x20
0000049b: ADD
0000049c: DUP1
0000049d: PUSH1 0x20
0000049f: ADD
000004a0: DUP1
000004a1: PUSH1 0x20
000004a3: ADD
000004a4: DUP5
000004a5: DUP2
000004a6: MSTORE
000004a7: PUSH1 0x20
000004a9: ADD
000004aa: DUP4
000004ab: DUP2
000004ac: SUB
000004ad: DUP4
000004ae: MSTORE
000004af: DUP7
000004b0: DUP2
000004b1: DUP2
000004b2: MLOAD
000004b3: DUP2
000004b4: MSTORE
000004b5: PUSH1 0x20
000004b7: ADD
000004b8: SWAP2
000004b9: POP
000004ba: DUP1
000004bb: MLOAD
000004bc: SWAP1
000004bd: PUSH1 0x20
000004bf: ADD
000004c0: SWAP1
000004c1: DUP1
000004c2: DUP4
000004c3: DUP4
000004c4: DUP3
000004c5: SWAP1
000004c6: PUSH1 0x00
000004c8: PUSH1 0x04
000004ca: PUSH1 0x20
000004cc: DUP5
000004cd: PUSH1 0x1f
000004cf: ADD
000004d0: DIV
000004d1: PUSH1 0x0f
000004d3: MUL
000004d4: PUSH1 0x03
000004d6: ADD
000004d7: CALL
000004d8: POP
000004d9: SWAP1
000004da: POP
000004db: SWAP1
000004dc: DUP2
000004dd: ADD
000004de: SWAP1
000004df: PUSH1 0x1f
000004e1: AND
000004e2: DUP1
000004e3: ISZERO
000004e4: PUSH2 0x0501
000004e7: JUMPI
000004e8: DUP1
000004e9: DUP3
000004ea: SUB
000004eb: DUP1
000004ec: MLOAD
000004ed: PUSH1 0x01
000004ef: DUP4
000004f0: PUSH1 0x20
000004f2: SUB
000004f3: PUSH2 0x0100
000004f6: EXP
000004f7: SUB
000004f8: NOT
000004f9: AND
000004fa: DUP2
000004fb: MSTORE
000004fc: PUSH1 0x20
000004fe: ADD
000004ff: SWAP2
00000500: POP
00000501: JUMPDEST
00000502: POP
00000503: DUP4
00000504: DUP2
00000505: SUB
00000506: DUP3
00000507: MSTORE
00000508: DUP6
00000509: DUP2
0000050a: DUP2
0000050b: MLOAD
0000050c: DUP2
0000050d: MSTORE
0000050e: PUSH1 0x20
00000510: ADD
00000511: SWAP2
00000512: POP
00000513: DUP1
00000514: MLOAD
00000515: SWAP1
00000516: PUSH1 0x20
00000518: ADD
00000519: SWAP1
0000051a: DUP1
0000051b: DUP4
0000051c: DUP4
0000051d: DUP3
0000051e: SWAP1
0000051f: PUSH1 0x00
00000521: PUSH1 0x04
00000523: PUSH1 0x20
00000525: DUP5
00000526: PUSH1 0x1f
00000528: ADD
00000529: DIV
0000052a: PUSH1 0x0f
0000052c: MUL
0000052d: PUSH1 0x03
0000052f: ADD
00000530: CALL
00000531: POP
00000532: SWAP1
00000533: POP
00000534: SWAP1
00000535: DUP2
00000536: ADD
00000537: SWAP1
00000538: PUSH1 0x1f
0000053a: AND
0000053b: DUP1
0000053c: ISZERO
0000053d: PUSH2 0x055a
00000540: JUMPI
00000541: DUP1
00000542: DUP3
00000543: SUB
00000544: DUP1
00000545: MLOAD
00000546: PUSH1 0x01
00000548: DUP4
00000549: PUSH1 0x20
0000054b: SUB
0000054c: PUSH2 0x0100
0000054f: EXP
00000550: SUB
00000551: NOT
00000552: AND
00000553: DUP2
00000554: MSTORE
00000555: PUSH1 0x20
00000557: ADD
00000558: SWAP2
00000559: POP
0000055a: JUMPDEST
0000055b: POP
0000055c: SWAP7
0000055d: POP
0000055e: POP
0000055f: POP
00000560: POP
00000561: POP
00000562: POP
00000563: POP
00000564: PUSH1 0x00
00000566: PUSH1 0x40
00000568: MLOAD
00000569: DUP1
0000056a: DUP4
0000056b: SUB
0000056c: DUP2
0000056d: PUSH1 0x00
0000056f: DUP8
00000570: PUSH2 0x61da
00000573: GAS
00000574: SUB
00000575: CALL
00000576: ISZERO
00000577: PUSH2 0x0002
0000057a: JUMPI
0000057b: POP
0000057c: POP
0000057d: POP
0000057e: DUP1
0000057f: PUSH1 0x01
00000581: EQ
00000582: ISZERO
00000583: PUSH2 0x06c1
00000586: JUMPI
00000587: PUSH2 0x06d2
0000058a: PUSH2 0x01bf
0000058d: JUMP
0000058e: JUMPDEST
0000058f: PUSH2 0x00a3
00000592: PUSH1 0x08
00000594: SLOAD
00000595: CALLER
00000596: PUSH1 0x01
00000598: PUSH1 0xa0
0000059a: PUSH1 0x02
0000059c: EXP
0000059d: SUB
0000059e: SWAP1
0000059f: DUP2
000005a0: AND
000005a1: SWAP2
000005a2: AND
000005a3: EQ
000005a4: PUSH2 0x0676
000005a7: JUMPI
000005a8: PUSH2 0x0002
000005ab: JUMP
000005ac: JUMPDEST
000005ad: PUSH1 0x40
000005af: DUP1
000005b0: MLOAD
000005b1: SWAP2
000005b2: DUP3
000005b3: MSTORE
000005b4: MLOAD
000005b5: SWAP1
000005b6: DUP2
000005b7: SWAP1
000005b8: SUB
000005b9: PUSH1 0x20
000005bb: ADD
000005bc: SWAP1
000005bd: RETURN
000005be: JUMPDEST
000005bf: PUSH1 0x40
000005c1: DUP1
000005c2: MLOAD
000005c3: SWAP1
000005c4: DUP2
000005c5: SWAP1
000005c6: DUP4
000005c7: SWAP1
000005c8: DUP1
000005c9: DUP4
000005ca: DUP2
000005cb: DUP5
000005cc: PUSH1 0x00
000005ce: PUSH1 0x04
000005d0: PUSH1 0x21
000005d2: CALL
000005d3: POP
000005d4: SWAP1
000005d5: POP
000005d6: ADD
000005d7: SWAP2
000005d8: POP
000005d9: POP
000005da: PUSH1 0x40
000005dc: MLOAD
000005dd: DUP1
000005de: SWAP2
000005df: SUB
000005e0: SWAP1
000005e1: RETURN
000005e2: JUMPDEST
000005e3: PUSH1 0x40
000005e5: MLOAD
000005e6: DUP1
000005e7: DUP4
000005e8: PUSH1 0x01
000005ea: PUSH1 0xa0
000005ec: PUSH1 0x02
000005ee: EXP
000005ef: SUB
000005f0: AND
000005f1: DUP2
000005f2: MSTORE
000005f3: PUSH1 0x20
000005f5: ADD
000005f6: DUP3
000005f7: PUSH1 0x01
000005f9: PUSH1 0xa0
000005fb: PUSH1 0x02
000005fd: EXP
000005fe: SUB
000005ff: AND
00000600: DUP2
00000601: MSTORE
00000602: PUSH1 0x20
00000604: ADD
00000605: SWAP3
00000606: POP
00000607: POP
00000608: POP
00000609: PUSH1 0x40
0000060b: MLOAD
0000060c: DUP1
0000060d: SWAP2
0000060e: SUB
0000060f: SWAP1
00000610: RETURN
00000611: JUMPDEST
00000612: PUSH1 0x40
00000614: DUP1
00000615: MLOAD
00000616: SWAP12
00000617: DUP13
00000618: MSTORE
00000619: PUSH1 0x20
0000061b: DUP13
0000061c: ADD
0000061d: SWAP11
0000061e: SWAP1
0000061f: SWAP11
00000620: MSTORE
00000621: DUP11
00000622: DUP11
00000623: ADD
00000624: SWAP9
00000625: SWAP1
00000626: SWAP9
00000627: MSTORE
00000628: PUSH1 0x60
0000062a: DUP11
0000062b: ADD
0000062c: SWAP7
0000062d: SWAP1
0000062e: SWAP7
0000062f: MSTORE
00000630: PUSH1 0x80
00000632: DUP10
00000633: ADD
00000634: SWAP5
00000635: SWAP1
00000636: SWAP5
00000637: MSTORE
00000638: PUSH1 0xa0
0000063a: DUP9
0000063b: ADD
0000063c: SWAP3
0000063d: SWAP1
0000063e: SWAP3
0000063f: MSTORE
00000640: PUSH1 0xc0
00000642: DUP8
00000643: ADD
00000644: MSTORE
00000645: PUSH1 0xe0
00000647: DUP7
00000648: ADD
00000649: MSTORE
0000064a: PUSH1 0x01
0000064c: PUSH1 0xa0
0000064e: PUSH1 0x02
00000650: EXP
00000651: SUB
00000652: SWAP1
00000653: DUP2
00000654: AND
00000655: PUSH2 0x0100
00000658: DUP7
00000659: ADD
0000065a: MSTORE
0000065b: SWAP1
0000065c: DUP2
0000065d: AND
0000065e: PUSH2 0x0120
00000661: DUP6
00000662: ADD
00000663: MSTORE
00000664: AND
00000665: PUSH2 0x0140
00000668: DUP4
00000669: ADD
0000066a: MSTORE
0000066b: MLOAD
0000066c: SWAP1
0000066d: DUP2
0000066e: SWAP1
0000066f: SUB
00000670: PUSH2 0x0160
00000673: ADD
00000674: SWAP1
00000675: RETURN
00000676: JUMPDEST
00000677: PUSH7 0x470de4df820000
0000067f: PUSH1 0x00
00000681: SWAP1
00000682: DUP2
00000683: SSTORE
00000684: PUSH1 0x32
00000686: PUSH1 0x01
00000688: SSTORE
00000689: PUSH8 0x8ac7230489e80000
00000692: PUSH1 0x02
00000694: SSTORE
00000695: PUSH1 0x03
00000697: DUP2
00000698: SWAP1
00000699: SSTORE
0000069a: PUSH3 0x03bfab
0000069e: TIMESTAMP
0000069f: ADD
000006a0: PUSH1 0x06
000006a2: SSTORE
000006a3: PUSH1 0x07
000006a5: SSTORE
000006a6: PUSH3 0x34bc00
000006aa: PUSH1 0x04
000006ac: DUP2
000006ad: SWAP1
000006ae: SSTORE
000006af: PUSH1 0x05
000006b1: SSTORE
000006b2: JUMP
000006b3: JUMPDEST
000006b4: DUP4
000006b5: PUSH1 0x01
000006b7: EQ
000006b8: ISZERO
000006b9: PUSH2 0x06d2
000006bc: JUMPI
000006bd: PUSH2 0x0002
000006c0: JUMP
000006c1: JUMPDEST
000006c2: DUP1
000006c3: PUSH1 0x02
000006c5: EQ
000006c6: ISZERO
000006c7: PUSH2 0x06d2
000006ca: JUMPI
000006cb: PUSH2 0x06d2
000006ce: PUSH2 0x02a1
000006d1: JUMP
000006d2: JUMPDEST
000006d3: POP
000006d4: POP
000006d5: POP
000006d6: POP
000006d7: JUMP
000006d8: JUMPDEST
000006d9: PUSH1 0x40
000006db: DUP1
000006dc: MLOAD
000006dd: DUP1
000006de: DUP3
000006df: ADD
000006e0: SWAP1
000006e1: SWAP2
000006e2: MSTORE
000006e3: SWAP1
000006e4: DUP2
000006e5: MSTORE
000006e6: PUSH1 0x20
000006e8: DUP2
000006e9: ADD
000006ea: SWAP2
000006eb: SWAP1
000006ec: SWAP2
000006ed: MSTORE
000006ee: SWAP3
000006ef: SWAP2
000006f0: POP
000006f1: POP
000006f2: JUMP
000006f3: JUMPDEST
000006f4: PUSH1 0x0b
000006f6: SLOAD
000006f7: PUSH1 0x40
000006f9: DUP1
000006fa: MLOAD
000006fb: PUSH1 0xe0
000006fd: PUSH1 0x02
000006ff: EXP
00000700: PUSH4 0x2964a643
00000705: MUL
00000706: DUP2
00000707: MSTORE
00000708: PUSH1 0x01
0000070a: PUSH1 0xa0
0000070c: PUSH1 0x02
0000070e: EXP
0000070f: SUB
00000710: CALLER
00000711: DUP2
00000712: AND
00000713: PUSH1 0x04
00000715: DUP4
00000716: ADD
00000717: MSTORE
00000718: SWAP2
00000719: MLOAD
0000071a: PUSH1 0x02
0000071c: SWAP8
0000071d: POP
0000071e: SWAP3
0000071f: SWAP1
00000720: SWAP2
00000721: AND
00000722: SWAP2
00000723: PUSH4 0x2964a643
00000728: SWAP2
00000729: PUSH1 0x24
0000072b: DUP2
0000072c: DUP2
0000072d: ADD
0000072e: SWAP3
0000072f: PUSH1 0x20
00000731: SWAP3
00000732: SWAP1
00000733: SWAP2
00000734: SWAP1
00000735: DUP3
00000736: SWAP1
00000737: SUB
00000738: ADD
00000739: DUP2
0000073a: PUSH1 0x00
0000073c: DUP8
0000073d: PUSH2 0x61da
00000740: GAS
00000741: SUB
00000742: CALL
00000743: ISZERO
00000744: PUSH2 0x0002
00000747: JUMPI
00000748: POP
00000749: POP
0000074a: PUSH1 0x40
0000074c: MLOAD
0000074d: MLOAD
0000074e: ISZERO
0000074f: SWAP1
00000750: POP
00000751: PUSH2 0x07cb
00000754: JUMPI
00000755: PUSH1 0x40
00000757: DUP1
00000758: MLOAD
00000759: PUSH1 0x0b
0000075b: SLOAD
0000075c: PUSH1 0xe2
0000075e: PUSH1 0x02
00000760: EXP
00000761: PUSH4 0x36f9a4d3
00000766: MUL
00000767: DUP3
00000768: MSTORE
00000769: PUSH1 0x01
0000076b: PUSH1 0xa0
0000076d: PUSH1 0x02
0000076f: EXP
00000770: SUB
00000771: CALLER
00000772: DUP2
00000773: AND
00000774: PUSH1 0x04
00000776: DUP5
00000777: ADD
00000778: MSTORE
00000779: SWAP3
0000077a: MLOAD
0000077b: SWAP3
0000077c: AND
0000077d: SWAP2
0000077e: PUSH4 0xdbe6934c
00000783: SWAP2
00000784: PUSH1 0x24
00000786: DUP2
00000787: DUP2
00000788: ADD
00000789: SWAP3
0000078a: PUSH1 0x20
0000078c: SWAP3
0000078d: SWAP1
0000078e: SWAP2
0000078f: SWAP1
00000790: DUP3
00000791: SWAP1
00000792: SUB
00000793: ADD
00000794: DUP2
00000795: PUSH1 0x00
00000797: DUP8
00000798: PUSH2 0x61da
0000079b: GAS
0000079c: SUB
0000079d: CALL
0000079e: ISZERO
0000079f: PUSH2 0x0002
000007a2: JUMPI
000007a3: POP
000007a4: POP
000007a5: PUSH1 0x40
000007a7: MLOAD
000007a8: MLOAD
000007a9: PUSH1 0x00
000007ab: EQ
000007ac: ISZERO
000007ad: SWAP1
000007ae: POP
000007af: PUSH2 0x07d0
000007b2: JUMPI
000007b3: DUP4
000007b4: SLOAD
000007b5: PUSH9 0x056bc75e2d63100000
000007bf: ADD
000007c0: CALLVALUE
000007c1: LT
000007c2: ISZERO
000007c3: PUSH2 0x0849
000007c6: JUMPI
000007c7: PUSH2 0x0002
000007ca: JUMP
000007cb: JUMPDEST
000007cc: PUSH2 0x0002
000007cf: JUMP
000007d0: JUMPDEST
000007d1: PUSH1 0x0b
000007d3: SLOAD
000007d4: PUSH1 0x40
000007d6: DUP1
000007d7: MLOAD
000007d8: PUSH1 0xe1
000007da: PUSH1 0x02
000007dc: EXP
000007dd: PUSH4 0x574605d9
000007e2: MUL
000007e3: DUP2
000007e4: MSTORE
000007e5: PUSH1 0x01
000007e7: PUSH1 0xa0
000007e9: PUSH1 0x02
000007eb: EXP
000007ec: SUB
000007ed: CALLER
000007ee: DUP2
000007ef: AND
000007f0: PUSH1 0x04
000007f2: DUP4
000007f3: ADD
000007f4: MSTORE
000007f5: SWAP2
000007f6: MLOAD
000007f7: SWAP3
000007f8: SWAP1
000007f9: SWAP2
000007fa: AND
000007fb: SWAP2
000007fc: PUSH4 0xae8c0bb2
00000801: SWAP2
00000802: PUSH1 0x24
00000804: DUP2
00000805: DUP2
00000806: ADD
00000807: SWAP3
00000808: PUSH1 0x20
0000080a: SWAP3
0000080b: SWAP1
0000080c: SWAP2
0000080d: SWAP1
0000080e: DUP3
0000080f: SWAP1
00000810: SUB
00000811: ADD
00000812: DUP2
00000813: PUSH1 0x00
00000815: DUP8
00000816: PUSH2 0x61da
00000819: GAS
0000081a: SUB
0000081b: CALL
0000081c: ISZERO
0000081d: PUSH2 0x0002
00000820: JUMPI
00000821: POP
00000822: POP
00000823: PUSH1 0x40
00000825: MLOAD
00000826: MLOAD
00000827: PUSH1 0x00
00000829: EQ
0000082a: SWAP1
0000082b: POP
0000082c: DUP1
0000082d: ISZERO
0000082e: PUSH2 0x083f
00000831: JUMPI
00000832: POP
00000833: PUSH9 0x056bc75e2d63100000
0000083d: CALLVALUE
0000083e: LT
0000083f: JUMPDEST
00000840: ISZERO
00000841: PUSH2 0x0949
00000844: JUMPI
00000845: PUSH2 0x0002
00000848: JUMP
00000849: JUMPDEST
0000084a: PUSH1 0x02
0000084c: SLOAD
0000084d: PUSH2 0x0857
00000850: SWAP1
00000851: CALLVALUE
00000852: SUB
00000853: PUSH2 0x00c5
00000856: JUMP
00000857: JUMPDEST
00000858: PUSH1 0x0b
0000085a: SLOAD
0000085b: PUSH1 0x40
0000085d: DUP1
0000085e: MLOAD
0000085f: PUSH1 0xe0
00000861: PUSH1 0x02
00000863: EXP
00000864: PUSH4 0x3544c28b
00000869: MUL
0000086a: DUP2
0000086b: MSTORE
0000086c: PUSH1 0x01
0000086e: PUSH1 0xa0
00000870: PUSH1 0x02
00000872: EXP
00000873: SUB
00000874: CALLER
00000875: DUP2
00000876: AND
00000877: PUSH1 0x04
00000879: DUP4
0000087a: ADD
0000087b: MSTORE
0000087c: PUSH1 0x01
0000087e: PUSH1 0x24
00000880: DUP4
00000881: ADD
00000882: MSTORE
00000883: SWAP2
00000884: MLOAD
00000885: SWAP4
00000886: SWAP9
00000887: POP
00000888: SWAP2
00000889: AND
0000088a: SWAP2
0000088b: PUSH4 0x3544c28b
00000890: SWAP2
00000891: PUSH1 0x44
00000893: DUP2
00000894: DUP2
00000895: ADD
00000896: SWAP3
00000897: PUSH1 0x00
00000899: SWAP3
0000089a: SWAP1
0000089b: SWAP2
0000089c: SWAP1
0000089d: DUP3
0000089e: SWAP1
0000089f: SUB
000008a0: ADD
000008a1: DUP2
000008a2: DUP4
000008a3: DUP8
000008a4: PUSH2 0x61da
000008a7: GAS
000008a8: SUB
000008a9: CALL
000008aa: ISZERO
000008ab: PUSH2 0x0002
000008ae: JUMPI
000008af: POP
000008b0: PUSH1 0x03
000008b2: SWAP6
000008b3: POP
000008b4: PUSH2 0x08be
000008b7: SWAP2
000008b8: POP
000008b9: POP
000008ba: JUMP
000008bb: JUMPDEST
000008bc: SWAP5
000008bd: POP
000008be: JUMPDEST
000008bf: PUSH1 0x0b
000008c1: SLOAD
000008c2: PUSH1 0x40
000008c4: DUP1
000008c5: MLOAD
000008c6: DUP8
000008c7: MLOAD
000008c8: PUSH1 0x20
000008ca: DUP10
000008cb: DUP2
000008cc: ADD
000008cd: MLOAD
000008ce: PUSH32 0x141c082500000000000000000000000000000000000000000000000000000000
000008ef: DUP5
000008f0: MSTORE
000008f1: SWAP4
000008f2: MLOAD
000008f3: SWAP2
000008f4: SWAP8
000008f5: POP
000008f6: SWAP3
000008f7: SWAP6
000008f8: POP
000008f9: PUSH1 0x01
000008fb: PUSH1 0xa0
000008fd: PUSH1 0x02
000008ff: EXP
00000900: SUB
00000901: SWAP4
00000902: SWAP1
00000903: SWAP4
00000904: AND
00000905: SWAP3
00000906: PUSH4 0x141c0825
0000090b: SWAP3
0000090c: PUSH1 0x04
0000090e: DUP4
0000090f: DUP2
00000910: ADD
00000911: SWAP4
00000912: SWAP2
00000913: SWAP3
00000914: SWAP2
00000915: DUP3
00000916: SWAP1
00000917: SUB
00000918: ADD
00000919: DUP2
0000091a: PUSH1 0x00
0000091c: DUP8
0000091d: PUSH2 0x61da
00000920: GAS
00000921: SUB
00000922: CALL
00000923: ISZERO
00000924: PUSH2 0x0002
00000927: JUMPI
00000928: POP
00000929: POP
0000092a: PUSH1 0x40
0000092c: MLOAD
0000092d: MLOAD
0000092e: SWAP2
0000092f: POP
00000930: POP
00000931: DUP3
00000932: DUP2
00000933: LT
00000934: DUP1
00000935: PUSH2 0x093f
00000938: JUMPI
00000939: POP
0000093a: DUP1
0000093b: DUP4
0000093c: DUP3
0000093d: SUB
0000093e: GT
0000093f: JUMPDEST
00000940: ISZERO
00000941: PUSH2 0x0952
00000944: JUMPI
00000945: PUSH2 0x0002
00000948: JUMP
00000949: JUMPDEST
0000094a: PUSH2 0x08bb
0000094d: CALLVALUE
0000094e: PUSH2 0x00c5
00000951: JUMP
00000952: JUMPDEST
00000953: PUSH1 0x0b
00000955: SLOAD
00000956: PUSH1 0x40
00000958: DUP1
00000959: MLOAD
0000095a: PUSH1 0xe1
0000095c: PUSH1 0x02
0000095e: EXP
0000095f: PUSH4 0x574605d9
00000964: MUL
00000965: DUP2
00000966: MSTORE
00000967: PUSH1 0x01
00000969: PUSH1 0xa0
0000096b: PUSH1 0x02
0000096d: EXP
0000096e: SUB
0000096f: CALLER
00000970: DUP2
00000971: AND
00000972: PUSH1 0x04
00000974: DUP4
00000975: ADD
00000976: MSTORE
00000977: SWAP2
00000978: MLOAD
00000979: SWAP3
0000097a: SWAP1
0000097b: SWAP2
0000097c: AND
0000097d: SWAP2
0000097e: PUSH4 0xae8c0bb2
00000983: SWAP2
00000984: PUSH1 0x24
00000986: DUP2
00000987: DUP2
00000988: ADD
00000989: SWAP3
0000098a: PUSH1 0x20
0000098c: SWAP3
0000098d: SWAP1
0000098e: SWAP2
0000098f: SWAP1
00000990: DUP3
00000991: SWAP1
00000992: SUB
00000993: ADD
00000994: DUP2
00000995: PUSH1 0x00
00000997: DUP8
00000998: PUSH2 0x61da
0000099b: GAS
0000099c: SUB
0000099d: CALL
0000099e: ISZERO
0000099f: PUSH2 0x0002
000009a2: JUMPI
000009a3: POP
000009a4: PUSH1 0x40
000009a6: DUP1
000009a7: MLOAD
000009a8: DUP1
000009a9: MLOAD
000009aa: PUSH1 0x0b
000009ac: SLOAD
000009ad: PUSH1 0xe1
000009af: PUSH1 0x02
000009b1: EXP
000009b2: PUSH4 0x574605d9
000009b7: MUL
000009b8: DUP4
000009b9: MSTORE
000009ba: PUSH1 0x01
000009bc: PUSH1 0xa0
000009be: PUSH1 0x02
000009c0: EXP
000009c1: SUB
000009c2: CALLER
000009c3: DUP2
000009c4: AND
000009c5: PUSH1 0x04
000009c7: DUP6
000009c8: ADD
000009c9: MSTORE
000009ca: SWAP4
000009cb: MLOAD
000009cc: SWAP2
000009cd: SWAP6
000009ce: POP
000009cf: DUP9
000009d0: SWAP5
000009d1: SWAP4
000009d2: AND
000009d3: SWAP3
000009d4: SWAP2
000009d5: PUSH1 0x24
000009d7: DUP2
000009d8: DUP2
000009d9: ADD
000009da: SWAP3
000009db: PUSH1 0x20
000009dd: SWAP3
000009de: SWAP1
000009df: SWAP2
000009e0: SWAP1
000009e1: DUP3
000009e2: SWAP1
000009e3: SUB
000009e4: ADD
000009e5: DUP2
000009e6: PUSH1 0x00
000009e8: DUP8
000009e9: PUSH2 0x61da
000009ec: GAS
000009ed: SUB
000009ee: CALL
000009ef: ISZERO
000009f0: PUSH2 0x0002
000009f3: JUMPI
000009f4: POP
000009f5: POP
000009f6: POP
000009f7: PUSH1 0x40
000009f9: MLOAD
000009fa: DUP1
000009fb: MLOAD
000009fc: SWAP1
000009fd: PUSH1 0x20
000009ff: ADD
00000a00: POP
00000a01: ADD
00000a02: LT
00000a03: ISZERO
00000a04: PUSH2 0x0a0c
00000a07: JUMPI
00000a08: PUSH2 0x0002
00000a0b: JUMP
00000a0c: JUMPDEST
00000a0d: PUSH1 0x0b
00000a0f: SLOAD
00000a10: PUSH1 0x40
00000a12: DUP1
00000a13: MLOAD
00000a14: PUSH1 0xe0
00000a16: PUSH1 0x02
00000a18: EXP
00000a19: PUSH4 0xcd268063
00000a1e: MUL
00000a1f: DUP2
00000a20: MSTORE
00000a21: PUSH1 0x01
00000a23: PUSH1 0xa0
00000a25: PUSH1 0x02
00000a27: EXP
00000a28: SUB
00000a29: CALLER
00000a2a: DUP2
00000a2b: AND
00000a2c: PUSH1 0x04
00000a2e: DUP4
00000a2f: ADD
00000a30: MSTORE
00000a31: PUSH1 0x24
00000a33: DUP3
00000a34: ADD
00000a35: DUP8
00000a36: SWAP1
00000a37: MSTORE
00000a38: SWAP2
00000a39: MLOAD
00000a3a: SWAP3
00000a3b: SWAP1
00000a3c: SWAP2
00000a3d: AND
00000a3e: SWAP2
00000a3f: PUSH4 0xcd268063
00000a44: SWAP2
00000a45: PUSH1 0x44
00000a47: DUP2
00000a48: DUP2
00000a49: ADD
00000a4a: SWAP3
00000a4b: PUSH1 0x00
00000a4d: SWAP3
00000a4e: SWAP1
00000a4f: SWAP2
00000a50: SWAP1
00000a51: DUP3
00000a52: SWAP1
00000a53: SUB
00000a54: ADD
00000a55: DUP2
00000a56: DUP4
00000a57: DUP8
00000a58: PUSH2 0x61da
00000a5b: GAS
00000a5c: SUB
00000a5d: CALL
00000a5e: ISZERO
00000a5f: PUSH2 0x0002
00000a62: JUMPI
00000a63: POP
00000a64: POP
00000a65: POP
00000a66: PUSH1 0x00
00000a68: DUP3
00000a69: GT
00000a6a: ISZERO
00000a6b: PUSH2 0x0a8f
00000a6e: JUMPI
00000a6f: PUSH1 0x40
00000a71: MLOAD
00000a72: CALLER
00000a73: PUSH1 0x01
00000a75: PUSH1 0xa0
00000a77: PUSH1 0x02
00000a79: EXP
00000a7a: SUB
00000a7b: AND
00000a7c: SWAP1
00000a7d: PUSH1 0x00
00000a7f: SWAP1
00000a80: DUP5
00000a81: SWAP1
00000a82: DUP3
00000a83: DUP2
00000a84: DUP2
00000a85: DUP2
00000a86: DUP6
00000a87: DUP9
00000a88: DUP4
00000a89: CALL
00000a8a: POP
00000a8b: POP
00000a8c: POP
00000a8d: POP
00000a8e: POP
00000a8f: JUMPDEST
00000a90: PUSH2 0x0c1e
00000a93: DUP5
00000a94: DUP5
00000a95: DUP5
00000a96: JUMPDEST
00000a97: PUSH1 0x0b
00000a99: SLOAD
00000a9a: PUSH1 0x40
00000a9c: DUP1
00000a9d: MLOAD
00000a9e: PUSH32 0x7cf746e100000000000000000000000000000000000000000000000000000000
00000abf: DUP2
00000ac0: MSTORE
00000ac1: PUSH1 0x01
00000ac3: PUSH1 0xa0
00000ac5: PUSH1 0x02
00000ac7: EXP
00000ac8: SUB
00000ac9: CALLER
00000aca: DUP2
00000acb: AND
00000acc: PUSH1 0x04
00000ace: DUP4
00000acf: ADD
00000ad0: MSTORE
00000ad1: SWAP2
00000ad2: MLOAD
00000ad3: PUSH1 0x00
00000ad5: SWAP4
00000ad6: DUP5
00000ad7: SWAP4
00000ad8: DUP5
00000ad9: SWAP4
00000ada: SWAP2
00000adb: AND
00000adc: SWAP2
00000add: PUSH4 0x7cf746e1
00000ae2: SWAP2
00000ae3: PUSH1 0x24
00000ae5: DUP2
00000ae6: DUP2
00000ae7: ADD
00000ae8: SWAP3
00000ae9: PUSH2 0x0100
00000aec: SWAP3
00000aed: SWAP1
00000aee: SWAP2
00000aef: SWAP1
00000af0: DUP3
00000af1: SWAP1
00000af2: SUB
00000af3: ADD
00000af4: DUP2
00000af5: DUP8
00000af6: DUP8
00000af7: PUSH2 0x61da
00000afa: GAS
00000afb: SUB
00000afc: CALL
00000afd: ISZERO
00000afe: PUSH2 0x0002
00000b01: JUMPI
00000b02: POP
00000b03: POP
00000b04: PUSH1 0x40
00000b06: DUP1
00000b07: MLOAD
00000b08: PUSH2 0x0100
00000b0b: DUP2
00000b0c: ADD
00000b0d: DUP1
00000b0e: DUP4
00000b0f: MSTORE
00000b10: DUP2
00000b11: MLOAD
00000b12: PUSH1 0x0b
00000b14: SLOAD
00000b15: PUSH32 0xecc4413300000000000000000000000000000000000000000000000000000000
00000b36: SWAP1
00000b37: SWAP3
00000b38: MSTORE
00000b39: PUSH1 0x01
00000b3b: PUSH1 0xa0
00000b3d: PUSH1 0x02
00000b3f: EXP
00000b40: SUB
00000b41: DUP2
00000b42: DUP2
00000b43: AND
00000b44: PUSH2 0x0104
00000b47: DUP6
00000b48: ADD
00000b49: MSTORE
00000b4a: SWAP4
00000b4b: MLOAD
00000b4c: SWAP1
00000b4d: SWAP7
00000b4e: POP
00000b4f: SWAP3
00000b50: AND
00000b51: SWAP3
00000b52: POP
00000b53: PUSH4 0xecc44133
00000b58: SWAP2
00000b59: PUSH2 0x0124
00000b5c: DUP1
00000b5d: DUP4
00000b5e: ADD
00000b5f: SWAP3
00000b60: PUSH1 0x20
00000b62: SWAP3
00000b63: SWAP2
00000b64: SWAP1
00000b65: DUP3
00000b66: SWAP1
00000b67: SUB
00000b68: ADD
00000b69: DUP2
00000b6a: DUP8
00000b6b: DUP8
00000b6c: PUSH2 0x61da
00000b6f: GAS
00000b70: SUB
00000b71: CALL
00000b72: ISZERO
00000b73: PUSH2 0x0002
00000b76: JUMPI
00000b77: POP
00000b78: POP
00000b79: POP
00000b7a: PUSH1 0x40
00000b7c: MLOAD
00000b7d: DUP1
00000b7e: MLOAD
00000b7f: SWAP1
00000b80: PUSH1 0x20
00000b82: ADD
00000b83: POP
00000b84: SWAP1
00000b85: POP
00000b86: PUSH1 0x00
00000b88: PUSH1 0x0b
00000b8a: PUSH1 0x00
00000b8c: POP
00000b8d: PUSH1 0x00
00000b8f: ADD
00000b90: PUSH1 0x00
00000b92: SWAP1
00000b93: SLOAD
00000b94: SWAP1
00000b95: PUSH2 0x0100
00000b98: EXP
00000b99: SWAP1
00000b9a: DIV
00000b9b: PUSH1 0x01
00000b9d: PUSH1 0xa0
00000b9f: PUSH1 0x02
00000ba1: EXP
00000ba2: SUB
00000ba3: AND
00000ba4: PUSH1 0x01
00000ba6: PUSH1 0xa0
00000ba8: PUSH1 0x02
00000baa: EXP
00000bab: SUB
00000bac: AND
00000bad: PUSH4 0xdbe6934c
00000bb2: DUP5
00000bb3: PUSH1 0x40
00000bb5: MLOAD
00000bb6: DUP3
00000bb7: PUSH1 0xe0
00000bb9: PUSH1 0x02
00000bbb: EXP
00000bbc: MUL
00000bbd: DUP2
00000bbe: MSTORE
00000bbf: PUSH1 0x04
00000bc1: ADD
00000bc2: DUP1
00000bc3: DUP3
00000bc4: PUSH1 0x01
00000bc6: PUSH1 0xa0
00000bc8: PUSH1 0x02
00000bca: EXP
00000bcb: SUB
00000bcc: AND
00000bcd: DUP2
00000bce: MSTORE
00000bcf: PUSH1 0x20
00000bd1: ADD
00000bd2: SWAP2
00000bd3: POP
00000bd4: POP
00000bd5: PUSH1 0x20
00000bd7: PUSH1 0x40
00000bd9: MLOAD
00000bda: DUP1
00000bdb: DUP4
00000bdc: SUB
00000bdd: DUP2
00000bde: PUSH1 0x00
00000be0: DUP8
00000be1: PUSH2 0x61da
00000be4: GAS
00000be5: SUB
00000be6: CALL
00000be7: ISZERO
00000be8: PUSH2 0x0002
00000beb: JUMPI
00000bec: POP
00000bed: POP
00000bee: PUSH1 0x40
00000bf0: MLOAD
00000bf1: MLOAD
00000bf2: SWAP2
00000bf3: SWAP1
00000bf4: SWAP2
00000bf5: GT
00000bf6: ISZERO
00000bf7: SWAP1
00000bf8: POP
00000bf9: PUSH2 0x1304
00000bfc: JUMPI
00000bfd: PUSH1 0x00
00000bff: DUP2
00000c00: GT
00000c01: ISZERO
00000c02: PUSH2 0x1274
00000c05: JUMPI
00000c06: DUP6
00000c07: PUSH1 0x01
00000c09: EQ
00000c0a: ISZERO
00000c0b: PUSH2 0x12bf
00000c0e: JUMPI
00000c0f: PUSH8 0x29a2241af62c0000
00000c18: SWAP3
00000c19: POP
00000c1a: PUSH2 0x12ff
00000c1d: JUMP
00000c1e: JUMPDEST
00000c1f: PUSH2 0x0c53
00000c22: JUMPDEST
00000c23: PUSH1 0x07
00000c25: SLOAD
00000c26: PUSH1 0x00
00000c28: SWAP1
00000c29: DUP2
00000c2a: EQ
00000c2b: DUP1
00000c2c: ISZERO
00000c2d: PUSH2 0x0c37
00000c30: JUMPI
00000c31: POP
00000c32: PUSH1 0x06
00000c34: SLOAD
00000c35: TIMESTAMP
00000c36: GT
00000c37: JUMPDEST
00000c38: ISZERO
00000c39: PUSH2 0x1271
00000c3c: JUMPI
00000c3d: PUSH1 0x06
00000c3f: SLOAD
00000c40: PUSH1 0x04
00000c42: SLOAD
00000c43: ADD
00000c44: TIMESTAMP
00000c45: GT
00000c46: ISZERO
00000c47: PUSH2 0x1176
00000c4a: JUMPI
00000c4b: PUSH2 0x1271
00000c4e: TIMESTAMP
00000c4f: PUSH1 0x07
00000c51: SSTORE
00000c52: JUMP
00000c53: JUMPDEST
00000c54: POP
00000c55: POP
00000c56: POP
00000c57: POP
00000c58: POP
00000c59: JUMP
00000c5a: JUMPDEST
00000c5b: POP
00000c5c: PUSH1 0x02
00000c5e: SLOAD
00000c5f: SWAP1
00000c60: SUB
00000c61: SWAP1
00000c62: JUMP
00000c63: JUMPDEST
00000c64: PUSH1 0x0b
00000c66: SLOAD
00000c67: PUSH1 0x40
00000c69: DUP1
00000c6a: MLOAD
00000c6b: PUSH1 0xe0
00000c6d: PUSH1 0x02
00000c6f: EXP
00000c70: PUSH4 0x2964a643
00000c75: MUL
00000c76: DUP2
00000c77: MSTORE
00000c78: PUSH1 0x01
00000c7a: PUSH1 0xa0
00000c7c: PUSH1 0x02
00000c7e: EXP
00000c7f: SUB
00000c80: CALLER
00000c81: DUP2
00000c82: AND
00000c83: PUSH1 0x04
00000c85: DUP4
00000c86: ADD
00000c87: MSTORE
00000c88: SWAP2
00000c89: MLOAD
00000c8a: SWAP3
00000c8b: SWAP1
00000c8c: SWAP2
00000c8d: AND
00000c8e: SWAP2
00000c8f: PUSH4 0x2964a643
00000c94: SWAP2
00000c95: PUSH1 0x24
00000c97: DUP2
00000c98: DUP2
00000c99: ADD
00000c9a: SWAP3
00000c9b: PUSH1 0x20
00000c9d: SWAP3
00000c9e: SWAP1
00000c9f: SWAP2
00000ca0: SWAP1
00000ca1: DUP3
00000ca2: SWAP1
00000ca3: SUB
00000ca4: ADD
00000ca5: DUP2
00000ca6: PUSH1 0x00
00000ca8: DUP8
00000ca9: PUSH2 0x61da
00000cac: GAS
00000cad: SUB
00000cae: CALL
00000caf: ISZERO
00000cb0: PUSH2 0x0002
00000cb3: JUMPI
00000cb4: POP
00000cb5: POP
00000cb6: PUSH1 0x40
00000cb8: MLOAD
00000cb9: MLOAD
00000cba: ISZERO
00000cbb: SWAP1
00000cbc: POP
00000cbd: PUSH2 0x07cb
00000cc0: JUMPI
00000cc1: PUSH1 0x40
00000cc3: DUP1
00000cc4: MLOAD
00000cc5: PUSH1 0x0b
00000cc7: SLOAD
00000cc8: PUSH1 0xe1
00000cca: PUSH1 0x02
00000ccc: EXP
00000ccd: PUSH4 0x6f3574cf
00000cd2: MUL
00000cd3: DUP3
00000cd4: MSTORE
00000cd5: SWAP2
00000cd6: MLOAD
00000cd7: PUSH2 0x1388
00000cda: SWAP3
00000cdb: PUSH1 0x01
00000cdd: PUSH1 0xa0
00000cdf: PUSH1 0x02
00000ce1: EXP
00000ce2: SUB
00000ce3: AND
00000ce4: SWAP2
00000ce5: PUSH4 0xde6ae99e
00000cea: SWAP2
00000ceb: PUSH1 0x04
00000ced: DUP3
00000cee: DUP2
00000cef: ADD
00000cf0: SWAP3
00000cf1: PUSH1 0x20
00000cf3: SWAP3
00000cf4: SWAP2
00000cf5: SWAP1
00000cf6: DUP3
00000cf7: SWAP1
00000cf8: SUB
00000cf9: ADD
00000cfa: DUP2
00000cfb: PUSH1 0x00
00000cfd: DUP8
00000cfe: PUSH2 0x61da
00000d01: GAS
00000d02: SUB
00000d03: CALL
00000d04: ISZERO
00000d05: PUSH2 0x0002
00000d08: JUMPI
00000d09: POP
00000d0a: POP
00000d0b: PUSH1 0x40
00000d0d: MLOAD
00000d0e: MLOAD
00000d0f: SWAP2
00000d10: SWAP1
00000d11: SWAP2
00000d12: GT
00000d13: SWAP1
00000d14: POP
00000d15: PUSH2 0x0d1d
00000d18: JUMPI
00000d19: PUSH2 0x0002
00000d1c: JUMP
00000d1d: JUMPDEST
00000d1e: PUSH2 0x0d26
00000d21: CALLVALUE
00000d22: PUSH2 0x00ac
00000d25: JUMP
00000d26: JUMPDEST
00000d27: PUSH1 0x40
00000d29: DUP1
00000d2a: MLOAD
00000d2b: PUSH1 0x0b
00000d2d: SLOAD
00000d2e: PUSH1 0xe1
00000d30: PUSH1 0x02
00000d32: EXP
00000d33: PUSH4 0x6f3574cf
00000d38: MUL
00000d39: DUP3
00000d3a: MSTORE
00000d3b: SWAP2
00000d3c: MLOAD
00000d3d: SWAP3
00000d3e: SWAP4
00000d3f: POP
00000d40: PUSH1 0x01
00000d42: SWAP3
00000d43: PUSH1 0x01
00000d45: PUSH1 0xa0
00000d47: PUSH1 0x02
00000d49: EXP
00000d4a: SUB
00000d4b: SWAP3
00000d4c: SWAP1
00000d4d: SWAP3
00000d4e: AND
00000d4f: SWAP2
00000d50: PUSH4 0xde6ae99e
00000d55: SWAP2
00000d56: PUSH1 0x04
00000d58: DUP2
00000d59: DUP2
00000d5a: ADD
00000d5b: SWAP3
00000d5c: PUSH1 0x20
00000d5e: SWAP3
00000d5f: SWAP1
00000d60: SWAP2
00000d61: SWAP1
00000d62: DUP3
00000d63: SWAP1
00000d64: SUB
00000d65: ADD
00000d66: DUP2
00000d67: PUSH1 0x00
00000d69: DUP8
00000d6a: PUSH2 0x61da
00000d6d: GAS
00000d6e: SUB
00000d6f: CALL
00000d70: ISZERO
00000d71: PUSH2 0x0002
00000d74: JUMPI
00000d75: POP
00000d76: POP
00000d77: PUSH1 0x40
00000d79: MLOAD
00000d7a: MLOAD
00000d7b: SWAP2
00000d7c: SWAP1
00000d7d: SWAP2
00000d7e: LT
00000d7f: ISZERO
00000d80: SWAP1
00000d81: POP
00000d82: PUSH2 0x0d8a
00000d85: JUMPI
00000d86: PUSH2 0x0002
00000d89: JUMP
00000d8a: JUMPDEST
00000d8b: PUSH1 0x40
00000d8d: DUP1
00000d8e: MLOAD
00000d8f: PUSH1 0x0b
00000d91: SLOAD
00000d92: PUSH1 0xe2
00000d94: PUSH1 0x02
00000d96: EXP
00000d97: PUSH4 0x36f9a4d3
00000d9c: MUL
00000d9d: DUP3
00000d9e: MSTORE
00000d9f: PUSH1 0x01
00000da1: PUSH1 0xa0
00000da3: PUSH1 0x02
00000da5: EXP
00000da6: SUB
00000da7: CALLER
00000da8: DUP2
00000da9: AND
00000daa: PUSH1 0x04
00000dac: DUP5
00000dad: ADD
00000dae: MSTORE
00000daf: SWAP3
00000db0: MLOAD
00000db1: PUSH1 0x00
00000db3: SWAP4
00000db4: SWAP2
00000db5: SWAP1
00000db6: SWAP2
00000db7: AND
00000db8: SWAP2
00000db9: PUSH4 0xdbe6934c
00000dbe: SWAP2
00000dbf: PUSH1 0x24
00000dc1: DUP3
00000dc2: DUP2
00000dc3: ADD
00000dc4: SWAP3
00000dc5: PUSH1 0x20
00000dc7: SWAP3
00000dc8: SWAP2
00000dc9: SWAP1
00000dca: DUP3
00000dcb: SWAP1
00000dcc: SUB
00000dcd: ADD
00000dce: DUP2
00000dcf: DUP8
00000dd0: DUP8
00000dd1: PUSH2 0x61da
00000dd4: GAS
00000dd5: SUB
00000dd6: CALL
00000dd7: ISZERO
00000dd8: PUSH2 0x0002
00000ddb: JUMPI
00000ddc: POP
00000ddd: POP
00000dde: PUSH1 0x40
00000de0: MLOAD
00000de1: MLOAD
00000de2: SWAP2
00000de3: SWAP1
00000de4: SWAP2
00000de5: GT
00000de6: SWAP1
00000de7: POP
00000de8: DUP1
00000de9: PUSH2 0x0e4b
00000dec: JUMPI
00000ded: POP
00000dee: PUSH1 0x40
00000df0: DUP1
00000df1: MLOAD
00000df2: PUSH1 0x0b
00000df4: SLOAD
00000df5: PUSH1 0xe1
00000df7: PUSH1 0x02
00000df9: EXP
00000dfa: PUSH4 0x574605d9
00000dff: MUL
00000e00: DUP3
00000e01: MSTORE
00000e02: PUSH1 0x01
00000e04: PUSH1 0xa0
00000e06: PUSH1 0x02
00000e08: EXP
00000e09: SUB
00000e0a: CALLER
00000e0b: DUP2
00000e0c: AND
00000e0d: PUSH1 0x04
00000e0f: DUP5
00000e10: ADD
00000e11: MSTORE
00000e12: SWAP3
00000e13: MLOAD
00000e14: PUSH1 0x00
00000e16: SWAP4
00000e17: SWAP2
00000e18: SWAP1
00000e19: SWAP2
00000e1a: AND
00000e1b: SWAP2
00000e1c: PUSH4 0xae8c0bb2
00000e21: SWAP2
00000e22: PUSH1 0x24
00000e24: DUP3
00000e25: DUP2
00000e26: ADD
00000e27: SWAP3
00000e28: PUSH1 0x20
00000e2a: SWAP3
00000e2b: SWAP2
00000e2c: SWAP1
00000e2d: DUP3
00000e2e: SWAP1
00000e2f: SUB
00000e30: ADD
00000e31: DUP2
00000e32: DUP8
00000e33: DUP8
00000e34: PUSH2 0x61da
00000e37: GAS
00000e38: SUB
00000e39: CALL
00000e3a: ISZERO
00000e3b: PUSH2 0x0002
00000e3e: JUMPI
00000e3f: POP
00000e40: POP
00000e41: PUSH1 0x40
00000e43: MLOAD
00000e44: MLOAD
00000e45: SWAP2
00000e46: SWAP1
00000e47: SWAP2
00000e48: GT
00000e49: SWAP1
00000e4a: POP
00000e4b: JUMPDEST
00000e4c: ISZERO
00000e4d: PUSH2 0x0e55
00000e50: JUMPI
00000e51: PUSH2 0x0002
00000e54: JUMP
00000e55: JUMPDEST
00000e56: PUSH1 0x40
00000e58: DUP1
00000e59: MLOAD
00000e5a: PUSH1 0x0b
00000e5c: SLOAD
00000e5d: PUSH1 0xe0
00000e5f: PUSH1 0x02
00000e61: EXP
00000e62: PUSH4 0x3544c28b
00000e67: MUL
00000e68: DUP3
00000e69: MSTORE
00000e6a: PUSH1 0x01
00000e6c: PUSH1 0xa0
00000e6e: PUSH1 0x02
00000e70: EXP
00000e71: SUB
00000e72: CALLER
00000e73: DUP2
00000e74: AND
00000e75: PUSH1 0x04
00000e77: DUP5
00000e78: ADD
00000e79: MSTORE
00000e7a: PUSH1 0x01
00000e7c: PUSH1 0x24
00000e7e: DUP5
00000e7f: ADD
00000e80: MSTORE
00000e81: SWAP3
00000e82: MLOAD
00000e83: SWAP3
00000e84: AND
00000e85: SWAP2
00000e86: PUSH4 0x3544c28b
00000e8b: SWAP2
00000e8c: PUSH1 0x44
00000e8e: DUP2
00000e8f: DUP2
00000e90: ADD
00000e91: SWAP3
00000e92: PUSH1 0x00
00000e94: SWAP3
00000e95: SWAP1
00000e96: SWAP2
00000e97: SWAP1
00000e98: DUP3
00000e99: SWAP1
00000e9a: SUB
00000e9b: ADD
00000e9c: DUP2
00000e9d: DUP4
00000e9e: DUP8
00000e9f: PUSH2 0x61da
00000ea2: GAS
00000ea3: SUB
00000ea4: CALL
00000ea5: ISZERO
00000ea6: PUSH2 0x0002
00000ea9: JUMPI
00000eaa: POP
00000eab: POP
00000eac: POP
00000ead: PUSH1 0x00
00000eaf: DUP2
00000eb0: GT
00000eb1: ISZERO
00000eb2: PUSH2 0x0ed6
00000eb5: JUMPI
00000eb6: PUSH1 0x40
00000eb8: MLOAD
00000eb9: CALLER
00000eba: PUSH1 0x01
00000ebc: PUSH1 0xa0
00000ebe: PUSH1 0x02
00000ec0: EXP
00000ec1: SUB
00000ec2: AND
00000ec3: SWAP1
00000ec4: PUSH1 0x00
00000ec6: SWAP1
00000ec7: DUP4
00000ec8: SWAP1
00000ec9: DUP3
00000eca: DUP2
00000ecb: DUP2
00000ecc: DUP2
00000ecd: DUP6
00000ece: DUP9
00000ecf: DUP4
00000ed0: CALL
00000ed1: POP
00000ed2: POP
00000ed3: POP
00000ed4: POP
00000ed5: POP
00000ed6: JUMPDEST
00000ed7: PUSH2 0x0ee3
00000eda: PUSH1 0x01
00000edc: PUSH1 0x01
00000ede: DUP4
00000edf: PUSH2 0x0a96
00000ee2: JUMP
00000ee3: JUMPDEST
00000ee4: PUSH2 0x1271
00000ee7: PUSH2 0x0c22
00000eea: JUMP
00000eeb: JUMPDEST
00000eec: PUSH1 0x0b
00000eee: PUSH1 0x00
00000ef0: POP
00000ef1: PUSH1 0x00
00000ef3: ADD
00000ef4: PUSH1 0x00
00000ef6: SWAP1
00000ef7: SLOAD
00000ef8: SWAP1
00000ef9: PUSH2 0x0100
00000efc: EXP
00000efd: SWAP1
00000efe: DIV
00000eff: PUSH1 0x01
00000f01: PUSH1 0xa0
00000f03: PUSH1 0x02
00000f05: EXP
00000f06: SUB
00000f07: AND
00000f08: PUSH1 0x01
00000f0a: PUSH1 0xa0
00000f0c: PUSH1 0x02
00000f0e: EXP
00000f0f: SUB
00000f10: AND
00000f11: PUSH4 0x48a1eadc
00000f16: DUP7
00000f17: DUP7
00000f18: DUP7
00000f19: PUSH1 0x01
00000f1b: PUSH1 0x40
00000f1d: MLOAD
00000f1e: DUP6
00000f1f: PUSH1 0xe0
00000f21: PUSH1 0x02
00000f23: EXP
00000f24: MUL
00000f25: DUP2
00000f26: MSTORE
00000f27: PUSH1 0x04
00000f29: ADD
00000f2a: DUP1
00000f2b: DUP6
00000f2c: PUSH1 0x01
00000f2e: PUSH1 0xa0
00000f30: PUSH1 0x02
00000f32: EXP
00000f33: SUB
00000f34: AND
00000f35: DUP2
00000f36: MSTORE
00000f37: PUSH1 0x20
00000f39: ADD
00000f3a: DUP1
00000f3b: PUSH1 0x20
00000f3d: ADD
00000f3e: DUP1
00000f3f: PUSH1 0x20
00000f41: ADD
00000f42: DUP5
00000f43: DUP2
00000f44: MSTORE
00000f45: PUSH1 0x20
00000f47: ADD
00000f48: DUP4
00000f49: DUP2
00000f4a: SUB
00000f4b: DUP4
00000f4c: MSTORE
00000f4d: DUP7
00000f4e: DUP2
00000f4f: DUP2
00000f50: MLOAD
00000f51: DUP2
00000f52: MSTORE
00000f53: PUSH1 0x20
00000f55: ADD
00000f56: SWAP2
00000f57: POP
00000f58: DUP1
00000f59: MLOAD
00000f5a: SWAP1
00000f5b: PUSH1 0x20
00000f5d: ADD
00000f5e: SWAP1
00000f5f: DUP1
00000f60: DUP4
00000f61: DUP4
00000f62: DUP3
00000f63: SWAP1
00000f64: PUSH1 0x00
00000f66: PUSH1 0x04
00000f68: PUSH1 0x20
00000f6a: DUP5
00000f6b: PUSH1 0x1f
00000f6d: ADD
00000f6e: DIV
00000f6f: PUSH1 0x0f
00000f71: MUL
00000f72: PUSH1 0x03
00000f74: ADD
00000f75: CALL
00000f76: POP
00000f77: SWAP1
00000f78: POP
00000f79: SWAP1
00000f7a: DUP2
00000f7b: ADD
00000f7c: SWAP1
00000f7d: PUSH1 0x1f
00000f7f: AND
00000f80: DUP1
00000f81: ISZERO
00000f82: PUSH2 0x0f9f
00000f85: JUMPI
00000f86: DUP1
00000f87: DUP3
00000f88: SUB
00000f89: DUP1
00000f8a: MLOAD
00000f8b: PUSH1 0x01
00000f8d: DUP4
00000f8e: PUSH1 0x20
00000f90: SUB
00000f91: PUSH2 0x0100
00000f94: EXP
00000f95: SUB
00000f96: NOT
00000f97: AND
00000f98: DUP2
00000f99: MSTORE
00000f9a: PUSH1 0x20
00000f9c: ADD
00000f9d: SWAP2
00000f9e: POP
00000f9f: JUMPDEST
00000fa0: POP
00000fa1: DUP4
00000fa2: DUP2
00000fa3: SUB
00000fa4: DUP3
00000fa5: MSTORE
00000fa6: DUP6
00000fa7: DUP2
00000fa8: DUP2
00000fa9: MLOAD
00000faa: DUP2
00000fab: MSTORE
00000fac: PUSH1 0x20
00000fae: ADD
00000faf: SWAP2
00000fb0: POP
00000fb1: DUP1
00000fb2: MLOAD
00000fb3: SWAP1
00000fb4: PUSH1 0x20
00000fb6: ADD
00000fb7: SWAP1
00000fb8: DUP1
00000fb9: DUP4
00000fba: DUP4
00000fbb: DUP3
00000fbc: SWAP1
00000fbd: PUSH1 0x00
00000fbf: PUSH1 0x04
00000fc1: PUSH1 0x20
00000fc3: DUP5
00000fc4: PUSH1 0x1f
00000fc6: ADD
00000fc7: DIV
00000fc8: PUSH1 0x0f
00000fca: MUL
00000fcb: PUSH1 0x03
00000fcd: ADD
00000fce: CALL
00000fcf: POP
00000fd0: SWAP1
00000fd1: POP
00000fd2: SWAP1
00000fd3: DUP2
00000fd4: ADD
00000fd5: SWAP1
00000fd6: PUSH1 0x1f
00000fd8: AND
00000fd9: DUP1
00000fda: ISZERO
00000fdb: PUSH2 0x0ff8
00000fde: JUMPI
00000fdf: DUP1
00000fe0: DUP3
00000fe1: SUB
00000fe2: DUP1
00000fe3: MLOAD
00000fe4: PUSH1 0x01
00000fe6: DUP4
00000fe7: PUSH1 0x20
00000fe9: SUB
00000fea: PUSH2 0x0100
00000fed: EXP
00000fee: SUB
00000fef: NOT
00000ff0: AND
00000ff1: DUP2
00000ff2: MSTORE
00000ff3: PUSH1 0x20
00000ff5: ADD
00000ff6: SWAP2
00000ff7: POP
00000ff8: JUMPDEST
00000ff9: POP
00000ffa: SWAP7
00000ffb: POP
00000ffc: POP
00000ffd: POP
00000ffe: POP
00000fff: POP
00001000: POP
00001001: POP
00001002: PUSH1 0x00
00001004: PUSH1 0x40
00001006: MLOAD
00001007: DUP1
00001008: DUP4
00001009: SUB
0000100a: DUP2
0000100b: PUSH1 0x00
0000100d: DUP8
0000100e: PUSH2 0x61da
00001011: GAS
00001012: SUB
00001013: CALL
00001014: ISZERO
00001015: PUSH2 0x0002
00001018: JUMPI
00001019: POP
0000101a: POP
0000101b: PUSH1 0x0b
0000101d: SLOAD
0000101e: PUSH1 0x40
00001020: DUP1
00001021: MLOAD
00001022: PUSH1 0xe0
00001024: PUSH1 0x02
00001026: EXP
00001027: PUSH4 0xcd268063
0000102c: MUL
0000102d: DUP2
0000102e: MSTORE
0000102f: PUSH1 0x01
00001031: PUSH1 0xa0
00001033: PUSH1 0x02
00001035: EXP
00001036: SUB
00001037: DUP10
00001038: DUP2
00001039: AND
0000103a: PUSH1 0x04
0000103c: DUP4
0000103d: ADD
0000103e: MSTORE
0000103f: PUSH1 0x24
00001041: DUP3
00001042: ADD
00001043: DUP8
00001044: SWAP1
00001045: MSTORE
00001046: SWAP2
00001047: MLOAD
00001048: SWAP3
00001049: SWAP1
0000104a: SWAP2
0000104b: AND
0000104c: SWAP3
0000104d: POP
0000104e: PUSH4 0xcd268063
00001053: SWAP2
00001054: PUSH1 0x44
00001056: DUP3
00001057: DUP2
00001058: ADD
00001059: SWAP3
0000105a: PUSH1 0x00
0000105c: SWAP3
0000105d: SWAP2
0000105e: SWAP1
0000105f: DUP3
00001060: SWAP1
00001061: SUB
00001062: ADD
00001063: DUP2
00001064: DUP4
00001065: DUP8
00001066: PUSH2 0x61da
00001069: GAS
0000106a: SUB
0000106b: CALL
0000106c: ISZERO
0000106d: PUSH2 0x0002
00001070: JUMPI
00001071: POP
00001072: POP
00001073: PUSH1 0x0b
00001075: SLOAD
00001076: PUSH1 0x40
00001078: DUP1
00001079: MLOAD
0000107a: PUSH1 0xe0
0000107c: PUSH1 0x02
0000107e: EXP
0000107f: PUSH4 0x3544c28b
00001084: MUL
00001085: DUP2
00001086: MSTORE
00001087: PUSH1 0x01
00001089: PUSH1 0xa0
0000108b: PUSH1 0x02
0000108d: EXP
0000108e: SUB
0000108f: DUP10
00001090: DUP2
00001091: AND
00001092: PUSH1 0x04
00001094: DUP4
00001095: ADD
00001096: MSTORE
00001097: PUSH1 0x24
00001099: DUP3
0000109a: ADD
0000109b: DUP7
0000109c: SWAP1
0000109d: MSTORE
0000109e: SWAP2
0000109f: MLOAD
000010a0: SWAP3
000010a1: SWAP1
000010a2: SWAP2
000010a3: AND
000010a4: SWAP3
000010a5: POP
000010a6: PUSH4 0x3544c28b
000010ab: SWAP2
000010ac: PUSH1 0x44
000010ae: DUP3
000010af: DUP2
000010b0: ADD
000010b1: SWAP3
000010b2: PUSH1 0x00
000010b4: SWAP3
000010b5: SWAP2
000010b6: SWAP1
000010b7: DUP3
000010b8: SWAP1
000010b9: SUB
000010ba: ADD
000010bb: DUP2
000010bc: DUP4
000010bd: DUP8
000010be: PUSH2 0x61da
000010c1: GAS
000010c2: SUB
000010c3: CALL
000010c4: ISZERO
000010c5: PUSH2 0x0002
000010c8: JUMPI
000010c9: POP
000010ca: POP
000010cb: POP
000010cc: POP
000010cd: POP
000010ce: POP
000010cf: POP
000010d0: POP
000010d1: JUMP
000010d2: JUMPDEST
000010d3: PUSH1 0x0b
000010d5: SLOAD
000010d6: PUSH1 0x40
000010d8: DUP1
000010d9: MLOAD
000010da: PUSH32 0x66b87b2a00000000000000000000000000000000000000000000000000000000
000010fb: DUP2
000010fc: MSTORE
000010fd: PUSH1 0x01
000010ff: PUSH1 0xa0
00001101: PUSH1 0x02
00001103: EXP
00001104: SUB
00001105: DUP6
00001106: DUP2
00001107: AND
00001108: PUSH1 0x04
0000110a: DUP4
0000110b: ADD
0000110c: MSTORE
0000110d: DUP5
0000110e: DUP2
0000110f: AND
00001110: PUSH1 0x24
00001112: DUP4
00001113: ADD
00001114: MSTORE
00001115: SWAP2
00001116: MLOAD
00001117: SWAP3
00001118: SWAP1
00001119: SWAP2
0000111a: AND
0000111b: SWAP2
0000111c: PUSH4 0x66b87b2a
00001121: SWAP2
00001122: PUSH1 0x44
00001124: DUP2
00001125: DUP2
00001126: ADD
00001127: SWAP3
00001128: PUSH1 0x00
0000112a: SWAP3
0000112b: SWAP1
0000112c: SWAP2
0000112d: SWAP1
0000112e: DUP3
0000112f: SWAP1
00001130: SUB
00001131: ADD
00001132: DUP2
00001133: DUP4
00001134: DUP8
00001135: PUSH2 0x61da
00001138: GAS
00001139: SUB
0000113a: CALL
0000113b: ISZERO
0000113c: PUSH2 0x0002
0000113f: JUMPI
00001140: POP
00001141: POP
00001142: POP
00001143: POP
00001144: POP
00001145: JUMP
00001146: JUMPDEST
00001147: PUSH1 0x0b
00001149: DUP1
0000114a: SLOAD
0000114b: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00001160: NOT
00001161: SWAP1
00001162: DUP2
00001163: AND
00001164: DUP4
00001165: OR
00001166: SWAP1
00001167: SWAP2
00001168: SSTORE
00001169: PUSH1 0x0c
0000116b: DUP1
0000116c: SLOAD
0000116d: SWAP1
0000116e: SWAP2
0000116f: AND
00001170: DUP3
00001171: OR
00001172: SWAP1
00001173: SSTORE
00001174: POP
00001175: JUMP
00001176: JUMPDEST
00001177: POP
00001178: PUSH1 0x06
0000117a: SLOAD
0000117b: PUSH1 0x04
0000117d: SLOAD
0000117e: TIMESTAMP
0000117f: SWAP2
00001180: SWAP1
00001181: SWAP2
00001182: SUB
00001183: DUP2
00001184: SUB
00001185: PUSH1 0x05
00001187: DUP2
00001188: SWAP1
00001189: SSTORE
0000118a: PUSH1 0x0d
0000118c: SLOAD
0000118d: PUSH3 0x015180
00001191: SWAP2
00001192: SWAP1
00001193: SWAP3
00001194: SUB
00001195: DIV
00001196: PUSH1 0x01
00001198: ADD
00001199: SWAP1
0000119a: DUP2
0000119b: SWAP1
0000119c: LT
0000119d: ISZERO
0000119e: PUSH2 0x1271
000011a1: JUMPI
000011a2: PUSH1 0x0d
000011a4: DUP2
000011a5: SWAP1
000011a6: SSTORE
000011a7: PUSH1 0x1e
000011a9: DUP2
000011aa: LT
000011ab: DUP1
000011ac: ISZERO
000011ad: SWAP1
000011ae: PUSH2 0x11c0
000011b1: JUMPI
000011b2: POP
000011b3: PUSH1 0x00
000011b5: SLOAD
000011b6: PUSH7 0x8e1bc9bf040000
000011be: SWAP1
000011bf: LT
000011c0: JUMPDEST
000011c1: ISZERO
000011c2: PUSH2 0x11d6
000011c5: JUMPI
000011c6: PUSH7 0x8e1bc9bf040000
000011ce: PUSH1 0x00
000011d0: SSTORE
000011d1: PUSH1 0x19
000011d3: PUSH1 0x01
000011d5: SSTORE
000011d6: JUMPDEST
000011d7: PUSH1 0x0d
000011d9: SLOAD
000011da: PUSH1 0x14
000011dc: SWAP1
000011dd: LT
000011de: DUP1
000011df: ISZERO
000011e0: SWAP1
000011e1: PUSH2 0x11f3
000011e4: JUMPI
000011e5: POP
000011e6: PUSH1 0x00
000011e8: SLOAD
000011e9: PUSH7 0x766c7d74835555
000011f1: SWAP1
000011f2: LT
000011f3: JUMPDEST
000011f4: ISZERO
000011f5: PUSH2 0x1209
000011f8: JUMPI
000011f9: PUSH7 0x766c7d74835555
00001201: PUSH1 0x00
00001203: SSTORE
00001204: PUSH1 0x1e
00001206: PUSH1 0x01
00001208: SSTORE
00001209: JUMPDEST
0000120a: PUSH1 0x0d
0000120c: SLOAD
0000120d: PUSH1 0x0a
0000120f: SWAP1
00001210: LT
00001211: DUP1
00001212: ISZERO
00001213: SWAP1
00001214: PUSH2 0x1226
00001217: JUMPI
00001218: POP
00001219: PUSH1 0x00
0000121b: SLOAD
0000121c: PUSH7 0x6581901ab9b6db
00001224: SWAP1
00001225: LT
00001226: JUMPDEST
00001227: ISZERO
00001228: PUSH2 0x123c
0000122b: JUMPI
0000122c: PUSH7 0x6581901ab9b6db
00001234: PUSH1 0x00
00001236: SSTORE
00001237: PUSH1 0x23
00001239: PUSH1 0x01
0000123b: SSTORE
0000123c: JUMPDEST
0000123d: PUSH1 0x0d
0000123f: SLOAD
00001240: PUSH1 0x05
00001242: SWAP1
00001243: LT
00001244: DUP1
00001245: ISZERO
00001246: SWAP1
00001247: PUSH2 0x1259
0000124a: JUMPI
0000124b: POP
0000124c: PUSH1 0x00
0000124e: SLOAD
0000124f: PUSH7 0x58d15e17628000
00001257: SWAP1
00001258: LT
00001259: JUMPDEST
0000125a: ISZERO
0000125b: PUSH2 0x1271
0000125e: JUMPI
0000125f: PUSH7 0x58d15e17628000
00001267: PUSH1 0x00
00001269: SSTORE
0000126a: PUSH1 0x28
0000126c: PUSH1 0x01
0000126e: SSTORE
0000126f: POP
00001270: JUMP
00001271: JUMPDEST
00001272: POP
00001273: JUMP
00001274: JUMPDEST
00001275: DUP6
00001276: PUSH1 0x01
00001278: EQ
00001279: DUP1
0000127a: PUSH2 0x1283
0000127d: JUMPI
0000127e: POP
0000127f: DUP6
00001280: PUSH1 0x03
00001282: EQ
00001283: JUMPDEST
00001284: ISZERO
00001285: PUSH2 0x1294
00001288: JUMPI
00001289: PUSH8 0x29a2241af62c0000
00001292: SWAP3
00001293: POP
00001294: JUMPDEST
00001295: PUSH1 0x40
00001297: MLOAD
00001298: PUSH1 0x01
0000129a: PUSH1 0xa0
0000129c: PUSH1 0x02
0000129e: EXP
0000129f: SUB
000012a0: DUP4
000012a1: AND
000012a2: SWAP1
000012a3: PUSH1 0x00
000012a5: SWAP1
000012a6: DUP6
000012a7: SWAP1
000012a8: DUP3
000012a9: DUP2
000012aa: DUP2
000012ab: DUP2
000012ac: DUP6
000012ad: DUP9
000012ae: DUP4
000012af: CALL
000012b0: SWAP4
000012b1: POP
000012b2: POP
000012b3: POP
000012b4: POP
000012b5: ISZERO
000012b6: ISZERO
000012b7: PUSH2 0x1304
000012ba: JUMPI
000012bb: PUSH2 0x0002
000012be: JUMP
000012bf: JUMPDEST
000012c0: DUP6
000012c1: PUSH1 0x02
000012c3: EQ
000012c4: ISZERO
000012c5: PUSH2 0x12dd
000012c8: JUMPI
000012c9: PUSH1 0x00
000012cb: SLOAD
000012cc: PUSH1 0x64
000012ce: SWAP1
000012cf: DUP7
000012d0: MUL
000012d1: DIV
000012d2: PUSH1 0x0f
000012d4: MUL
000012d5: SWAP1
000012d6: SWAP3
000012d7: ADD
000012d8: SWAP2
000012d9: PUSH2 0x12ff
000012dc: JUMP
000012dd: JUMPDEST
000012de: DUP6
000012df: PUSH1 0x03
000012e1: EQ
000012e2: ISZERO
000012e3: PUSH2 0x12ff
000012e6: JUMPI
000012e7: PUSH1 0x00
000012e9: SLOAD
000012ea: PUSH1 0x64
000012ec: SWAP1
000012ed: DUP7
000012ee: MUL
000012ef: DIV
000012f0: PUSH1 0x0f
000012f2: MUL
000012f3: PUSH8 0x29a2241af62c0000
000012fc: ADD
000012fd: SWAP3
000012fe: POP
000012ff: JUMPDEST
00001300: PUSH2 0x1294
00001303: JUMP
00001304: JUMPDEST
00001305: PUSH1 0x0a
00001307: SLOAD
00001308: PUSH1 0x40
0000130a: MLOAD
0000130b: PUSH1 0x01
0000130d: PUSH1 0xa0
0000130f: PUSH1 0x02
00001311: EXP
00001312: SUB
00001313: SWAP2
00001314: SWAP1
00001315: SWAP2
00001316: AND
00001317: SWAP1
00001318: PUSH1 0x00
0000131a: SWAP1
0000131b: CALLVALUE
0000131c: DUP8
0000131d: SWAP1
0000131e: SUB
0000131f: DUP7
00001320: SWAP1
00001321: SUB
00001322: SWAP1
00001323: DUP3
00001324: DUP2
00001325: DUP2
00001326: DUP2
00001327: DUP6
00001328: DUP9
00001329: DUP4
0000132a: CALL
0000132b: SWAP4
0000132c: POP
0000132d: POP
0000132e: POP
0000132f: POP
00001330: POP
00001331: PUSH2 0x1338
00001334: PUSH2 0x0c22
00001337: JUMP
00001338: JUMPDEST
00001339: POP
0000133a: POP
0000133b: POP
0000133c: POP
0000133d: POP
0000133e: POP
0000133f: JUMP