Analysis Run

{"no_findings":false,"summary":"Bytecode shows multiple CALL sites with computed targets/values and no guards detected in the artifacts; if any of these paths are publicly reachable, they could enable unintended external calls or value transfers.","findings":[{"severity":"medium","category":"other","title":"Computed external CALLs with potential value transfer","exploit_scenario":"The bytecode contains several CALL instructions where both target and value are computed rather than constant. If any of the reachable entrypoints allow a caller to influence these parameters and are not properly access‑controlled, an attacker could cause the contract to send ETH or invoke arbitrary external code (including malicious reentrancy paths) to drain funds or break invariants. The trace evidence saw a constant target in one run, but this was not confirmed across all paths, so the risk remains uncertain.","recommendation":"Verify that every path to these CALLs is restricted (role checks/ownership) and that the target/value are validated (allowlist/immutable addresses, explicit value caps). If state changes can occur around these calls, enforce checks‑effects‑interactions or add a reentrancy guard.","evidence":"Detector findings report “ETH value transfer possible” and “Untrusted CALL target/value reachable” with no guards detected. Callsites recorded at pc 0x08e9, 0x09ce, 0x0e09, 0x114c, 0x146d, 0x16b5; target/value expression categories are computed and returndata checks are not explicitly captured in the detector output.","locations":["pc:0x8e9","pc:0x9ce","pc:0xe09","pc:0x114c","pc:0x146d","pc:0x16b5"]}]}

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

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

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

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

thinking
**Reading BYTECODE_BUNDLE.json**

I'm opening BYTECODE_BUNDLE.json directly to inspect its contents for relevant data since the sandbox is read-only.
exec
/bin/bash -lc ls in /tmp/codex-u_h21szk succeeded in 7ms:
BYTECODE_BUNDLE.json
codex-output-schema.json
exec
/bin/bash -lc 'cat BYTECODE_BUNDLE.json' in /tmp/codex-u_h21szk succeeded in 7ms:
{
  "analysis_artifact": {
    "address": "0xac99380baa171f3a12d7504cf985535ad0bdb26b",
    "artifact_hash": "0x304144eb117d3ef94e2a80eaa526522d3fcbdaf505834c34fb462cddd845ee6d",
    "artifact_json": {
      "auth": {
        "guards": []
      },
      "basic_blocks": [
        {
          "end_pc": 12,
          "hash": "0x6ffe6f1589be70b3aab6ecc36ec1e2e60e4b5e98b2c91917c7625b7e0380e50b",
          "opcodes": [
            "PUSH1",
            "PUSH1",
            "MSTORE",
            "PUSH1",
            "CALLDATASIZE",
            "LT",
            "PUSH2",

thinking
**Analyzing call evidence and targets**

I'm verifying that CALL targets are mostly the contract itself with constant_target flagged false, indicating some computed values. I'll search the JSON for "callsite" or "evidence_bundle" to find detailed callsite information for clearer insight into ETH transfers and call patterns.
exec
/bin/bash -lc 'rg -n "callsites|evidence|storage|slots|proxy|delegate" BYTECODE_BUNDLE.json' in /tmp/codex-u_h21szk succeeded in 7ms:
7033:      "callsites": [
8903:            "delegatecall": 0,
8907:          "storage": {
8909:            "slots": [
8972:            "delegatecall": 0,
8976:          "storage": {
8978:            "slots": [
9041:            "delegatecall": 0,
9045:          "storage": {
9047:            "slots": [
9110:            "delegatecall": 0,
9114:          "storage": {
9116:            "slots": [
9179:            "delegatecall": 0,
9183:          "storage": {
9185:            "slots": [
9248:            "delegatecall": 0,
9252:          "storage": {
9254:            "slots": [
9317:            "delegatecall": 0,

thinking
**Planning callsite inspection**
exec
/bin/bash -lc "sed -n '7000,7085p' BYTECODE_BUNDLE.json" in /tmp/codex-u_h21szk succeeded in 8ms:
            "OP_CE",
            "OP_CC",
            "OP_D7",
            "OP_A0",
            "OP_2A",
            "OP_86",
            "OP_5E",
            "OP_B5",
            "SIGNEXTEND",
            "PUSH5",
            "STOP"
          ],
          "start_pc": 7152
        },
        {
          "end_pc": 7174,
          "hash": "0x899709124adc64823cb7503ae2188d0a73741336cee88678a22c9858e82da658",
          "opcodes": [
            "MOD",
            "MOD",

thinking
**Exploring storage-related modules**

I'm inspecting files related to storage summary and proxy to identify necessary storage slots and functions for implementation.
exec
/bin/bash -lc "sed -n '8860,9050p' BYTECODE_BUNDLE.json" in /tmp/codex-u_h21szk succeeded in 8ms:
        },
        {
          "entry_pc": 1935534583,
          "selector": "0x6324ed92"
        },
        {
          "entry_pc": null,
          "selector": "0x735de9f7"
        },
        {
          "entry_pc": 1606674955,
          "selector": "0x36568abe"
        },
        {
          "entry_pc": null,
          "selector": "0x5fc3ea0b"
        },
        {
          "entry_pc": 287015741,
          "selector": "0x111b833d"

thinking
**Noticing shared logic across functions**

Many functions appear to share the same sinks and storage, suggesting a single dispatcher with multiple selectors leading to the same core code; I'll investigate proxy evidence and storage slots next for clearer insight.
exec
/bin/bash -lc "sed -n '10190,10360p' BYTECODE_BUNDLE.json" in /tmp/codex-u_h21szk succeeded in 10ms:
                "slot": "0x0000000000000000000000000000000000000000000000000000000000000003"
              },
              {
                "op": "SLOAD",
                "pc": 5620,
                "slot": "0x0000000000000000000000000000000000000000000000000000000000000003"
              },
              {
                "op": "SLOAD",
                "pc": 7067,
                "slot": "0x0000000000000000000000000000000000000000000000000000000000000000"
              }
            ],
            "writes": 13
          }
        }
      ],
      "selectors": [
        "0xd547741f",
        "0xe02023a1",


thinking
**Analyzing external callsites and reentrancy risk**

The bytecode shows untrusted external CALLs with value and common token functions, raising reentrancy concerns if state updates happen after calls. Next, I’ll inspect basic blocks around CALL opcodes to check if state changes happen post-call for concrete evidence.
thinking
**Planning opcode disassembly around callsites**

I’m preparing to parse and disassemble the runtime bytecode with a Python script to identify opcodes near CALL instructions at specific PCs, aiming to analyze instruction flow around calls for reentrancy evidence. This approach avoids full JSON parsing by targeting relevant offsets directly.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path

path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
with path.open() as f:
    data=json.load(f)

bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

# opcode names
opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

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

# callsites from bundle
callsites=[c['pc'] for c in data['analysis_artifact']['artifact_json']['callsites']]

# helper: show window
index={pc:i for i,(pc,_,_) in enumerate(ops)}
for pc in callsites:
    i=index.get(pc)
    print('CALLSITE pc',pc)
    if i is None:
        print('  not found')
        continue
    start=max(0,i-8)
    end=min(len(ops),i+8)
    for pc_i,name,imm in ops[start:end]:
        marker='->' if pc_i==pc else '  '
        if imm:
            imm_hex=imm.hex()
            print(f\"{marker} {pc_i:04x}: {name} 0x{imm_hex}\")
        else:
            print(f\"{marker} {pc_i:04x}: {name}\")
    print('')
PY" in /tmp/codex-u_h21szk succeeded in 42ms:
CALLSITE pc 2281
   08de: PUSH2 0x08e6
   08e1: JUMPI
   08e2: PUSH1 0x00
   08e4: DUP1
   08e5: REVERT
   08e6: JUMPDEST
   08e7: POP
   08e8: GAS
-> 08e9: CALL
   08ea: ISZERO
   08eb: DUP1
   08ec: ISZERO
   08ed: PUSH2 0x08fa
   08f0: JUMPI
   08f1: RETURNDATASIZE
   08f2: PUSH1 0x00

CALLSITE pc 2510
   09c3: PUSH2 0x09cb


thinking
**Analyzing external call value usage**

External calls often check success by inspecting return data, reducing some risk. To detect ETH transfers, I'll analyze opcodes around CALL to identify if the value argument (3rd stack slot) is zero or nonzero, by tracing preceding PUSH or CALLVALUE usage, though this is complex and requires careful stack context decoding.
thinking
**Approximating call value via partial stack simulation**

Full stack simulation is complex, so I'll approximate the call's value argument by inspecting and partially simulating a small opcode window before the call, focusing on detecting CALLVALUE usage or immediate pushes indicating nonzero value, while disassembling extended opcode regions around key callsites for clearer context.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path

path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
with path.open() as f:
    data=json.load(f)

bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

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

index={pc:i for i,(pc,_,_) in enumerate(ops)}

callsites=[c['pc'] for c in data['analysis_artifact']['artifact_json']['callsites']]

for pc in callsites:
    i=index.get(pc)
    print('CALLSITE pc',pc)
    if i is None:
        continue
    start=max(0,i-25)
    end=min(len(ops),i+20)
    for pc_i,name,imm in ops[start:end]:
        marker='->' if pc_i==pc else '  '
        if imm:
            imm_hex=imm.hex()
            print(f\"{marker} {pc_i:04x}: {name} 0x{imm_hex}\")
        else:
            print(f\"{marker} {pc_i:04x}: {name}\")
    print('')
PY" in /tmp/codex-u_h21szk succeeded in 36ms:
CALLSITE pc 2281
   08cb: PUSH1 0x20
   08cd: SWAP3
   08ce: SWAP1
   08cf: SWAP2
   08d0: SWAP1
   08d1: DUP3
   08d2: SWAP1
   08d3: SUB
   08d4: ADD
   08d5: DUP2
   08d6: PUSH1 0x00
   08d8: DUP8
   08d9: DUP1
   08da: EXTCODESIZE
   08db: ISZERO
   08dc: DUP1
   08dd: ISZERO
   08de: PUSH2 0x08e6
   08e1: JUMPI


thinking
**Planning symbolic stack analysis**

I'm outlining a way to track the call's value argument by symbolically evaluating the EVM stack backward from the call site within the basic block, treating unknowns conservatively to resolve if the value is zero or dynamic.
thinking
**Investigating storage writes after calls**

I'm focusing on locating SSTORE instructions after external calls by parsing opcode positions to assess reentrancy risk, since storage write details aren't explicitly listed but counts are known.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path

path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
with path.open() as f:
    data=json.load(f)
bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

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

sstore_pcs=[pc for pc,name,_ in ops if name=='SSTORE']
print('SSTORE count',len(sstore_pcs))
print('SSTORE pcs:',sstore_pcs[:50])

call_pcs=[c['pc'] for c in data['analysis_artifact']['artifact_json']['callsites']]

# For each callsite, show nearest subsequent SSTORE within next 200 bytes
for call_pc in call_pcs:
    next_s=[pc for pc in sstore_pcs if pc>call_pc and pc-call_pc<400]
    print('call',call_pc,'next sstore',next_s[:3])

# Show SSTORE around specific region 0x1000-0x1300 for context
for pc,name,imm in ops:
    if 0x1000 <= pc <= 0x1300 and name=='SSTORE':
        print('SSTORE at',hex(pc))
PY" in /tmp/codex-u_h21szk succeeded in 41ms:
SSTORE count 13
SSTORE pcs: [2044, 3078, 4122, 4689, 6372, 6577, 6593, 6612, 6722, 6742, 6773, 6775, 6800]
call 2281 next sstore []
call 2510 next sstore []
call 3593 next sstore []
call 4428 next sstore [4689]
call 5229 next sstore []
call 5813 next sstore []
SSTORE at 0x101a
SSTORE at 0x1251

thinking
**Inspecting potential reentrancy risk near key call and state update**

I'm examining disassembly around the external call at 0x114c and the subsequent state update at 0x1251 to determine if the SSTORE happens after the external call, which could expose a reentrancy vulnerability. I'll check the instruction flow from 0x1120 to 0x1280 for clarity.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path

path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
with path.open() as f:
    data=json.load(f)
bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

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

# show region 0x1120-0x1280
start=0x1120
end=0x1280
for pc,name,imm in ops:
    if start <= pc <= end:
        if imm:
            print(f\"{pc:04x}: {name} 0x{imm.hex()}\")
        else:
            print(f\"{pc:04x}: {name}\")
PY" in /tmp/codex-u_h21szk succeeded in 51ms:
1120: MSTORE
1121: SWAP1
1122: MLOAD
1123: SWAP1
1124: DUP2
1125: SWAP1
1126: SUB
1127: PUSH1 0x64
1129: ADD
112a: SWAP1
112b: REVERT
112c: JUMPDEST
112d: PUSH1 0x40
112f: MLOAD
1130: PUSH1 0x01
1132: PUSH1 0x01
1134: PUSH1 0xa0
1136: SHL
1137: SUB
1138: DUP4


thinking
**Analyzing external call before state update**

The external call occurs before the SSTORE, raising potential reentrancy risk, but there’s no direct evidence of a reentrancy guard present since the strings lack typical indicators like "ReentrancyGuard." I'll next verify guard usage to confirm vulnerability risk.
thinking
**Clarifying reentrancy risk amid uncertain control flow**

The call before SSTORE likely occurs in separate functions, weakening the claim of state update after call in the same flow; control flow ambiguity prevents confirming reentrancy risk confidently. I'll note multiple untrusted external calls with possible ETH transfer and that access control exists but guard detection heuristics show none.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path
path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
data=json.loads(path.read_text())
bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

pcs=[]
pc=0
while pc < len(code):
    op=code[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if name=='CALLVALUE':
        pcs.append(pc)
    if 0x60 <= op <= 0x7f:
        pc+=1+(op-0x5f)
    else:
        pc+=1

print('CALLVALUE count',len(pcs))
print('CALLVALUE pcs',pcs[:20])
PY" in /tmp/codex-u_h21szk succeeded in 35ms:
CALLVALUE count 15
CALLVALUE pcs [812, 872, 929, 986, 1350, 1399, 1447, 1524, 1581, 1602, 1623, 1665, 1708, 1765, 1786]


thinking
**Planning symbolic stack simulation**

I'm considering simulating the instruction stack from the last JUMPDEST before each CALL to approximate whether the call's value argument is zero or variable, aiming to detect payable versus nonpayable calls by analyzing a fixed window of instructions within basic blocks.
thinking
**Designing symbolic stack simulator**

I'm outlining a symbolic stack simulator that tracks stack state from the previous JUMPDEST to each CALL, representing unknown initial stack values as symbols and propagating expressions to determine if the CALL's value argument is a constant zero or symbolic. This approach will handle core EVM ops minimally to detect constant value usage despite uncertain stack depth.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path

path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
with path.open() as f:
    data=json.load(f)
bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

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

index={pc:i for i,(pc,_,_) in enumerate(ops)}

callsites=[c['pc'] for c in data['analysis_artifact']['artifact_json']['callsites']]

# simple symbolic value
counter=0

def sym():
    global counter
    counter+=1
    return f's{counter}'


def binop(a,b,op):
    if isinstance(a,int) and isinstance(b,int):
        if op=='ADD':
            return (a+b) & ((1<<256)-1)
        if op=='SUB':
            return (a-b) & ((1<<256)-1)
        if op=='MUL':
            return (a*b) & ((1<<256)-1)
        if op=='AND':
            return a & b
        if op=='OR':
            return a | b
        if op=='XOR':
            return a "'^ b
        if op=='"'SHL':
            return (a<<b) & ((1<<256)-1)
        if op=='SHR':
            return (a>>b)
    return f'({a} {op} {b})'


def unop(a,op):
    if isinstance(a,int):
        if op=='ISZERO':
            return 1 if a==0 else 0
        if op=='NOT':
            return ((1<<256)-1) "'^ a
    return f'"'{op}({a})'


def simulate(start_idx, end_idx):
    stack=[sym() for _ in range(15)]  # initial unknown stack depth
    for i in range(start_idx, end_idx):
        pc,name,imm=ops[i]
        # handle op
        if name.startswith('PUSH'):
            stack.append(int.from_bytes(imm,'big'))
        elif name.startswith('DUP'):
            n=int(name[3:])
            stack.append(stack[-n])
        elif name.startswith('SWAP'):
            n=int(name[4:])
            stack[-1],stack[-1-n]=stack[-1-n],stack[-1]
        elif name=='POP':
            stack.pop()
        elif name in ('ADD','SUB','MUL','AND','OR','XOR','SHL','SHR'):
            b=stack.pop(); a=stack.pop();
            stack.append(binop(a,b,name))
        elif name in ('ISZERO','NOT'):
            a=stack.pop(); stack.append(unop(a,name))
        elif name in ('EXTCODESIZE','CALLDATALOAD','SLOAD','MLOAD','BALANCE','SELFBALANCE','GAS','RETURNDATASIZE','CALLER','CALLVALUE','ADDRESS','ORIGIN','NUMBER','TIMESTAMP','CHAINID','BASEFEE','GASPRICE','EXTCODEHASH','MSIZE'):
            # consume args if any
            if name in ('CALLDATALOAD','SLOAD','MLOAD','BALANCE','EXTCODESIZE','EXTCODEHASH'):
                stack.pop()
            # push unknown
            stack.append(sym())
        elif name in ('SHA3',):
            # pop 2
            stack.pop(); stack.pop(); stack.append(sym())
        elif name in ('JUMP','JUMPI','JUMPDEST','STOP','RETURN','REVERT','INVALID','LOG0','LOG1','LOG2','LOG3','LOG4'):
            # approximate stack effects
            if name=='JUMPI':
                stack.pop(); stack.pop()
            elif name=='JUMP':
                stack.pop()
            elif name.startswith('LOG'):
                n=int(name[3:])
                # pop mstart, msize and n topics
                for _ in range(2+n):
                    stack.pop()
            elif name in ('RETURN','REVERT'):
                stack.pop(); stack.pop()
            # else no stack
        elif name=='CALL':
            # shouldn't reach here in simulate pre-call
            pass
        else:
            # default: unknown stack effects -> skip
            pass
    return stack

# find previous JUMPDEST for call
for call_pc in callsites:
    call_idx=index[call_pc]
    # find previous JUMPDEST
    start_idx=call_idx
    while start_idx>0 and ops[start_idx][1] "'!= '"'JUMPDEST':
        start_idx-=1
    stack=simulate(start_idx, call_idx)
    # CALL expects 7 args; value is stack[-3] (gas,to,value,in_ofs,in_size,out_ofs,out_size)
    if len(stack) < 7:
        value='unknown'
    else:
        value=stack[-3]
    print(hex(call_pc), 'value arg symbolic:', value)
PY" in /tmp/codex-u_h21szk succeeded in 48ms:
0x8e9 value arg symbolic: s13
0x9ce value arg symbolic: s29
0xe09 value arg symbolic: s45
0x114c value arg symbolic: s61
0x146d value arg symbolic: s77
0x16b5 value arg symbolic: s93


thinking
**Flagging potential untrusted CALLs with value**

Symbolic simulation shows call value arguments are not simply zero but potentially derived or unknown, indicating possible external calls with nonzero ETH value and missing authorization guards; this justifies a conservative medium-severity finding with evidence from callsites and detectors.
thinking
**Refining findings with conservative evidence**

Plans to issue a few findings: untrusted external calls with computed targets/values and potential reentrancy due to missing detected guards, while noting no proxy or delegatecall usage and limited guard/access control evidence; also assessing ERC20 call handling to clarify if return data is safely checked before deciding severity.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path

path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
with path.open() as f:
    data=json.load(f)
bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

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

start=0x0d20
end=0x0e50
for pc,name,imm in ops:
    if start <= pc <= end:
        if imm:
            print(f\"{pc:04x}: {name} 0x{imm.hex()}\")
        else:
            print(f\"{pc:04x}: {name}\")
PY" in /tmp/codex-u_h21szk succeeded in 52ms:
0d20: SWAP1
0d21: REVERT
0d22: JUMPDEST
0d23: PUSH2 0x0cc7
0d26: DUP3
0d27: DUP3
0d28: PUSH2 0x1849
0d2b: JUMP
0d2c: JUMPDEST
0d2d: PUSH1 0x40
0d2f: DUP1
0d30: MLOAD
0d31: PUSH8 0x5749544844524157
0d3a: PUSH1 0xc0
0d3c: SHL
0d3d: DUP2
0d3e: MSTORE
0d3f: SWAP1
0d40: MLOAD
0d41: SWAP1

thinking
**Verifying state updates after token call**

I'm confirming whether any storage writes occur after the token transfer call by searching for SSTORE instructions in the relevant bytecode region to assess reentrancy risk.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path
path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
data=json.loads(path.read_text())
bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

ops=[]
pc=0
while pc < len(code):
    op=code[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    imm=b''
    if 0x60 <= op <= 0x7f:
        pc+=1+(op-0x5f)
    else:
        pc+=1
    if name=='SSTORE' and 0xd20 <= pc <= 0xf00:
        print('SSTORE near',hex(pc-1))
PY" in /tmp/codex-u_h21szk succeeded in 36ms:



thinking
**Concluding low reentrancy risk with caution**

No state updates follow external calls with value, lowering reentrancy risk; findings will note only a caution about untrusted external CALLs lacking explicit access control or reentrancy guards.
thinking
**Identifying external CALL patterns with gas stipend logic**

Detailed analysis reveals an external CALL pattern matching Solidity’s ETH transfer using a 2300 gas stipend conditional on value, indicating typical low-level transfer behavior; this supports flagging untrusted external CALLs with computed targets and possible value transfer as a medium-severity caution due to potential reentrancy if state updates follow the call.
exec
/bin/bash -lc "python - <<'PY'
import json
from pathlib import Path
path=Path('/tmp/codex-u_h21szk/BYTECODE_BUNDLE.json')
data=json.loads(path.read_text())
bytecode=data['artifact']['runtime_bytecode']['full']
if bytecode.startswith('0x'):
    bytecode=bytecode[2:]
code=bytes.fromhex(bytecode)

opnames={
    **{i:f'PUSH{i-0x5f}' for i in range(0x60,0x80)},
    **{i:f'DUP{i-0x7f}' for i in range(0x80,0x90)},
    **{i:f'SWAP{i-0x8f}' for i in range(0x90,0xa0)},
    **{i:f'LOG{i-0xa0}' for i in range(0xa0,0xa5)},
}
base={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}
opnames.update(base)

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

start=0x0860
end=0x0940
for pc,name,imm in ops:
    if start <= pc <= end:
        if imm:
            print(f\"{pc:04x}: {name} 0x{imm.hex()}\")
        else:
            print(f\"{pc:04x}: {name}\")
PY" in /tmp/codex-u_h21szk succeeded in 44ms:
0861: PUSH1 0x01
0863: PUSH1 0xa0
0865: SHL
0866: SUB
0867: AND
0868: SWAP1
0869: POP
086a: PUSH1 0x00
086c: DUP1
086d: SWAP1
086e: POP
086f: JUMPDEST
0870: DUP5
0871: DUP2
0872: LT
0873: ISZERO
0874: PUSH2 0x0a48
0877: JUMPI
0878: PUSH1 0x03
087a: SLOAD


thinking
**Concluding no critical vulnerabilities**

The calls mostly include proper return data size checks or reasonable exceptions (like ETH transfers), with external calls expected in DeFi context; given no clear unsafe patterns emerge, concluding no findings is justified despite untrusted calls.
thinking
**Flagging medium-severity caution on external CALLs**

Detected multiple external CALLs with computed targets and possible ETH value transfer lacking explicit guard detection, posing potential risk if access control or reentrancy protections are missing; issuing a medium-severity finding advising strict validation and access restrictions.
codex
{"no_findings":false,"summary":"Bytecode shows multiple CALL sites with computed targets/values and no guards detected in the artifacts; if any of these paths are publicly reachable, they could enable unintended external calls or value transfers.","findings":[{"severity":"medium","category":"other","title":"Computed external CALLs with potential value transfer","exploit_scenario":"The bytecode contains several CALL instructions where both target and value are computed rather than constant. If any of the reachable entrypoints allow a caller to influence these parameters and are not properly access‑controlled, an attacker could cause the contract to send ETH or invoke arbitrary external code (including malicious reentrancy paths) to drain funds or break invariants. The trace evidence saw a constant target in one run, but this was not confirmed across all paths, so the risk remains uncertain.","recommendation":"Verify that every path to these CALLs is restricted (role checks/ownership) and that the target/value are validated (allowlist/immutable addresses, explicit value caps). If state changes can occur around these calls, enforce checks‑effects‑interactions or add a reentrancy guard.","evidence":"Detector findings report “ETH value transfer possible” and “Untrusted CALL target/value reachable” with no guards detected. Callsites recorded at pc 0x08e9, 0x09ce, 0x0e09, 0x114c, 0x146d, 0x16b5; target/value expression categories are computed and returndata checks are not explicitly captured in the detector output.","locations":["pc:0x8e9","pc:0x9ce","pc:0xe09","pc:0x114c","pc:0x146d","pc:0x16b5"]}]}
tokens used
75,396

{
    "codex": {
        "ran_at": "2026-01-22T07:45:39.044479+00:00",
        "returncode": 0
    },
    "project": {
        "mode": "bytecode",
        "bytecode_length": 14354,
        "bytecode_truncated": false,
        "capability_graph_present": true,
        "analysis_artifact_present": true
    },
    "summary": "Bytecode shows multiple CALL sites with computed targets/values and no guards detected in the artifacts; if any of these paths are publicly reachable, they could enable unintended external calls or value transfers.",
    "raw_final": {
        "summary": "Bytecode shows multiple CALL sites with computed targets/values and no guards detected in the artifacts; if any of these paths are publicly reachable, they could enable unintended external calls or value transfers.",
        "findings": [
            {
                "title": "Computed external CALLs with potential value transfer",
                "category": "other",
                "evidence": "Detector findings report \u201cETH value transfer possible\u201d and \u201cUntrusted CALL target/value reachable\u201d with no guards detected. Callsites recorded at pc 0x08e9, 0x09ce, 0x0e09, 0x114c, 0x146d, 0x16b5; target/value expression categories are computed and returndata checks are not explicitly captured in the detector output.",
                "severity": "medium",
                "locations": [
                    "pc:0x8e9",
                    "pc:0x9ce",
                    "pc:0xe09",
                    "pc:0x114c",
                    "pc:0x146d",
                    "pc:0x16b5"
                ],
                "recommendation": "Verify that every path to these CALLs is restricted (role checks/ownership) and that the target/value are validated (allowlist/immutable addresses, explicit value caps). If state changes can occur around these calls, enforce checks\u2011effects\u2011interactions or add a reentrancy guard.",
                "exploit_scenario": "The bytecode contains several CALL instructions where both target and value are computed rather than constant. If any of the reachable entrypoints allow a caller to influence these parameters and are not properly access\u2011controlled, an attacker could cause the contract to send ETH or invoke arbitrary external code (including malicious reentrancy paths) to drain funds or break invariants. The trace evidence saw a constant target in one run, but this was not confirmed across all paths, so the risk remains uncertain."
            }
        ],
        "no_findings": false
    },
    "no_findings": false,
    "schema_version": 1
}

00000000: PUSH1 0x80
00000002: PUSH1 0x40
00000004: MSTORE
00000005: PUSH1 0x04
00000007: CALLDATASIZE
00000008: LT
00000009: PUSH2 0x0162
0000000c: JUMPI
0000000d: PUSH1 0x00
0000000f: CALLDATALOAD
00000010: PUSH1 0xe0
00000012: SHR
00000013: DUP1
00000014: PUSH4 0x9010d07c
00000019: GT
0000001a: PUSH2 0x00c0
0000001d: JUMPI
0000001e: DUP1
0000001f: PUSH4 0xca15c873
00000024: GT
00000025: PUSH2 0x0074
00000028: JUMPI
00000029: DUP1
0000002a: PUSH4 0xd547741f
0000002f: GT
00000030: PUSH2 0x0059
00000033: JUMPI
00000034: DUP1
00000035: PUSH4 0xd547741f
0000003a: EQ
0000003b: PUSH2 0x06ab
0000003e: JUMPI
0000003f: DUP1
00000040: PUSH4 0xe02023a1
00000045: EQ
00000046: PUSH2 0x06e4
00000049: JUMPI
0000004a: DUP1
0000004b: PUSH4 0xe67d636f
00000050: EQ
00000051: PUSH2 0x06f9
00000054: JUMPI
00000055: PUSH2 0x0169
00000058: JUMP
00000059: JUMPDEST
0000005a: DUP1
0000005b: PUSH4 0xca15c873
00000060: EQ
00000061: PUSH2 0x0656
00000064: JUMPI
00000065: DUP1
00000066: PUSH4 0xcfdbf254
0000006b: EQ
0000006c: PUSH2 0x0680
0000006f: JUMPI
00000070: PUSH2 0x0169
00000073: JUMP
00000074: JUMPDEST
00000075: DUP1
00000076: PUSH4 0xa158657c
0000007b: GT
0000007c: PUSH2 0x00a5
0000007f: JUMPI
00000080: DUP1
00000081: PUSH4 0xa158657c
00000086: EQ
00000087: PUSH2 0x05f3
0000008a: JUMPI
0000008b: DUP1
0000008c: PUSH4 0xa217fddf
00000091: EQ
00000092: PUSH2 0x062c
00000095: JUMPI
00000096: DUP1
00000097: PUSH4 0xa26a6cc6
0000009c: EQ
0000009d: PUSH2 0x0641
000000a0: JUMPI
000000a1: PUSH2 0x0169
000000a4: JUMP
000000a5: JUMPDEST
000000a6: DUP1
000000a7: PUSH4 0x9010d07c
000000ac: EQ
000000ad: PUSH2 0x0576
000000b0: JUMPI
000000b1: DUP1
000000b2: PUSH4 0x91d14854
000000b7: EQ
000000b8: PUSH2 0x05a6
000000bb: JUMPI
000000bc: PUSH2 0x0169
000000bf: JUMP
000000c0: JUMPDEST
000000c1: DUP1
000000c2: PUSH4 0x36568abe
000000c7: GT
000000c8: PUSH2 0x0117
000000cb: JUMPI
000000cc: DUP1
000000cd: PUSH4 0x60e1d17f
000000d2: GT
000000d3: PUSH2 0x00fc
000000d6: JUMPI
000000d7: DUP1
000000d8: PUSH4 0x60e1d17f
000000dd: EQ
000000de: PUSH2 0x041c
000000e1: JUMPI
000000e2: DUP1
000000e3: PUSH4 0x6324ed92
000000e8: EQ
000000e9: PUSH2 0x04ae
000000ec: JUMPI
000000ed: DUP1
000000ee: PUSH4 0x735de9f7
000000f3: EQ
000000f4: PUSH2 0x0545
000000f7: JUMPI
000000f8: PUSH2 0x0169
000000fb: JUMP
000000fc: JUMPDEST
000000fd: DUP1
000000fe: PUSH4 0x36568abe
00000103: EQ
00000104: PUSH2 0x03a0
00000107: JUMPI
00000108: DUP1
00000109: PUSH4 0x5fc3ea0b
0000010e: EQ
0000010f: PUSH2 0x03d9
00000112: JUMPI
00000113: PUSH2 0x0169
00000116: JUMP
00000117: JUMPDEST
00000118: DUP1
00000119: PUSH4 0x111b833d
0000011e: GT
0000011f: PUSH2 0x0148
00000122: JUMPI
00000123: DUP1
00000124: PUSH4 0x111b833d
00000129: EQ
0000012a: PUSH2 0x0293
0000012d: JUMPI
0000012e: DUP1
0000012f: PUSH4 0x248a9ca3
00000134: EQ
00000135: PUSH2 0x032b
00000138: JUMPI
00000139: DUP1
0000013a: PUSH4 0x2f2ff15d
0000013f: EQ
00000140: PUSH2 0x0367
00000143: JUMPI
00000144: PUSH2 0x0169
00000147: JUMP
00000148: JUMPDEST
00000149: DUP1
0000014a: PUSH3 0x36d3b2
0000014e: EQ
0000014f: PUSH2 0x016b
00000152: JUMPI
00000153: DUP1
00000154: PUSH4 0x0de2eadb
00000159: EQ
0000015a: PUSH2 0x0202
0000015d: JUMPI
0000015e: PUSH2 0x0169
00000161: JUMP
00000162: JUMPDEST
00000163: CALLDATASIZE
00000164: PUSH2 0x0169
00000167: JUMPI
00000168: STOP
00000169: JUMPDEST
0000016a: STOP
0000016b: JUMPDEST
0000016c: PUSH2 0x0169
0000016f: PUSH1 0x04
00000171: DUP1
00000172: CALLDATASIZE
00000173: SUB
00000174: PUSH1 0xe0
00000176: DUP2
00000177: LT
00000178: ISZERO
00000179: PUSH2 0x0181
0000017c: JUMPI
0000017d: PUSH1 0x00
0000017f: DUP1
00000180: REVERT
00000181: JUMPDEST
00000182: DUP2
00000183: CALLDATALOAD
00000184: SWAP2
00000185: PUSH1 0x20
00000187: DUP2
00000188: ADD
00000189: CALLDATALOAD
0000018a: SWAP2
0000018b: DUP2
0000018c: ADD
0000018d: SWAP1
0000018e: PUSH1 0x60
00000190: DUP2
00000191: ADD
00000192: PUSH1 0x40
00000194: DUP3
00000195: ADD
00000196: CALLDATALOAD
00000197: PUSH5 0x0100000000
0000019d: DUP2
0000019e: GT
0000019f: ISZERO
000001a0: PUSH2 0x01a8
000001a3: JUMPI
000001a4: PUSH1 0x00
000001a6: DUP1
000001a7: REVERT
000001a8: JUMPDEST
000001a9: DUP3
000001aa: ADD
000001ab: DUP4
000001ac: PUSH1 0x20
000001ae: DUP3
000001af: ADD
000001b0: GT
000001b1: ISZERO
000001b2: PUSH2 0x01ba
000001b5: JUMPI
000001b6: PUSH1 0x00
000001b8: DUP1
000001b9: REVERT
000001ba: JUMPDEST
000001bb: DUP1
000001bc: CALLDATALOAD
000001bd: SWAP1
000001be: PUSH1 0x20
000001c0: ADD
000001c1: SWAP2
000001c2: DUP5
000001c3: PUSH1 0x20
000001c5: DUP4
000001c6: MUL
000001c7: DUP5
000001c8: ADD
000001c9: GT
000001ca: PUSH5 0x0100000000
000001d0: DUP4
000001d1: GT
000001d2: OR
000001d3: ISZERO
000001d4: PUSH2 0x01dc
000001d7: JUMPI
000001d8: PUSH1 0x00
000001da: DUP1
000001db: REVERT
000001dc: JUMPDEST
000001dd: SWAP2
000001de: SWAP4
000001df: POP
000001e0: SWAP2
000001e1: POP
000001e2: PUSH1 0x01
000001e4: PUSH1 0x01
000001e6: PUSH1 0xa0
000001e8: SHL
000001e9: SUB
000001ea: DUP2
000001eb: CALLDATALOAD
000001ec: AND
000001ed: SWAP1
000001ee: PUSH1 0x20
000001f0: DUP2
000001f1: ADD
000001f2: CALLDATALOAD
000001f3: SWAP1
000001f4: PUSH1 0x40
000001f6: DUP2
000001f7: ADD
000001f8: CALLDATALOAD
000001f9: SWAP1
000001fa: PUSH1 0x60
000001fc: ADD
000001fd: CALLDATALOAD
000001fe: PUSH2 0x070e
00000201: JUMP
00000202: JUMPDEST
00000203: PUSH2 0x0169
00000206: PUSH1 0x04
00000208: DUP1
00000209: CALLDATASIZE
0000020a: SUB
0000020b: PUSH1 0xc0
0000020d: DUP2
0000020e: LT
0000020f: ISZERO
00000210: PUSH2 0x0218
00000213: JUMPI
00000214: PUSH1 0x00
00000216: DUP1
00000217: REVERT
00000218: JUMPDEST
00000219: DUP2
0000021a: CALLDATALOAD
0000021b: SWAP2
0000021c: PUSH1 0x20
0000021e: DUP2
0000021f: ADD
00000220: CALLDATALOAD
00000221: SWAP2
00000222: DUP2
00000223: ADD
00000224: SWAP1
00000225: PUSH1 0x60
00000227: DUP2
00000228: ADD
00000229: PUSH1 0x40
0000022b: DUP3
0000022c: ADD
0000022d: CALLDATALOAD
0000022e: PUSH5 0x0100000000
00000234: DUP2
00000235: GT
00000236: ISZERO
00000237: PUSH2 0x023f
0000023a: JUMPI
0000023b: PUSH1 0x00
0000023d: DUP1
0000023e: REVERT
0000023f: JUMPDEST
00000240: DUP3
00000241: ADD
00000242: DUP4
00000243: PUSH1 0x20
00000245: DUP3
00000246: ADD
00000247: GT
00000248: ISZERO
00000249: PUSH2 0x0251
0000024c: JUMPI
0000024d: PUSH1 0x00
0000024f: DUP1
00000250: REVERT
00000251: JUMPDEST
00000252: DUP1
00000253: CALLDATALOAD
00000254: SWAP1
00000255: PUSH1 0x20
00000257: ADD
00000258: SWAP2
00000259: DUP5
0000025a: PUSH1 0x20
0000025c: DUP4
0000025d: MUL
0000025e: DUP5
0000025f: ADD
00000260: GT
00000261: PUSH5 0x0100000000
00000267: DUP4
00000268: GT
00000269: OR
0000026a: ISZERO
0000026b: PUSH2 0x0273
0000026e: JUMPI
0000026f: PUSH1 0x00
00000271: DUP1
00000272: REVERT
00000273: JUMPDEST
00000274: SWAP2
00000275: SWAP4
00000276: POP
00000277: SWAP2
00000278: POP
00000279: PUSH1 0x01
0000027b: PUSH1 0x01
0000027d: PUSH1 0xa0
0000027f: SHL
00000280: SUB
00000281: DUP2
00000282: CALLDATALOAD
00000283: AND
00000284: SWAP1
00000285: PUSH1 0x20
00000287: DUP2
00000288: ADD
00000289: CALLDATALOAD
0000028a: SWAP1
0000028b: PUSH1 0x40
0000028d: ADD
0000028e: CALLDATALOAD
0000028f: PUSH2 0x0a55
00000292: JUMP
00000293: JUMPDEST
00000294: PUSH2 0x0169
00000297: PUSH1 0x04
00000299: DUP1
0000029a: CALLDATASIZE
0000029b: SUB
0000029c: PUSH1 0xe0
0000029e: DUP2
0000029f: LT
000002a0: ISZERO
000002a1: PUSH2 0x02a9
000002a4: JUMPI
000002a5: PUSH1 0x00
000002a7: DUP1
000002a8: REVERT
000002a9: JUMPDEST
000002aa: DUP2
000002ab: CALLDATALOAD
000002ac: SWAP2
000002ad: SWAP1
000002ae: DUP2
000002af: ADD
000002b0: SWAP1
000002b1: PUSH1 0x40
000002b3: DUP2
000002b4: ADD
000002b5: PUSH1 0x20
000002b7: DUP3
000002b8: ADD
000002b9: CALLDATALOAD
000002ba: PUSH5 0x0100000000
000002c0: DUP2
000002c1: GT
000002c2: ISZERO
000002c3: PUSH2 0x02cb
000002c6: JUMPI
000002c7: PUSH1 0x00
000002c9: DUP1
000002ca: REVERT
000002cb: JUMPDEST
000002cc: DUP3
000002cd: ADD
000002ce: DUP4
000002cf: PUSH1 0x20
000002d1: DUP3
000002d2: ADD
000002d3: GT
000002d4: ISZERO
000002d5: PUSH2 0x02dd
000002d8: JUMPI
000002d9: PUSH1 0x00
000002db: DUP1
000002dc: REVERT
000002dd: JUMPDEST
000002de: DUP1
000002df: CALLDATALOAD
000002e0: SWAP1
000002e1: PUSH1 0x20
000002e3: ADD
000002e4: SWAP2
000002e5: DUP5
000002e6: PUSH1 0x20
000002e8: DUP4
000002e9: MUL
000002ea: DUP5
000002eb: ADD
000002ec: GT
000002ed: PUSH5 0x0100000000
000002f3: DUP4
000002f4: GT
000002f5: OR
000002f6: ISZERO
000002f7: PUSH2 0x02ff
000002fa: JUMPI
000002fb: PUSH1 0x00
000002fd: DUP1
000002fe: REVERT
000002ff: JUMPDEST
00000300: SWAP2
00000301: SWAP4
00000302: POP
00000303: SWAP2
00000304: POP
00000305: PUSH1 0x01
00000307: PUSH1 0x01
00000309: PUSH1 0xa0
0000030b: SHL
0000030c: SUB
0000030d: DUP2
0000030e: CALLDATALOAD
0000030f: AND
00000310: SWAP1
00000311: PUSH1 0x20
00000313: DUP2
00000314: ADD
00000315: CALLDATALOAD
00000316: SWAP1
00000317: PUSH1 0x40
00000319: DUP2
0000031a: ADD
0000031b: CALLDATALOAD
0000031c: SWAP1
0000031d: PUSH1 0x60
0000031f: DUP2
00000320: ADD
00000321: CALLDATALOAD
00000322: SWAP1
00000323: PUSH1 0x80
00000325: ADD
00000326: CALLDATALOAD
00000327: PUSH2 0x0b19
0000032a: JUMP
0000032b: JUMPDEST
0000032c: CALLVALUE
0000032d: DUP1
0000032e: ISZERO
0000032f: PUSH2 0x0337
00000332: JUMPI
00000333: PUSH1 0x00
00000335: DUP1
00000336: REVERT
00000337: JUMPDEST
00000338: POP
00000339: PUSH2 0x0355
0000033c: PUSH1 0x04
0000033e: DUP1
0000033f: CALLDATASIZE
00000340: SUB
00000341: PUSH1 0x20
00000343: DUP2
00000344: LT
00000345: ISZERO
00000346: PUSH2 0x034e
00000349: JUMPI
0000034a: PUSH1 0x00
0000034c: DUP1
0000034d: REVERT
0000034e: JUMPDEST
0000034f: POP
00000350: CALLDATALOAD
00000351: PUSH2 0x0c4f
00000354: JUMP
00000355: JUMPDEST
00000356: PUSH1 0x40
00000358: DUP1
00000359: MLOAD
0000035a: SWAP2
0000035b: DUP3
0000035c: MSTORE
0000035d: MLOAD
0000035e: SWAP1
0000035f: DUP2
00000360: SWAP1
00000361: SUB
00000362: PUSH1 0x20
00000364: ADD
00000365: SWAP1
00000366: RETURN
00000367: JUMPDEST
00000368: CALLVALUE
00000369: DUP1
0000036a: ISZERO
0000036b: PUSH2 0x0373
0000036e: JUMPI
0000036f: PUSH1 0x00
00000371: DUP1
00000372: REVERT
00000373: JUMPDEST
00000374: POP
00000375: PUSH2 0x0169
00000378: PUSH1 0x04
0000037a: DUP1
0000037b: CALLDATASIZE
0000037c: SUB
0000037d: PUSH1 0x40
0000037f: DUP2
00000380: LT
00000381: ISZERO
00000382: PUSH2 0x038a
00000385: JUMPI
00000386: PUSH1 0x00
00000388: DUP1
00000389: REVERT
0000038a: JUMPDEST
0000038b: POP
0000038c: DUP1
0000038d: CALLDATALOAD
0000038e: SWAP1
0000038f: PUSH1 0x20
00000391: ADD
00000392: CALLDATALOAD
00000393: PUSH1 0x01
00000395: PUSH1 0x01
00000397: PUSH1 0xa0
00000399: SHL
0000039a: SUB
0000039b: AND
0000039c: PUSH2 0x0c64
0000039f: JUMP
000003a0: JUMPDEST
000003a1: CALLVALUE
000003a2: DUP1
000003a3: ISZERO
000003a4: PUSH2 0x03ac
000003a7: JUMPI
000003a8: PUSH1 0x00
000003aa: DUP1
000003ab: REVERT
000003ac: JUMPDEST
000003ad: POP
000003ae: PUSH2 0x0169
000003b1: PUSH1 0x04
000003b3: DUP1
000003b4: CALLDATASIZE
000003b5: SUB
000003b6: PUSH1 0x40
000003b8: DUP2
000003b9: LT
000003ba: ISZERO
000003bb: PUSH2 0x03c3
000003be: JUMPI
000003bf: PUSH1 0x00
000003c1: DUP1
000003c2: REVERT
000003c3: JUMPDEST
000003c4: POP
000003c5: DUP1
000003c6: CALLDATALOAD
000003c7: SWAP1
000003c8: PUSH1 0x20
000003ca: ADD
000003cb: CALLDATALOAD
000003cc: PUSH1 0x01
000003ce: PUSH1 0x01
000003d0: PUSH1 0xa0
000003d2: SHL
000003d3: SUB
000003d4: AND
000003d5: PUSH2 0x0ccb
000003d8: JUMP
000003d9: JUMPDEST
000003da: CALLVALUE
000003db: DUP1
000003dc: ISZERO
000003dd: PUSH2 0x03e5
000003e0: JUMPI
000003e1: PUSH1 0x00
000003e3: DUP1
000003e4: REVERT
000003e5: JUMPDEST
000003e6: POP
000003e7: PUSH2 0x0169
000003ea: PUSH1 0x04
000003ec: DUP1
000003ed: CALLDATASIZE
000003ee: SUB
000003ef: PUSH1 0x60
000003f1: DUP2
000003f2: LT
000003f3: ISZERO
000003f4: PUSH2 0x03fc
000003f7: JUMPI
000003f8: PUSH1 0x00
000003fa: DUP1
000003fb: REVERT
000003fc: JUMPDEST
000003fd: POP
000003fe: PUSH1 0x01
00000400: PUSH1 0x01
00000402: PUSH1 0xa0
00000404: SHL
00000405: SUB
00000406: DUP2
00000407: CALLDATALOAD
00000408: DUP2
00000409: AND
0000040a: SWAP2
0000040b: PUSH1 0x20
0000040d: DUP2
0000040e: ADD
0000040f: CALLDATALOAD
00000410: SWAP2
00000411: PUSH1 0x40
00000413: SWAP1
00000414: SWAP2
00000415: ADD
00000416: CALLDATALOAD
00000417: AND
00000418: PUSH2 0x0d2c
0000041b: JUMP
0000041c: JUMPDEST
0000041d: PUSH2 0x0169
00000420: PUSH1 0x04
00000422: DUP1
00000423: CALLDATASIZE
00000424: SUB
00000425: PUSH1 0xc0
00000427: DUP2
00000428: LT
00000429: ISZERO
0000042a: PUSH2 0x0432
0000042d: JUMPI
0000042e: PUSH1 0x00
00000430: DUP1
00000431: REVERT
00000432: JUMPDEST
00000433: DUP2
00000434: CALLDATALOAD
00000435: SWAP2
00000436: SWAP1
00000437: DUP2
00000438: ADD
00000439: SWAP1
0000043a: PUSH1 0x40
0000043c: DUP2
0000043d: ADD
0000043e: PUSH1 0x20
00000440: DUP3
00000441: ADD
00000442: CALLDATALOAD
00000443: PUSH5 0x0100000000
00000449: DUP2
0000044a: GT
0000044b: ISZERO
0000044c: PUSH2 0x0454
0000044f: JUMPI
00000450: PUSH1 0x00
00000452: DUP1
00000453: REVERT
00000454: JUMPDEST
00000455: DUP3
00000456: ADD
00000457: DUP4
00000458: PUSH1 0x20
0000045a: DUP3
0000045b: ADD
0000045c: GT
0000045d: ISZERO
0000045e: PUSH2 0x0466
00000461: JUMPI
00000462: PUSH1 0x00
00000464: DUP1
00000465: REVERT
00000466: JUMPDEST
00000467: DUP1
00000468: CALLDATALOAD
00000469: SWAP1
0000046a: PUSH1 0x20
0000046c: ADD
0000046d: SWAP2
0000046e: DUP5
0000046f: PUSH1 0x20
00000471: DUP4
00000472: MUL
00000473: DUP5
00000474: ADD
00000475: GT
00000476: PUSH5 0x0100000000
0000047c: DUP4
0000047d: GT
0000047e: OR
0000047f: ISZERO
00000480: PUSH2 0x0488
00000483: JUMPI
00000484: PUSH1 0x00
00000486: DUP1
00000487: REVERT
00000488: JUMPDEST
00000489: SWAP2
0000048a: SWAP4
0000048b: POP
0000048c: SWAP2
0000048d: POP
0000048e: PUSH1 0x01
00000490: PUSH1 0x01
00000492: PUSH1 0xa0
00000494: SHL
00000495: SUB
00000496: DUP2
00000497: CALLDATALOAD
00000498: AND
00000499: SWAP1
0000049a: PUSH1 0x20
0000049c: DUP2
0000049d: ADD
0000049e: CALLDATALOAD
0000049f: SWAP1
000004a0: PUSH1 0x40
000004a2: DUP2
000004a3: ADD
000004a4: CALLDATALOAD
000004a5: SWAP1
000004a6: PUSH1 0x60
000004a8: ADD
000004a9: CALLDATALOAD
000004aa: PUSH2 0x0e72
000004ad: JUMP
000004ae: JUMPDEST
000004af: PUSH2 0x0169
000004b2: PUSH1 0x04
000004b4: DUP1
000004b5: CALLDATASIZE
000004b6: SUB
000004b7: PUSH1 0xe0
000004b9: DUP2
000004ba: LT
000004bb: ISZERO
000004bc: PUSH2 0x04c4
000004bf: JUMPI
000004c0: PUSH1 0x00
000004c2: DUP1
000004c3: REVERT
000004c4: JUMPDEST
000004c5: DUP2
000004c6: CALLDATALOAD
000004c7: SWAP2
000004c8: PUSH1 0x20
000004ca: DUP2
000004cb: ADD
000004cc: CALLDATALOAD
000004cd: SWAP2
000004ce: DUP2
000004cf: ADD
000004d0: SWAP1
000004d1: PUSH1 0x60
000004d3: DUP2
000004d4: ADD
000004d5: PUSH1 0x40
000004d7: DUP3
000004d8: ADD
000004d9: CALLDATALOAD
000004da: PUSH5 0x0100000000
000004e0: DUP2
000004e1: GT
000004e2: ISZERO
000004e3: PUSH2 0x04eb
000004e6: JUMPI
000004e7: PUSH1 0x00
000004e9: DUP1
000004ea: REVERT
000004eb: JUMPDEST
000004ec: DUP3
000004ed: ADD
000004ee: DUP4
000004ef: PUSH1 0x20
000004f1: DUP3
000004f2: ADD
000004f3: GT
000004f4: ISZERO
000004f5: PUSH2 0x04fd
000004f8: JUMPI
000004f9: PUSH1 0x00
000004fb: DUP1
000004fc: REVERT
000004fd: JUMPDEST
000004fe: DUP1
000004ff: CALLDATALOAD
00000500: SWAP1
00000501: PUSH1 0x20
00000503: ADD
00000504: SWAP2
00000505: DUP5
00000506: PUSH1 0x20
00000508: DUP4
00000509: MUL
0000050a: DUP5
0000050b: ADD
0000050c: GT
0000050d: PUSH5 0x0100000000
00000513: DUP4
00000514: GT
00000515: OR
00000516: ISZERO
00000517: PUSH2 0x051f
0000051a: JUMPI
0000051b: PUSH1 0x00
0000051d: DUP1
0000051e: REVERT
0000051f: JUMPDEST
00000520: SWAP2
00000521: SWAP4
00000522: POP
00000523: SWAP2
00000524: POP
00000525: PUSH1 0x01
00000527: PUSH1 0x01
00000529: PUSH1 0xa0
0000052b: SHL
0000052c: SUB
0000052d: DUP2
0000052e: CALLDATALOAD
0000052f: AND
00000530: SWAP1
00000531: PUSH1 0x20
00000533: DUP2
00000534: ADD
00000535: CALLDATALOAD
00000536: SWAP1
00000537: PUSH1 0x40
00000539: DUP2
0000053a: ADD
0000053b: CALLDATALOAD
0000053c: SWAP1
0000053d: PUSH1 0x60
0000053f: ADD
00000540: CALLDATALOAD
00000541: PUSH2 0x0f2c
00000544: JUMP
00000545: JUMPDEST
00000546: CALLVALUE
00000547: DUP1
00000548: ISZERO
00000549: PUSH2 0x0551
0000054c: JUMPI
0000054d: PUSH1 0x00
0000054f: DUP1
00000550: REVERT
00000551: JUMPDEST
00000552: POP
00000553: PUSH2 0x055a
00000556: PUSH2 0x105e
00000559: JUMP
0000055a: JUMPDEST
0000055b: PUSH1 0x40
0000055d: DUP1
0000055e: MLOAD
0000055f: PUSH1 0x01
00000561: PUSH1 0x01
00000563: PUSH1 0xa0
00000565: SHL
00000566: SUB
00000567: SWAP1
00000568: SWAP3
00000569: AND
0000056a: DUP3
0000056b: MSTORE
0000056c: MLOAD
0000056d: SWAP1
0000056e: DUP2
0000056f: SWAP1
00000570: SUB
00000571: PUSH1 0x20
00000573: ADD
00000574: SWAP1
00000575: RETURN
00000576: JUMPDEST
00000577: CALLVALUE
00000578: DUP1
00000579: ISZERO
0000057a: PUSH2 0x0582
0000057d: JUMPI
0000057e: PUSH1 0x00
00000580: DUP1
00000581: REVERT
00000582: JUMPDEST
00000583: POP
00000584: PUSH2 0x055a
00000587: PUSH1 0x04
00000589: DUP1
0000058a: CALLDATASIZE
0000058b: SUB
0000058c: PUSH1 0x40
0000058e: DUP2
0000058f: LT
00000590: ISZERO
00000591: PUSH2 0x0599
00000594: JUMPI
00000595: PUSH1 0x00
00000597: DUP1
00000598: REVERT
00000599: JUMPDEST
0000059a: POP
0000059b: DUP1
0000059c: CALLDATALOAD
0000059d: SWAP1
0000059e: PUSH1 0x20
000005a0: ADD
000005a1: CALLDATALOAD
000005a2: PUSH2 0x106d
000005a5: JUMP
000005a6: JUMPDEST
000005a7: CALLVALUE
000005a8: DUP1
000005a9: ISZERO
000005aa: PUSH2 0x05b2
000005ad: JUMPI
000005ae: PUSH1 0x00
000005b0: DUP1
000005b1: REVERT
000005b2: JUMPDEST
000005b3: POP
000005b4: PUSH2 0x05df
000005b7: PUSH1 0x04
000005b9: DUP1
000005ba: CALLDATASIZE
000005bb: SUB
000005bc: PUSH1 0x40
000005be: DUP2
000005bf: LT
000005c0: ISZERO
000005c1: PUSH2 0x05c9
000005c4: JUMPI
000005c5: PUSH1 0x00
000005c7: DUP1
000005c8: REVERT
000005c9: JUMPDEST
000005ca: POP
000005cb: DUP1
000005cc: CALLDATALOAD
000005cd: SWAP1
000005ce: PUSH1 0x20
000005d0: ADD
000005d1: CALLDATALOAD
000005d2: PUSH1 0x01
000005d4: PUSH1 0x01
000005d6: PUSH1 0xa0
000005d8: SHL
000005d9: SUB
000005da: AND
000005db: PUSH2 0x1094
000005de: JUMP
000005df: JUMPDEST
000005e0: PUSH1 0x40
000005e2: DUP1
000005e3: MLOAD
000005e4: SWAP2
000005e5: ISZERO
000005e6: ISZERO
000005e7: DUP3
000005e8: MSTORE
000005e9: MLOAD
000005ea: SWAP1
000005eb: DUP2
000005ec: SWAP1
000005ed: SUB
000005ee: PUSH1 0x20
000005f0: ADD
000005f1: SWAP1
000005f2: RETURN
000005f3: JUMPDEST
000005f4: CALLVALUE
000005f5: DUP1
000005f6: ISZERO
000005f7: PUSH2 0x05ff
000005fa: JUMPI
000005fb: PUSH1 0x00
000005fd: DUP1
000005fe: REVERT
000005ff: JUMPDEST
00000600: POP
00000601: PUSH2 0x0169
00000604: PUSH1 0x04
00000606: DUP1
00000607: CALLDATASIZE
00000608: SUB
00000609: PUSH1 0x40
0000060b: DUP2
0000060c: LT
0000060d: ISZERO
0000060e: PUSH2 0x0616
00000611: JUMPI
00000612: PUSH1 0x00
00000614: DUP1
00000615: REVERT
00000616: JUMPDEST
00000617: POP
00000618: DUP1
00000619: CALLDATALOAD
0000061a: SWAP1
0000061b: PUSH1 0x20
0000061d: ADD
0000061e: CALLDATALOAD
0000061f: PUSH1 0x01
00000621: PUSH1 0x01
00000623: PUSH1 0xa0
00000625: SHL
00000626: SUB
00000627: AND
00000628: PUSH2 0x10b2
0000062b: JUMP
0000062c: JUMPDEST
0000062d: CALLVALUE
0000062e: DUP1
0000062f: ISZERO
00000630: PUSH2 0x0638
00000633: JUMPI
00000634: PUSH1 0x00
00000636: DUP1
00000637: REVERT
00000638: JUMPDEST
00000639: POP
0000063a: PUSH2 0x0355
0000063d: PUSH2 0x119e
00000640: JUMP
00000641: JUMPDEST
00000642: CALLVALUE
00000643: DUP1
00000644: ISZERO
00000645: PUSH2 0x064d
00000648: JUMPI
00000649: PUSH1 0x00
0000064b: DUP1
0000064c: REVERT
0000064d: JUMPDEST
0000064e: POP
0000064f: PUSH2 0x0169
00000652: PUSH2 0x11a3
00000655: JUMP
00000656: JUMPDEST
00000657: CALLVALUE
00000658: DUP1
00000659: ISZERO
0000065a: PUSH2 0x0662
0000065d: JUMPI
0000065e: PUSH1 0x00
00000660: DUP1
00000661: REVERT
00000662: JUMPDEST
00000663: POP
00000664: PUSH2 0x0355
00000667: PUSH1 0x04
00000669: DUP1
0000066a: CALLDATASIZE
0000066b: SUB
0000066c: PUSH1 0x20
0000066e: DUP2
0000066f: LT
00000670: ISZERO
00000671: PUSH2 0x0679
00000674: JUMPI
00000675: PUSH1 0x00
00000677: DUP1
00000678: REVERT
00000679: JUMPDEST
0000067a: POP
0000067b: CALLDATALOAD
0000067c: PUSH2 0x1292
0000067f: JUMP
00000680: JUMPDEST
00000681: CALLVALUE
00000682: DUP1
00000683: ISZERO
00000684: PUSH2 0x068c
00000687: JUMPI
00000688: PUSH1 0x00
0000068a: DUP1
0000068b: REVERT
0000068c: JUMPDEST
0000068d: POP
0000068e: PUSH2 0x0695
00000691: PUSH2 0x12a9
00000694: JUMP
00000695: JUMPDEST
00000696: PUSH1 0x40
00000698: DUP1
00000699: MLOAD
0000069a: PUSH1 0xff
0000069c: SWAP1
0000069d: SWAP3
0000069e: AND
0000069f: DUP3
000006a0: MSTORE
000006a1: MLOAD
000006a2: SWAP1
000006a3: DUP2
000006a4: SWAP1
000006a5: SUB
000006a6: PUSH1 0x20
000006a8: ADD
000006a9: SWAP1
000006aa: RETURN
000006ab: JUMPDEST
000006ac: CALLVALUE
000006ad: DUP1
000006ae: ISZERO
000006af: PUSH2 0x06b7
000006b2: JUMPI
000006b3: PUSH1 0x00
000006b5: DUP1
000006b6: REVERT
000006b7: JUMPDEST
000006b8: POP
000006b9: PUSH2 0x0169
000006bc: PUSH1 0x04
000006be: DUP1
000006bf: CALLDATASIZE
000006c0: SUB
000006c1: PUSH1 0x40
000006c3: DUP2
000006c4: LT
000006c5: ISZERO
000006c6: PUSH2 0x06ce
000006c9: JUMPI
000006ca: PUSH1 0x00
000006cc: DUP1
000006cd: REVERT
000006ce: JUMPDEST
000006cf: POP
000006d0: DUP1
000006d1: CALLDATALOAD
000006d2: SWAP1
000006d3: PUSH1 0x20
000006d5: ADD
000006d6: CALLDATALOAD
000006d7: PUSH1 0x01
000006d9: PUSH1 0x01
000006db: PUSH1 0xa0
000006dd: SHL
000006de: SUB
000006df: AND
000006e0: PUSH2 0x12b9
000006e3: JUMP
000006e4: JUMPDEST
000006e5: CALLVALUE
000006e6: DUP1
000006e7: ISZERO
000006e8: PUSH2 0x06f0
000006eb: JUMPI
000006ec: PUSH1 0x00
000006ee: DUP1
000006ef: REVERT
000006f0: JUMPDEST
000006f1: POP
000006f2: PUSH2 0x0355
000006f5: PUSH2 0x1312
000006f8: JUMP
000006f9: JUMPDEST
000006fa: CALLVALUE
000006fb: DUP1
000006fc: ISZERO
000006fd: PUSH2 0x0705
00000700: JUMPI
00000701: PUSH1 0x00
00000703: DUP1
00000704: REVERT
00000705: JUMPDEST
00000706: POP
00000707: PUSH2 0x0355
0000070a: PUSH2 0x1332
0000070d: JUMP
0000070e: JUMPDEST
0000070f: PUSH1 0x40
00000711: DUP1
00000712: MLOAD
00000713: PUSH5 0x5452414445
00000719: PUSH1 0xd8
0000071b: SHL
0000071c: DUP2
0000071d: MSTORE
0000071e: SWAP1
0000071f: MLOAD
00000720: SWAP1
00000721: DUP2
00000722: SWAP1
00000723: SUB
00000724: PUSH1 0x05
00000726: ADD
00000727: SWAP1
00000728: KECCAK256
00000729: PUSH2 0x0739
0000072c: DUP2
0000072d: PUSH2 0x0734
00000730: PUSH2 0x134f
00000733: JUMP
00000734: JUMPDEST
00000735: PUSH2 0x1094
00000738: JUMP
00000739: JUMPDEST
0000073a: PUSH2 0x078a
0000073d: JUMPI
0000073e: PUSH1 0x40
00000740: DUP1
00000741: MLOAD
00000742: PUSH3 0x461bcd
00000746: PUSH1 0xe5
00000748: SHL
00000749: DUP2
0000074a: MSTORE
0000074b: PUSH1 0x20
0000074d: PUSH1 0x04
0000074f: DUP3
00000750: ADD
00000751: MSTORE
00000752: PUSH1 0x1a
00000754: PUSH1 0x24
00000756: DUP3
00000757: ADD
00000758: MSTORE
00000759: PUSH32 0x446f206e6f74206861766520726571756972656420726f6c652e000000000000
0000077a: PUSH1 0x44
0000077c: DUP3
0000077d: ADD
0000077e: MSTORE
0000077f: SWAP1
00000780: MLOAD
00000781: SWAP1
00000782: DUP2
00000783: SWAP1
00000784: SUB
00000785: PUSH1 0x64
00000787: ADD
00000788: SWAP1
00000789: REVERT
0000078a: JUMPDEST
0000078b: PUSH1 0x00
0000078d: DUP3
0000078e: DUP2
0000078f: MSTORE
00000790: PUSH1 0x02
00000792: PUSH1 0x20
00000794: MSTORE
00000795: PUSH1 0x40
00000797: DUP2
00000798: KECCAK256
00000799: SLOAD
0000079a: PUSH1 0xff
0000079c: AND
0000079d: PUSH1 0x01
0000079f: DUP2
000007a0: GT
000007a1: ISZERO
000007a2: PUSH2 0x07a7
000007a5: JUMPI
000007a6: INVALID
000007a7: JUMPDEST
000007a8: EQ
000007a9: PUSH2 0x07e3
000007ac: JUMPI
000007ad: PUSH1 0x40
000007af: MLOAD
000007b0: PUSH3 0x461bcd
000007b4: PUSH1 0xe5
000007b6: SHL
000007b7: DUP2
000007b8: MSTORE
000007b9: PUSH1 0x04
000007bb: ADD
000007bc: DUP1
000007bd: DUP1
000007be: PUSH1 0x20
000007c0: ADD
000007c1: DUP3
000007c2: DUP2
000007c3: SUB
000007c4: DUP3
000007c5: MSTORE
000007c6: PUSH1 0x44
000007c8: DUP2
000007c9: MSTORE
000007ca: PUSH1 0x20
000007cc: ADD
000007cd: DUP1
000007ce: PUSH2 0x1b29
000007d1: PUSH1 0x44
000007d3: SWAP2
000007d4: CODECOPY
000007d5: PUSH1 0x60
000007d7: ADD
000007d8: SWAP2
000007d9: POP
000007da: POP
000007db: PUSH1 0x40
000007dd: MLOAD
000007de: DUP1
000007df: SWAP2
000007e0: SUB
000007e1: SWAP1
000007e2: REVERT
000007e3: JUMPDEST
000007e4: PUSH1 0x00
000007e6: DUP3
000007e7: DUP2
000007e8: MSTORE
000007e9: PUSH1 0x02
000007eb: PUSH1 0x20
000007ed: MSTORE
000007ee: PUSH1 0x40
000007f0: SWAP1
000007f1: KECCAK256
000007f2: DUP1
000007f3: SLOAD
000007f4: PUSH1 0xff
000007f6: NOT
000007f7: AND
000007f8: PUSH1 0x01
000007fa: OR
000007fb: SWAP1
000007fc: SSTORE
000007fd: PUSH1 0x03
000007ff: SLOAD
00000800: PUSH1 0xff
00000802: PUSH1 0x01
00000804: PUSH1 0xa0
00000806: SHL
00000807: SWAP1
00000808: SWAP2
00000809: DIV
0000080a: AND
0000080b: DUP4
0000080c: GT
0000080d: ISZERO
0000080e: PUSH2 0x0848
00000811: JUMPI
00000812: PUSH1 0x40
00000814: MLOAD
00000815: PUSH3 0x461bcd
00000819: PUSH1 0xe5
0000081b: SHL
0000081c: DUP2
0000081d: MSTORE
0000081e: PUSH1 0x04
00000820: ADD
00000821: DUP1
00000822: DUP1
00000823: PUSH1 0x20
00000825: ADD
00000826: DUP3
00000827: DUP2
00000828: SUB
00000829: DUP3
0000082a: MSTORE
0000082b: PUSH1 0x37
0000082d: DUP2
0000082e: MSTORE
0000082f: PUSH1 0x20
00000831: ADD
00000832: DUP1
00000833: PUSH2 0x1b6d
00000836: PUSH1 0x37
00000838: SWAP2
00000839: CODECOPY
0000083a: PUSH1 0x40
0000083c: ADD
0000083d: SWAP2
0000083e: POP
0000083f: POP
00000840: PUSH1 0x40
00000842: MLOAD
00000843: DUP1
00000844: SWAP2
00000845: SUB
00000846: SWAP1
00000847: REVERT
00000848: JUMPDEST
00000849: PUSH1 0x00
0000084b: DUP8
0000084c: DUP8
0000084d: PUSH1 0x00
0000084f: DUP2
00000850: DUP2
00000851: LT
00000852: PUSH2 0x0857
00000855: JUMPI
00000856: INVALID
00000857: JUMPDEST
00000858: SWAP1
00000859: POP
0000085a: PUSH1 0x20
0000085c: MUL
0000085d: ADD
0000085e: CALLDATALOAD
0000085f: PUSH1 0x01
00000861: PUSH1 0x01
00000863: PUSH1 0xa0
00000865: SHL
00000866: SUB
00000867: AND
00000868: SWAP1
00000869: POP
0000086a: PUSH1 0x00
0000086c: DUP1
0000086d: SWAP1
0000086e: POP
0000086f: JUMPDEST
00000870: DUP5
00000871: DUP2
00000872: LT
00000873: ISZERO
00000874: PUSH2 0x0a48
00000877: JUMPI
00000878: PUSH1 0x03
0000087a: SLOAD
0000087b: PUSH1 0x40
0000087d: DUP1
0000087e: MLOAD
0000087f: PUSH32 0x095ea7b300000000000000000000000000000000000000000000000000000000
000008a0: DUP2
000008a1: MSTORE
000008a2: PUSH1 0x01
000008a4: PUSH1 0x01
000008a6: PUSH1 0xa0
000008a8: SHL
000008a9: SUB
000008aa: SWAP3
000008ab: DUP4
000008ac: AND
000008ad: PUSH1 0x04
000008af: DUP3
000008b0: ADD
000008b1: MSTORE
000008b2: PUSH1 0x24
000008b4: DUP2
000008b5: ADD
000008b6: DUP15
000008b7: SWAP1
000008b8: MSTORE
000008b9: SWAP1
000008ba: MLOAD
000008bb: SWAP2
000008bc: DUP5
000008bd: AND
000008be: SWAP2
000008bf: PUSH4 0x095ea7b3
000008c4: SWAP2
000008c5: PUSH1 0x44
000008c7: DUP1
000008c8: DUP3
000008c9: ADD
000008ca: SWAP3
000008cb: PUSH1 0x20
000008cd: SWAP3
000008ce: SWAP1
000008cf: SWAP2
000008d0: SWAP1
000008d1: DUP3
000008d2: SWAP1
000008d3: SUB
000008d4: ADD
000008d5: DUP2
000008d6: PUSH1 0x00
000008d8: DUP8
000008d9: DUP1
000008da: EXTCODESIZE
000008db: ISZERO
000008dc: DUP1
000008dd: ISZERO
000008de: PUSH2 0x08e6
000008e1: JUMPI
000008e2: PUSH1 0x00
000008e4: DUP1
000008e5: REVERT
000008e6: JUMPDEST
000008e7: POP
000008e8: GAS
000008e9: CALL
000008ea: ISZERO
000008eb: DUP1
000008ec: ISZERO
000008ed: PUSH2 0x08fa
000008f0: JUMPI
000008f1: RETURNDATASIZE
000008f2: PUSH1 0x00
000008f4: DUP1
000008f5: RETURNDATACOPY
000008f6: RETURNDATASIZE
000008f7: PUSH1 0x00
000008f9: REVERT
000008fa: JUMPDEST
000008fb: POP
000008fc: POP
000008fd: POP
000008fe: POP
000008ff: PUSH1 0x40
00000901: MLOAD
00000902: RETURNDATASIZE
00000903: PUSH1 0x20
00000905: DUP2
00000906: LT
00000907: ISZERO
00000908: PUSH2 0x0910
0000090b: JUMPI
0000090c: PUSH1 0x00
0000090e: DUP1
0000090f: REVERT
00000910: JUMPDEST
00000911: POP
00000912: POP
00000913: PUSH1 0x03
00000915: SLOAD
00000916: PUSH1 0x40
00000918: MLOAD
00000919: PUSH32 0x791ac94700000000000000000000000000000000000000000000000000000000
0000093a: DUP2
0000093b: MSTORE
0000093c: PUSH1 0x04
0000093e: DUP2
0000093f: ADD
00000940: DUP14
00000941: DUP2
00000942: MSTORE
00000943: PUSH1 0x24
00000945: DUP3
00000946: ADD
00000947: DUP14
00000948: SWAP1
00000949: MSTORE
0000094a: PUSH1 0x01
0000094c: PUSH1 0x01
0000094e: PUSH1 0xa0
00000950: SHL
00000951: SUB
00000952: DUP11
00000953: DUP2
00000954: AND
00000955: PUSH1 0x64
00000957: DUP5
00000958: ADD
00000959: MSTORE
0000095a: PUSH1 0x84
0000095c: DUP4
0000095d: ADD
0000095e: DUP11
0000095f: SWAP1
00000960: MSTORE
00000961: PUSH1 0xa0
00000963: PUSH1 0x44
00000965: DUP5
00000966: ADD
00000967: SWAP1
00000968: DUP2
00000969: MSTORE
0000096a: PUSH1 0xa4
0000096c: DUP5
0000096d: ADD
0000096e: DUP14
0000096f: SWAP1
00000970: MSTORE
00000971: SWAP4
00000972: AND
00000973: SWAP3
00000974: PUSH4 0x791ac947
00000979: SWAP3
0000097a: DUP16
0000097b: SWAP3
0000097c: DUP16
0000097d: SWAP3
0000097e: DUP16
0000097f: SWAP3
00000980: DUP16
00000981: SWAP3
00000982: DUP16
00000983: SWAP3
00000984: DUP16
00000985: SWAP3
00000986: PUSH1 0xc4
00000988: ADD
00000989: DUP7
0000098a: PUSH1 0x20
0000098c: DUP8
0000098d: MUL
0000098e: DUP1
0000098f: DUP3
00000990: DUP5
00000991: CALLDATACOPY
00000992: PUSH1 0x00
00000994: DUP2
00000995: DUP5
00000996: ADD
00000997: MSTORE
00000998: PUSH1 0x1f
0000099a: NOT
0000099b: PUSH1 0x1f
0000099d: DUP3
0000099e: ADD
0000099f: AND
000009a0: SWAP1
000009a1: POP
000009a2: DUP1
000009a3: DUP4
000009a4: ADD
000009a5: SWAP3
000009a6: POP
000009a7: POP
000009a8: POP
000009a9: SWAP8
000009aa: POP
000009ab: POP
000009ac: POP
000009ad: POP
000009ae: POP
000009af: POP
000009b0: POP
000009b1: POP
000009b2: PUSH1 0x00
000009b4: PUSH1 0x40
000009b6: MLOAD
000009b7: DUP1
000009b8: DUP4
000009b9: SUB
000009ba: DUP2
000009bb: PUSH1 0x00
000009bd: DUP8
000009be: DUP1
000009bf: EXTCODESIZE
000009c0: ISZERO
000009c1: DUP1
000009c2: ISZERO
000009c3: PUSH2 0x09cb
000009c6: JUMPI
000009c7: PUSH1 0x00
000009c9: DUP1
000009ca: REVERT
000009cb: JUMPDEST
000009cc: POP
000009cd: GAS
000009ce: CALL
000009cf: ISZERO
000009d0: DUP1
000009d1: ISZERO
000009d2: PUSH2 0x09df
000009d5: JUMPI
000009d6: RETURNDATASIZE
000009d7: PUSH1 0x00
000009d9: DUP1
000009da: RETURNDATACOPY
000009db: RETURNDATASIZE
000009dc: PUSH1 0x00
000009de: REVERT
000009df: JUMPDEST
000009e0: POP
000009e1: POP
000009e2: POP
000009e3: POP
000009e4: DUP7
000009e5: PUSH1 0x01
000009e7: PUSH1 0x01
000009e9: PUSH1 0xa0
000009eb: SHL
000009ec: SUB
000009ed: AND
000009ee: DUP10
000009ef: DUP10
000009f0: PUSH1 0x00
000009f2: DUP2
000009f3: DUP2
000009f4: LT
000009f5: PUSH2 0x09fa
000009f8: JUMPI
000009f9: INVALID
000009fa: JUMPDEST
000009fb: SWAP1
000009fc: POP
000009fd: PUSH1 0x20
000009ff: MUL
00000a00: ADD
00000a01: CALLDATALOAD
00000a02: PUSH1 0x01
00000a04: PUSH1 0x01
00000a06: PUSH1 0xa0
00000a08: SHL
00000a09: SUB
00000a0a: AND
00000a0b: PUSH1 0x01
00000a0d: PUSH1 0x01
00000a0f: PUSH1 0xa0
00000a11: SHL
00000a12: SUB
00000a13: AND
00000a14: DUP13
00000a15: PUSH32 0x77a2d8f78ecce717d6e615a383e782423f4716f8fa42131595ffe10211b06bfb
00000a36: PUSH1 0x40
00000a38: MLOAD
00000a39: PUSH1 0x40
00000a3b: MLOAD
00000a3c: DUP1
00000a3d: SWAP2
00000a3e: SUB
00000a3f: SWAP1
00000a40: LOG4
00000a41: PUSH1 0x01
00000a43: ADD
00000a44: PUSH2 0x086f
00000a47: JUMP
00000a48: JUMPDEST
00000a49: POP
00000a4a: POP
00000a4b: POP
00000a4c: POP
00000a4d: POP
00000a4e: POP
00000a4f: POP
00000a50: POP
00000a51: POP
00000a52: POP
00000a53: POP
00000a54: JUMP
00000a55: JUMPDEST
00000a56: PUSH1 0x40
00000a58: DUP1
00000a59: MLOAD
00000a5a: PUSH5 0x5452414445
00000a60: PUSH1 0xd8
00000a62: SHL
00000a63: DUP2
00000a64: MSTORE
00000a65: SWAP1
00000a66: MLOAD
00000a67: SWAP1
00000a68: DUP2
00000a69: SWAP1
00000a6a: SUB
00000a6b: PUSH1 0x05
00000a6d: ADD
00000a6e: SWAP1
00000a6f: KECCAK256
00000a70: PUSH2 0x0a7b
00000a73: DUP2
00000a74: PUSH2 0x0734
00000a77: PUSH2 0x134f
00000a7a: JUMP
00000a7b: JUMPDEST
00000a7c: PUSH2 0x0acc
00000a7f: JUMPI
00000a80: PUSH1 0x40
00000a82: DUP1
00000a83: MLOAD
00000a84: PUSH3 0x461bcd
00000a88: PUSH1 0xe5
00000a8a: SHL
00000a8b: DUP2
00000a8c: MSTORE
00000a8d: PUSH1 0x20
00000a8f: PUSH1 0x04
00000a91: DUP3
00000a92: ADD
00000a93: MSTORE
00000a94: PUSH1 0x1a
00000a96: PUSH1 0x24
00000a98: DUP3
00000a99: ADD
00000a9a: MSTORE
00000a9b: PUSH32 0x446f206e6f74206861766520726571756972656420726f6c652e000000000000
00000abc: PUSH1 0x44
00000abe: DUP3
00000abf: ADD
00000ac0: MSTORE
00000ac1: SWAP1
00000ac2: MLOAD
00000ac3: SWAP1
00000ac4: DUP2
00000ac5: SWAP1
00000ac6: SUB
00000ac7: PUSH1 0x64
00000ac9: ADD
00000aca: SWAP1
00000acb: REVERT
00000acc: JUMPDEST
00000acd: PUSH2 0x0b0f
00000ad0: DUP9
00000ad1: DUP9
00000ad2: DUP9
00000ad3: DUP9
00000ad4: DUP1
00000ad5: DUP1
00000ad6: PUSH1 0x20
00000ad8: MUL
00000ad9: PUSH1 0x20
00000adb: ADD
00000adc: PUSH1 0x40
00000ade: MLOAD
00000adf: SWAP1
00000ae0: DUP2
00000ae1: ADD
00000ae2: PUSH1 0x40
00000ae4: MSTORE
00000ae5: DUP1
00000ae6: SWAP4
00000ae7: SWAP3
00000ae8: SWAP2
00000ae9: SWAP1
00000aea: DUP2
00000aeb: DUP2
00000aec: MSTORE
00000aed: PUSH1 0x20
00000aef: ADD
00000af0: DUP4
00000af1: DUP4
00000af2: PUSH1 0x20
00000af4: MUL
00000af5: DUP1
00000af6: DUP3
00000af7: DUP5
00000af8: CALLDATACOPY
00000af9: PUSH1 0x00
00000afb: SWAP3
00000afc: ADD
00000afd: SWAP2
00000afe: SWAP1
00000aff: SWAP2
00000b00: MSTORE
00000b01: POP
00000b02: DUP11
00000b03: SWAP3
00000b04: POP
00000b05: DUP10
00000b06: SWAP2
00000b07: POP
00000b08: DUP9
00000b09: SWAP1
00000b0a: POP
00000b0b: PUSH2 0x1353
00000b0e: JUMP
00000b0f: JUMPDEST
00000b10: POP
00000b11: POP
00000b12: POP
00000b13: POP
00000b14: POP
00000b15: POP
00000b16: POP
00000b17: POP
00000b18: JUMP
00000b19: JUMPDEST
00000b1a: PUSH1 0x40
00000b1c: DUP1
00000b1d: MLOAD
00000b1e: PUSH5 0x5452414445
00000b24: PUSH1 0xd8
00000b26: SHL
00000b27: DUP2
00000b28: MSTORE
00000b29: SWAP1
00000b2a: MLOAD
00000b2b: SWAP1
00000b2c: DUP2
00000b2d: SWAP1
00000b2e: SUB
00000b2f: PUSH1 0x05
00000b31: ADD
00000b32: SWAP1
00000b33: KECCAK256
00000b34: PUSH2 0x0b3f
00000b37: DUP2
00000b38: PUSH2 0x0734
00000b3b: PUSH2 0x134f
00000b3e: JUMP
00000b3f: JUMPDEST
00000b40: PUSH2 0x0b90
00000b43: JUMPI
00000b44: PUSH1 0x40
00000b46: DUP1
00000b47: MLOAD
00000b48: PUSH3 0x461bcd
00000b4c: PUSH1 0xe5
00000b4e: SHL
00000b4f: DUP2
00000b50: MSTORE
00000b51: PUSH1 0x20
00000b53: PUSH1 0x04
00000b55: DUP3
00000b56: ADD
00000b57: MSTORE
00000b58: PUSH1 0x1a
00000b5a: PUSH1 0x24
00000b5c: DUP3
00000b5d: ADD
00000b5e: MSTORE
00000b5f: PUSH32 0x446f206e6f74206861766520726571756972656420726f6c652e000000000000
00000b80: PUSH1 0x44
00000b82: DUP3
00000b83: ADD
00000b84: MSTORE
00000b85: SWAP1
00000b86: MLOAD
00000b87: SWAP1
00000b88: DUP2
00000b89: SWAP1
00000b8a: SUB
00000b8b: PUSH1 0x64
00000b8d: ADD
00000b8e: SWAP1
00000b8f: REVERT
00000b90: JUMPDEST
00000b91: PUSH1 0x00
00000b93: DUP4
00000b94: DUP2
00000b95: MSTORE
00000b96: PUSH1 0x02
00000b98: PUSH1 0x20
00000b9a: MSTORE
00000b9b: PUSH1 0x40
00000b9d: DUP2
00000b9e: KECCAK256
00000b9f: SLOAD
00000ba0: PUSH1 0xff
00000ba2: AND
00000ba3: PUSH1 0x01
00000ba5: DUP2
00000ba6: GT
00000ba7: ISZERO
00000ba8: PUSH2 0x0bad
00000bab: JUMPI
00000bac: INVALID
00000bad: JUMPDEST
00000bae: EQ
00000baf: PUSH2 0x0be9
00000bb2: JUMPI
00000bb3: PUSH1 0x40
00000bb5: MLOAD
00000bb6: PUSH3 0x461bcd
00000bba: PUSH1 0xe5
00000bbc: SHL
00000bbd: DUP2
00000bbe: MSTORE
00000bbf: PUSH1 0x04
00000bc1: ADD
00000bc2: DUP1
00000bc3: DUP1
00000bc4: PUSH1 0x20
00000bc6: ADD
00000bc7: DUP3
00000bc8: DUP2
00000bc9: SUB
00000bca: DUP3
00000bcb: MSTORE
00000bcc: PUSH1 0x44
00000bce: DUP2
00000bcf: MSTORE
00000bd0: PUSH1 0x20
00000bd2: ADD
00000bd3: DUP1
00000bd4: PUSH2 0x1b29
00000bd7: PUSH1 0x44
00000bd9: SWAP2
00000bda: CODECOPY
00000bdb: PUSH1 0x60
00000bdd: ADD
00000bde: SWAP2
00000bdf: POP
00000be0: POP
00000be1: PUSH1 0x40
00000be3: MLOAD
00000be4: DUP1
00000be5: SWAP2
00000be6: SUB
00000be7: SWAP1
00000be8: REVERT
00000be9: JUMPDEST
00000bea: PUSH1 0x00
00000bec: DUP4
00000bed: DUP2
00000bee: MSTORE
00000bef: PUSH1 0x02
00000bf1: PUSH1 0x20
00000bf3: SWAP1
00000bf4: DUP2
00000bf5: MSTORE
00000bf6: PUSH1 0x40
00000bf8: SWAP2
00000bf9: DUP3
00000bfa: SWAP1
00000bfb: KECCAK256
00000bfc: DUP1
00000bfd: SLOAD
00000bfe: PUSH1 0xff
00000c00: NOT
00000c01: AND
00000c02: PUSH1 0x01
00000c04: OR
00000c05: SWAP1
00000c06: SSTORE
00000c07: DUP2
00000c08: MLOAD
00000c09: DUP10
00000c0a: DUP3
00000c0b: MUL
00000c0c: DUP2
00000c0d: DUP2
00000c0e: ADD
00000c0f: DUP4
00000c10: ADD
00000c11: SWAP1
00000c12: SWAP4
00000c13: MSTORE
00000c14: DUP10
00000c15: DUP2
00000c16: MSTORE
00000c17: PUSH2 0x0c44
00000c1a: SWAP3
00000c1b: DUP13
00000c1c: SWAP3
00000c1d: DUP13
00000c1e: SWAP2
00000c1f: DUP13
00000c20: SWAP2
00000c21: DUP3
00000c22: SWAP2
00000c23: SWAP1
00000c24: DUP6
00000c25: ADD
00000c26: SWAP1
00000c27: DUP5
00000c28: SWAP1
00000c29: DUP1
00000c2a: DUP3
00000c2b: DUP5
00000c2c: CALLDATACOPY
00000c2d: PUSH1 0x00
00000c2f: SWAP3
00000c30: ADD
00000c31: SWAP2
00000c32: SWAP1
00000c33: SWAP2
00000c34: MSTORE
00000c35: POP
00000c36: DUP12
00000c37: SWAP3
00000c38: POP
00000c39: DUP11
00000c3a: SWAP2
00000c3b: POP
00000c3c: DUP10
00000c3d: SWAP1
00000c3e: POP
00000c3f: DUP8
00000c40: PUSH2 0x159b
00000c43: JUMP
00000c44: JUMPDEST
00000c45: POP
00000c46: POP
00000c47: POP
00000c48: POP
00000c49: POP
00000c4a: POP
00000c4b: POP
00000c4c: POP
00000c4d: POP
00000c4e: JUMP
00000c4f: JUMPDEST
00000c50: PUSH1 0x00
00000c52: SWAP1
00000c53: DUP2
00000c54: MSTORE
00000c55: PUSH1 0x20
00000c57: DUP2
00000c58: SWAP1
00000c59: MSTORE
00000c5a: PUSH1 0x40
00000c5c: SWAP1
00000c5d: KECCAK256
00000c5e: PUSH1 0x02
00000c60: ADD
00000c61: SLOAD
00000c62: SWAP1
00000c63: JUMP
00000c64: JUMPDEST
00000c65: PUSH1 0x00
00000c67: DUP3
00000c68: DUP2
00000c69: MSTORE
00000c6a: PUSH1 0x20
00000c6c: DUP2
00000c6d: SWAP1
00000c6e: MSTORE
00000c6f: PUSH1 0x40
00000c71: SWAP1
00000c72: KECCAK256
00000c73: PUSH1 0x02
00000c75: ADD
00000c76: SLOAD
00000c77: PUSH2 0x0c82
00000c7a: SWAP1
00000c7b: PUSH2 0x0734
00000c7e: PUSH2 0x134f
00000c81: JUMP
00000c82: JUMPDEST
00000c83: PUSH2 0x0cbd
00000c86: JUMPI
00000c87: PUSH1 0x40
00000c89: MLOAD
00000c8a: PUSH3 0x461bcd
00000c8e: PUSH1 0xe5
00000c90: SHL
00000c91: DUP2
00000c92: MSTORE
00000c93: PUSH1 0x04
00000c95: ADD
00000c96: DUP1
00000c97: DUP1
00000c98: PUSH1 0x20
00000c9a: ADD
00000c9b: DUP3
00000c9c: DUP2
00000c9d: SUB
00000c9e: DUP3
00000c9f: MSTORE
00000ca0: PUSH1 0x2f
00000ca2: DUP2
00000ca3: MSTORE
00000ca4: PUSH1 0x20
00000ca6: ADD
00000ca7: DUP1
00000ca8: PUSH2 0x1aca
00000cab: PUSH1 0x2f
00000cad: SWAP2
00000cae: CODECOPY
00000caf: PUSH1 0x40
00000cb1: ADD
00000cb2: SWAP2
00000cb3: POP
00000cb4: POP
00000cb5: PUSH1 0x40
00000cb7: MLOAD
00000cb8: DUP1
00000cb9: SWAP2
00000cba: SUB
00000cbb: SWAP1
00000cbc: REVERT
00000cbd: JUMPDEST
00000cbe: PUSH2 0x0cc7
00000cc1: DUP3
00000cc2: DUP3
00000cc3: PUSH2 0x17da
00000cc6: JUMP
00000cc7: JUMPDEST
00000cc8: POP
00000cc9: POP
00000cca: JUMP
00000ccb: JUMPDEST
00000ccc: PUSH2 0x0cd3
00000ccf: PUSH2 0x134f
00000cd2: JUMP
00000cd3: JUMPDEST
00000cd4: PUSH1 0x01
00000cd6: PUSH1 0x01
00000cd8: PUSH1 0xa0
00000cda: SHL
00000cdb: SUB
00000cdc: AND
00000cdd: DUP2
00000cde: PUSH1 0x01
00000ce0: PUSH1 0x01
00000ce2: PUSH1 0xa0
00000ce4: SHL
00000ce5: SUB
00000ce6: AND
00000ce7: EQ
00000ce8: PUSH2 0x0d22
00000ceb: JUMPI
00000cec: PUSH1 0x40
00000cee: MLOAD
00000cef: PUSH3 0x461bcd
00000cf3: PUSH1 0xe5
00000cf5: SHL
00000cf6: DUP2
00000cf7: MSTORE
00000cf8: PUSH1 0x04
00000cfa: ADD
00000cfb: DUP1
00000cfc: DUP1
00000cfd: PUSH1 0x20
00000cff: ADD
00000d00: DUP3
00000d01: DUP2
00000d02: SUB
00000d03: DUP3
00000d04: MSTORE
00000d05: PUSH1 0x2f
00000d07: DUP2
00000d08: MSTORE
00000d09: PUSH1 0x20
00000d0b: ADD
00000d0c: DUP1
00000d0d: PUSH2 0x1ba4
00000d10: PUSH1 0x2f
00000d12: SWAP2
00000d13: CODECOPY
00000d14: PUSH1 0x40
00000d16: ADD
00000d17: SWAP2
00000d18: POP
00000d19: POP
00000d1a: PUSH1 0x40
00000d1c: MLOAD
00000d1d: DUP1
00000d1e: SWAP2
00000d1f: SUB
00000d20: SWAP1
00000d21: REVERT
00000d22: JUMPDEST
00000d23: PUSH2 0x0cc7
00000d26: DUP3
00000d27: DUP3
00000d28: PUSH2 0x1849
00000d2b: JUMP
00000d2c: JUMPDEST
00000d2d: PUSH1 0x40
00000d2f: DUP1
00000d30: MLOAD
00000d31: PUSH8 0x5749544844524157
00000d3a: PUSH1 0xc0
00000d3c: SHL
00000d3d: DUP2
00000d3e: MSTORE
00000d3f: SWAP1
00000d40: MLOAD
00000d41: SWAP1
00000d42: DUP2
00000d43: SWAP1
00000d44: SUB
00000d45: PUSH1 0x08
00000d47: ADD
00000d48: SWAP1
00000d49: KECCAK256
00000d4a: PUSH2 0x0d55
00000d4d: DUP2
00000d4e: PUSH2 0x0734
00000d51: PUSH2 0x134f
00000d54: JUMP
00000d55: JUMPDEST
00000d56: PUSH2 0x0da6
00000d59: JUMPI
00000d5a: PUSH1 0x40
00000d5c: DUP1
00000d5d: MLOAD
00000d5e: PUSH3 0x461bcd
00000d62: PUSH1 0xe5
00000d64: SHL
00000d65: DUP2
00000d66: MSTORE
00000d67: PUSH1 0x20
00000d69: PUSH1 0x04
00000d6b: DUP3
00000d6c: ADD
00000d6d: MSTORE
00000d6e: PUSH1 0x1a
00000d70: PUSH1 0x24
00000d72: DUP3
00000d73: ADD
00000d74: MSTORE
00000d75: PUSH32 0x446f206e6f74206861766520726571756972656420726f6c652e000000000000
00000d96: PUSH1 0x44
00000d98: DUP3
00000d99: ADD
00000d9a: MSTORE
00000d9b: SWAP1
00000d9c: MLOAD
00000d9d: SWAP1
00000d9e: DUP2
00000d9f: SWAP1
00000da0: SUB
00000da1: PUSH1 0x64
00000da3: ADD
00000da4: SWAP1
00000da5: REVERT
00000da6: JUMPDEST
00000da7: DUP4
00000da8: PUSH1 0x01
00000daa: PUSH1 0x01
00000dac: PUSH1 0xa0
00000dae: SHL
00000daf: SUB
00000db0: AND
00000db1: PUSH4 0xa9059cbb
00000db6: DUP4
00000db7: DUP6
00000db8: PUSH1 0x40
00000dba: MLOAD
00000dbb: DUP4
00000dbc: PUSH4 0xffffffff
00000dc1: AND
00000dc2: PUSH1 0xe0
00000dc4: SHL
00000dc5: DUP2
00000dc6: MSTORE
00000dc7: PUSH1 0x04
00000dc9: ADD
00000dca: DUP1
00000dcb: DUP4
00000dcc: PUSH1 0x01
00000dce: PUSH1 0x01
00000dd0: PUSH1 0xa0
00000dd2: SHL
00000dd3: SUB
00000dd4: AND
00000dd5: PUSH1 0x01
00000dd7: PUSH1 0x01
00000dd9: PUSH1 0xa0
00000ddb: SHL
00000ddc: SUB
00000ddd: AND
00000dde: DUP2
00000ddf: MSTORE
00000de0: PUSH1 0x20
00000de2: ADD
00000de3: DUP3
00000de4: DUP2
00000de5: MSTORE
00000de6: PUSH1 0x20
00000de8: ADD
00000de9: SWAP3
00000dea: POP
00000deb: POP
00000dec: POP
00000ded: PUSH1 0x20
00000def: PUSH1 0x40
00000df1: MLOAD
00000df2: DUP1
00000df3: DUP4
00000df4: SUB
00000df5: DUP2
00000df6: PUSH1 0x00
00000df8: DUP8
00000df9: DUP1
00000dfa: EXTCODESIZE
00000dfb: ISZERO
00000dfc: DUP1
00000dfd: ISZERO
00000dfe: PUSH2 0x0e06
00000e01: JUMPI
00000e02: PUSH1 0x00
00000e04: DUP1
00000e05: REVERT
00000e06: JUMPDEST
00000e07: POP
00000e08: GAS
00000e09: CALL
00000e0a: ISZERO
00000e0b: DUP1
00000e0c: ISZERO
00000e0d: PUSH2 0x0e1a
00000e10: JUMPI
00000e11: RETURNDATASIZE
00000e12: PUSH1 0x00
00000e14: DUP1
00000e15: RETURNDATACOPY
00000e16: RETURNDATASIZE
00000e17: PUSH1 0x00
00000e19: REVERT
00000e1a: JUMPDEST
00000e1b: POP
00000e1c: POP
00000e1d: POP
00000e1e: POP
00000e1f: PUSH1 0x40
00000e21: MLOAD
00000e22: RETURNDATASIZE
00000e23: PUSH1 0x20
00000e25: DUP2
00000e26: LT
00000e27: ISZERO
00000e28: PUSH2 0x0e30
00000e2b: JUMPI
00000e2c: PUSH1 0x00
00000e2e: DUP1
00000e2f: REVERT
00000e30: JUMPDEST
00000e31: POP
00000e32: POP
00000e33: PUSH1 0x40
00000e35: MLOAD
00000e36: PUSH1 0x01
00000e38: PUSH1 0x01
00000e3a: PUSH1 0xa0
00000e3c: SHL
00000e3d: SUB
00000e3e: DUP1
00000e3f: DUP5
00000e40: AND
00000e41: SWAP2
00000e42: DUP6
00000e43: SWAP2
00000e44: DUP8
00000e45: AND
00000e46: SWAP1
00000e47: PUSH32 0xc7de2d139afb8c4257b3fac58f791fb657180f2f86753ed057e0c3a404f705a3
00000e68: SWAP1
00000e69: PUSH1 0x00
00000e6b: SWAP1
00000e6c: LOG4
00000e6d: POP
00000e6e: POP
00000e6f: POP
00000e70: POP
00000e71: JUMP
00000e72: JUMPDEST
00000e73: PUSH1 0x40
00000e75: DUP1
00000e76: MLOAD
00000e77: PUSH5 0x5452414445
00000e7d: PUSH1 0xd8
00000e7f: SHL
00000e80: DUP2
00000e81: MSTORE
00000e82: SWAP1
00000e83: MLOAD
00000e84: SWAP1
00000e85: DUP2
00000e86: SWAP1
00000e87: SUB
00000e88: PUSH1 0x05
00000e8a: ADD
00000e8b: SWAP1
00000e8c: KECCAK256
00000e8d: PUSH2 0x0e98
00000e90: DUP2
00000e91: PUSH2 0x0734
00000e94: PUSH2 0x134f
00000e97: JUMP
00000e98: JUMPDEST
00000e99: PUSH2 0x0ee9
00000e9c: JUMPI
00000e9d: PUSH1 0x40
00000e9f: DUP1
00000ea0: MLOAD
00000ea1: PUSH3 0x461bcd
00000ea5: PUSH1 0xe5
00000ea7: SHL
00000ea8: DUP2
00000ea9: MSTORE
00000eaa: PUSH1 0x20
00000eac: PUSH1 0x04
00000eae: DUP3
00000eaf: ADD
00000eb0: MSTORE
00000eb1: PUSH1 0x1a
00000eb3: PUSH1 0x24
00000eb5: DUP3
00000eb6: ADD
00000eb7: MSTORE
00000eb8: PUSH32 0x446f206e6f74206861766520726571756972656420726f6c652e000000000000
00000ed9: PUSH1 0x44
00000edb: DUP3
00000edc: ADD
00000edd: MSTORE
00000ede: SWAP1
00000edf: MLOAD
00000ee0: SWAP1
00000ee1: DUP2
00000ee2: SWAP1
00000ee3: SUB
00000ee4: PUSH1 0x64
00000ee6: ADD
00000ee7: SWAP1
00000ee8: REVERT
00000ee9: JUMPDEST
00000eea: PUSH2 0x0b0f
00000eed: DUP9
00000eee: DUP9
00000eef: DUP9
00000ef0: DUP1
00000ef1: DUP1
00000ef2: PUSH1 0x20
00000ef4: MUL
00000ef5: PUSH1 0x20
00000ef7: ADD
00000ef8: PUSH1 0x40
00000efa: MLOAD
00000efb: SWAP1
00000efc: DUP2
00000efd: ADD
00000efe: PUSH1 0x40
00000f00: MSTORE
00000f01: DUP1
00000f02: SWAP4
00000f03: SWAP3
00000f04: SWAP2
00000f05: SWAP1
00000f06: DUP2
00000f07: DUP2
00000f08: MSTORE
00000f09: PUSH1 0x20
00000f0b: ADD
00000f0c: DUP4
00000f0d: DUP4
00000f0e: PUSH1 0x20
00000f10: MUL
00000f11: DUP1
00000f12: DUP3
00000f13: DUP5
00000f14: CALLDATACOPY
00000f15: PUSH1 0x00
00000f17: SWAP3
00000f18: ADD
00000f19: SWAP2
00000f1a: SWAP1
00000f1b: SWAP2
00000f1c: MSTORE
00000f1d: POP
00000f1e: DUP11
00000f1f: SWAP3
00000f20: POP
00000f21: DUP10
00000f22: SWAP2
00000f23: POP
00000f24: DUP9
00000f25: SWAP1
00000f26: POP
00000f27: DUP8
00000f28: PUSH2 0x159b
00000f2b: JUMP
00000f2c: JUMPDEST
00000f2d: PUSH1 0x40
00000f2f: DUP1
00000f30: MLOAD
00000f31: PUSH5 0x5452414445
00000f37: PUSH1 0xd8
00000f39: SHL
00000f3a: DUP2
00000f3b: MSTORE
00000f3c: SWAP1
00000f3d: MLOAD
00000f3e: SWAP1
00000f3f: DUP2
00000f40: SWAP1
00000f41: SUB
00000f42: PUSH1 0x05
00000f44: ADD
00000f45: SWAP1
00000f46: KECCAK256
00000f47: PUSH2 0x0f52
00000f4a: DUP2
00000f4b: PUSH2 0x0734
00000f4e: PUSH2 0x134f
00000f51: JUMP
00000f52: JUMPDEST
00000f53: PUSH2 0x0fa3
00000f56: JUMPI
00000f57: PUSH1 0x40
00000f59: DUP1
00000f5a: MLOAD
00000f5b: PUSH3 0x461bcd
00000f5f: PUSH1 0xe5
00000f61: SHL
00000f62: DUP2
00000f63: MSTORE
00000f64: PUSH1 0x20
00000f66: PUSH1 0x04
00000f68: DUP3
00000f69: ADD
00000f6a: MSTORE
00000f6b: PUSH1 0x1a
00000f6d: PUSH1 0x24
00000f6f: DUP3
00000f70: ADD
00000f71: MSTORE
00000f72: PUSH32 0x446f206e6f74206861766520726571756972656420726f6c652e000000000000
00000f93: PUSH1 0x44
00000f95: DUP3
00000f96: ADD
00000f97: MSTORE
00000f98: SWAP1
00000f99: MLOAD
00000f9a: SWAP1
00000f9b: DUP2
00000f9c: SWAP1
00000f9d: SUB
00000f9e: PUSH1 0x64
00000fa0: ADD
00000fa1: SWAP1
00000fa2: REVERT
00000fa3: JUMPDEST
00000fa4: PUSH1 0x00
00000fa6: DUP3
00000fa7: DUP2
00000fa8: MSTORE
00000fa9: PUSH1 0x02
00000fab: PUSH1 0x20
00000fad: MSTORE
00000fae: PUSH1 0x40
00000fb0: DUP2
00000fb1: KECCAK256
00000fb2: SLOAD
00000fb3: PUSH1 0xff
00000fb5: AND
00000fb6: PUSH1 0x01
00000fb8: DUP2
00000fb9: GT
00000fba: ISZERO
00000fbb: PUSH2 0x0fc0
00000fbe: JUMPI
00000fbf: INVALID
00000fc0: JUMPDEST
00000fc1: EQ
00000fc2: PUSH2 0x0ffc
00000fc5: JUMPI
00000fc6: PUSH1 0x40
00000fc8: MLOAD
00000fc9: PUSH3 0x461bcd
00000fcd: PUSH1 0xe5
00000fcf: SHL
00000fd0: DUP2
00000fd1: MSTORE
00000fd2: PUSH1 0x04
00000fd4: ADD
00000fd5: DUP1
00000fd6: DUP1
00000fd7: PUSH1 0x20
00000fd9: ADD
00000fda: DUP3
00000fdb: DUP2
00000fdc: SUB
00000fdd: DUP3
00000fde: MSTORE
00000fdf: PUSH1 0x44
00000fe1: DUP2
00000fe2: MSTORE
00000fe3: PUSH1 0x20
00000fe5: ADD
00000fe6: DUP1
00000fe7: PUSH2 0x1b29
00000fea: PUSH1 0x44
00000fec: SWAP2
00000fed: CODECOPY
00000fee: PUSH1 0x60
00000ff0: ADD
00000ff1: SWAP2
00000ff2: POP
00000ff3: POP
00000ff4: PUSH1 0x40
00000ff6: MLOAD
00000ff7: DUP1
00000ff8: SWAP2
00000ff9: SUB
00000ffa: SWAP1
00000ffb: REVERT
00000ffc: JUMPDEST
00000ffd: PUSH1 0x00
00000fff: DUP3
00001000: DUP2
00001001: MSTORE
00001002: PUSH1 0x02
00001004: PUSH1 0x20
00001006: MSTORE
00001007: PUSH1 0x40
00001009: SWAP1
0000100a: KECCAK256
0000100b: DUP1
0000100c: SLOAD
0000100d: PUSH1 0x01
0000100f: SWAP2
00001010: SWAP1
00001011: PUSH1 0xff
00001013: NOT
00001014: AND
00001015: DUP3
00001016: DUP1
00001017: MUL
00001018: OR
00001019: SWAP1
0000101a: SSTORE
0000101b: POP
0000101c: PUSH2 0x0c44
0000101f: DUP10
00001020: DUP10
00001021: DUP10
00001022: DUP10
00001023: DUP1
00001024: DUP1
00001025: PUSH1 0x20
00001027: MUL
00001028: PUSH1 0x20
0000102a: ADD
0000102b: PUSH1 0x40
0000102d: MLOAD
0000102e: SWAP1
0000102f: DUP2
00001030: ADD
00001031: PUSH1 0x40
00001033: MSTORE
00001034: DUP1
00001035: SWAP4
00001036: SWAP3
00001037: SWAP2
00001038: SWAP1
00001039: DUP2
0000103a: DUP2
0000103b: MSTORE
0000103c: PUSH1 0x20
0000103e: ADD
0000103f: DUP4
00001040: DUP4
00001041: PUSH1 0x20
00001043: MUL
00001044: DUP1
00001045: DUP3
00001046: DUP5
00001047: CALLDATACOPY
00001048: PUSH1 0x00
0000104a: SWAP3
0000104b: ADD
0000104c: SWAP2
0000104d: SWAP1
0000104e: SWAP2
0000104f: MSTORE
00001050: POP
00001051: DUP12
00001052: SWAP3
00001053: POP
00001054: DUP11
00001055: SWAP2
00001056: POP
00001057: DUP10
00001058: SWAP1
00001059: POP
0000105a: PUSH2 0x1353
0000105d: JUMP
0000105e: JUMPDEST
0000105f: PUSH1 0x03
00001061: SLOAD
00001062: PUSH1 0x01
00001064: PUSH1 0x01
00001066: PUSH1 0xa0
00001068: SHL
00001069: SUB
0000106a: AND
0000106b: DUP2
0000106c: JUMP
0000106d: JUMPDEST
0000106e: PUSH1 0x00
00001070: DUP3
00001071: DUP2
00001072: MSTORE
00001073: PUSH1 0x20
00001075: DUP2
00001076: SWAP1
00001077: MSTORE
00001078: PUSH1 0x40
0000107a: DUP2
0000107b: KECCAK256
0000107c: PUSH2 0x108b
0000107f: SWAP1
00001080: DUP4
00001081: PUSH4 0xffffffff
00001086: PUSH2 0x18b8
00001089: AND
0000108a: JUMP
0000108b: JUMPDEST
0000108c: SWAP1
0000108d: POP
0000108e: JUMPDEST
0000108f: SWAP3
00001090: SWAP2
00001091: POP
00001092: POP
00001093: JUMP
00001094: JUMPDEST
00001095: PUSH1 0x00
00001097: DUP3
00001098: DUP2
00001099: MSTORE
0000109a: PUSH1 0x20
0000109c: DUP2
0000109d: SWAP1
0000109e: MSTORE
0000109f: PUSH1 0x40
000010a1: DUP2
000010a2: KECCAK256
000010a3: PUSH2 0x108b
000010a6: SWAP1
000010a7: DUP4
000010a8: PUSH4 0xffffffff
000010ad: PUSH2 0x18c4
000010b0: AND
000010b1: JUMP
000010b2: JUMPDEST
000010b3: PUSH1 0x40
000010b5: DUP1
000010b6: MLOAD
000010b7: PUSH8 0x5749544844524157
000010c0: PUSH1 0xc0
000010c2: SHL
000010c3: DUP2
000010c4: MSTORE
000010c5: SWAP1
000010c6: MLOAD
000010c7: SWAP1
000010c8: DUP2
000010c9: SWAP1
000010ca: SUB
000010cb: PUSH1 0x08
000010cd: ADD
000010ce: SWAP1
000010cf: KECCAK256
000010d0: PUSH2 0x10db
000010d3: DUP2
000010d4: PUSH2 0x0734
000010d7: PUSH2 0x134f
000010da: JUMP
000010db: JUMPDEST
000010dc: PUSH2 0x112c
000010df: JUMPI
000010e0: PUSH1 0x40
000010e2: DUP1
000010e3: MLOAD
000010e4: PUSH3 0x461bcd
000010e8: PUSH1 0xe5
000010ea: SHL
000010eb: DUP2
000010ec: MSTORE
000010ed: PUSH1 0x20
000010ef: PUSH1 0x04
000010f1: DUP3
000010f2: ADD
000010f3: MSTORE
000010f4: PUSH1 0x1a
000010f6: PUSH1 0x24
000010f8: DUP3
000010f9: ADD
000010fa: MSTORE
000010fb: PUSH32 0x446f206e6f74206861766520726571756972656420726f6c652e000000000000
0000111c: PUSH1 0x44
0000111e: DUP3
0000111f: ADD
00001120: MSTORE
00001121: SWAP1
00001122: MLOAD
00001123: SWAP1
00001124: DUP2
00001125: SWAP1
00001126: SUB
00001127: PUSH1 0x64
00001129: ADD
0000112a: SWAP1
0000112b: REVERT
0000112c: JUMPDEST
0000112d: PUSH1 0x40
0000112f: MLOAD
00001130: PUSH1 0x01
00001132: PUSH1 0x01
00001134: PUSH1 0xa0
00001136: SHL
00001137: SUB
00001138: DUP4
00001139: AND
0000113a: SWAP1
0000113b: DUP5
0000113c: ISZERO
0000113d: PUSH2 0x08fc
00001140: MUL
00001141: SWAP1
00001142: DUP6
00001143: SWAP1
00001144: PUSH1 0x00
00001146: DUP2
00001147: DUP2
00001148: DUP2
00001149: DUP6
0000114a: DUP9
0000114b: DUP9
0000114c: CALL
0000114d: SWAP4
0000114e: POP
0000114f: POP
00001150: POP
00001151: POP
00001152: ISZERO
00001153: DUP1
00001154: ISZERO
00001155: PUSH2 0x1162
00001158: JUMPI
00001159: RETURNDATASIZE
0000115a: PUSH1 0x00
0000115c: DUP1
0000115d: RETURNDATACOPY
0000115e: RETURNDATASIZE
0000115f: PUSH1 0x00
00001161: REVERT
00001162: JUMPDEST
00001163: POP
00001164: PUSH1 0x40
00001166: MLOAD
00001167: PUSH1 0x01
00001169: PUSH1 0x01
0000116b: PUSH1 0xa0
0000116d: SHL
0000116e: SUB
0000116f: DUP4
00001170: AND
00001171: SWAP1
00001172: DUP5
00001173: SWAP1
00001174: PUSH32 0xdb987c1c65c75a9e9046a3ca9bdc236b547e784f7077581105a193d618c2e3a5
00001195: SWAP1
00001196: PUSH1 0x00
00001198: SWAP1
00001199: LOG3
0000119a: POP
0000119b: POP
0000119c: POP
0000119d: JUMP
0000119e: JUMPDEST
0000119f: PUSH1 0x00
000011a1: DUP2
000011a2: JUMP
000011a3: JUMPDEST
000011a4: PUSH1 0x40
000011a6: DUP1
000011a7: MLOAD
000011a8: PUSH5 0x5452414445
000011ae: PUSH1 0xd8
000011b0: SHL
000011b1: DUP2
000011b2: MSTORE
000011b3: SWAP1
000011b4: MLOAD
000011b5: SWAP1
000011b6: DUP2
000011b7: SWAP1
000011b8: SUB
000011b9: PUSH1 0x05
000011bb: ADD
000011bc: SWAP1
000011bd: KECCAK256
000011be: PUSH2 0x11c9
000011c1: DUP2
000011c2: PUSH2 0x0734
000011c5: PUSH2 0x134f
000011c8: JUMP
000011c9: JUMPDEST
000011ca: PUSH2 0x121a
000011cd: JUMPI
000011ce: PUSH1 0x40
000011d0: DUP1
000011d1: MLOAD
000011d2: PUSH3 0x461bcd
000011d6: PUSH1 0xe5
000011d8: SHL
000011d9: DUP2
000011da: MSTORE
000011db: PUSH1 0x20
000011dd: PUSH1 0x04
000011df: DUP3
000011e0: ADD
000011e1: MSTORE
000011e2: PUSH1 0x1a
000011e4: PUSH1 0x24
000011e6: DUP3
000011e7: ADD
000011e8: MSTORE
000011e9: PUSH32 0x446f206e6f74206861766520726571756972656420726f6c652e000000000000
0000120a: PUSH1 0x44
0000120c: DUP3
0000120d: ADD
0000120e: MSTORE
0000120f: SWAP1
00001210: MLOAD
00001211: SWAP1
00001212: DUP2
00001213: SWAP1
00001214: SUB
00001215: PUSH1 0x64
00001217: ADD
00001218: SWAP1
00001219: REVERT
0000121a: JUMPDEST
0000121b: PUSH1 0x00
0000121d: PUSH1 0x02
0000121f: PUSH1 0x00
00001221: PUSH2 0x122a
00001224: PUSH1 0x01
00001226: PUSH2 0x18d9
00001229: JUMP
0000122a: JUMPDEST
0000122b: DUP2
0000122c: MSTORE
0000122d: PUSH1 0x20
0000122f: DUP2
00001230: ADD
00001231: SWAP2
00001232: SWAP1
00001233: SWAP2
00001234: MSTORE
00001235: PUSH1 0x40
00001237: ADD
00001238: PUSH1 0x00
0000123a: KECCAK256
0000123b: DUP1
0000123c: SLOAD
0000123d: PUSH1 0xff
0000123f: NOT
00001240: AND
00001241: PUSH1 0x01
00001243: DUP4
00001244: DUP2
00001245: DUP2
00001246: GT
00001247: ISZERO
00001248: PUSH2 0x124d
0000124b: JUMPI
0000124c: INVALID
0000124d: JUMPDEST
0000124e: MUL
0000124f: OR
00001250: SWAP1
00001251: SSTORE
00001252: POP
00001253: PUSH2 0x125c
00001256: PUSH1 0x01
00001258: PUSH2 0x18d9
0000125b: JUMP
0000125c: JUMPDEST
0000125d: PUSH1 0x40
0000125f: MLOAD
00001260: PUSH32 0x0e9e6ed82d503365c459f125541738b231c9ae22ad156cbe6ce0bc5f3c33ae87
00001281: SWAP1
00001282: PUSH1 0x00
00001284: SWAP1
00001285: LOG2
00001286: PUSH2 0x128f
00001289: PUSH1 0x01
0000128b: PUSH2 0x18dd
0000128e: JUMP
0000128f: JUMPDEST
00001290: POP
00001291: JUMP
00001292: JUMPDEST
00001293: PUSH1 0x00
00001295: DUP2
00001296: DUP2
00001297: MSTORE
00001298: PUSH1 0x20
0000129a: DUP2
0000129b: SWAP1
0000129c: MSTORE
0000129d: PUSH1 0x40
0000129f: DUP2
000012a0: KECCAK256
000012a1: PUSH2 0x108e
000012a4: SWAP1
000012a5: PUSH2 0x18e6
000012a8: JUMP
000012a9: JUMPDEST
000012aa: PUSH1 0x03
000012ac: SLOAD
000012ad: PUSH1 0x01
000012af: PUSH1 0xa0
000012b1: SHL
000012b2: SWAP1
000012b3: DIV
000012b4: PUSH1 0xff
000012b6: AND
000012b7: DUP2
000012b8: JUMP
000012b9: JUMPDEST
000012ba: PUSH1 0x00
000012bc: DUP3
000012bd: DUP2
000012be: MSTORE
000012bf: PUSH1 0x20
000012c1: DUP2
000012c2: SWAP1
000012c3: MSTORE
000012c4: PUSH1 0x40
000012c6: SWAP1
000012c7: KECCAK256
000012c8: PUSH1 0x02
000012ca: ADD
000012cb: SLOAD
000012cc: PUSH2 0x12d7
000012cf: SWAP1
000012d0: PUSH2 0x0734
000012d3: PUSH2 0x134f
000012d6: JUMP
000012d7: JUMPDEST
000012d8: PUSH2 0x0d22
000012db: JUMPI
000012dc: PUSH1 0x40
000012de: MLOAD
000012df: PUSH3 0x461bcd
000012e3: PUSH1 0xe5
000012e5: SHL
000012e6: DUP2
000012e7: MSTORE
000012e8: PUSH1 0x04
000012ea: ADD
000012eb: DUP1
000012ec: DUP1
000012ed: PUSH1 0x20
000012ef: ADD
000012f0: DUP3
000012f1: DUP2
000012f2: SUB
000012f3: DUP3
000012f4: MSTORE
000012f5: PUSH1 0x30
000012f7: DUP2
000012f8: MSTORE
000012f9: PUSH1 0x20
000012fb: ADD
000012fc: DUP1
000012fd: PUSH2 0x1af9
00001300: PUSH1 0x30
00001302: SWAP2
00001303: CODECOPY
00001304: PUSH1 0x40
00001306: ADD
00001307: SWAP2
00001308: POP
00001309: POP
0000130a: PUSH1 0x40
0000130c: MLOAD
0000130d: DUP1
0000130e: SWAP2
0000130f: SUB
00001310: SWAP1
00001311: REVERT
00001312: JUMPDEST
00001313: PUSH1 0x40
00001315: DUP1
00001316: MLOAD
00001317: PUSH8 0x5749544844524157
00001320: PUSH1 0xc0
00001322: SHL
00001323: DUP2
00001324: MSTORE
00001325: SWAP1
00001326: MLOAD
00001327: SWAP1
00001328: DUP2
00001329: SWAP1
0000132a: SUB
0000132b: PUSH1 0x08
0000132d: ADD
0000132e: SWAP1
0000132f: KECCAK256
00001330: DUP2
00001331: JUMP
00001332: JUMPDEST
00001333: PUSH1 0x40
00001335: DUP1
00001336: MLOAD
00001337: PUSH5 0x5452414445
0000133d: PUSH1 0xd8
0000133f: SHL
00001340: DUP2
00001341: MSTORE
00001342: SWAP1
00001343: MLOAD
00001344: SWAP1
00001345: DUP2
00001346: SWAP1
00001347: SUB
00001348: PUSH1 0x05
0000134a: ADD
0000134b: SWAP1
0000134c: KECCAK256
0000134d: DUP2
0000134e: JUMP
0000134f: JUMPDEST
00001350: CALLER
00001351: SWAP1
00001352: JUMP
00001353: JUMPDEST
00001354: PUSH1 0x03
00001356: SLOAD
00001357: PUSH1 0x01
00001359: PUSH1 0xa0
0000135b: SHL
0000135c: SWAP1
0000135d: DIV
0000135e: PUSH1 0xff
00001360: AND
00001361: DUP2
00001362: GT
00001363: ISZERO
00001364: PUSH2 0x139e
00001367: JUMPI
00001368: PUSH1 0x40
0000136a: MLOAD
0000136b: PUSH3 0x461bcd
0000136f: PUSH1 0xe5
00001371: SHL
00001372: DUP2
00001373: MSTORE
00001374: PUSH1 0x04
00001376: ADD
00001377: DUP1
00001378: DUP1
00001379: PUSH1 0x20
0000137b: ADD
0000137c: DUP3
0000137d: DUP2
0000137e: SUB
0000137f: DUP3
00001380: MSTORE
00001381: PUSH1 0x37
00001383: DUP2
00001384: MSTORE
00001385: PUSH1 0x20
00001387: ADD
00001388: DUP1
00001389: PUSH2 0x1b6d
0000138c: PUSH1 0x37
0000138e: SWAP2
0000138f: CODECOPY
00001390: PUSH1 0x40
00001392: ADD
00001393: SWAP2
00001394: POP
00001395: POP
00001396: PUSH1 0x40
00001398: MLOAD
00001399: DUP1
0000139a: SWAP2
0000139b: SUB
0000139c: SWAP1
0000139d: REVERT
0000139e: JUMPDEST
0000139f: PUSH1 0x00
000013a1: JUMPDEST
000013a2: DUP2
000013a3: DUP2
000013a4: LT
000013a5: ISZERO
000013a6: PUSH2 0x1592
000013a9: JUMPI
000013aa: PUSH1 0x03
000013ac: SLOAD
000013ad: PUSH1 0x40
000013af: MLOAD
000013b0: PUSH32 0x7ff36ab500000000000000000000000000000000000000000000000000000000
000013d1: DUP2
000013d2: MSTORE
000013d3: PUSH1 0x04
000013d5: DUP2
000013d6: ADD
000013d7: DUP9
000013d8: DUP2
000013d9: MSTORE
000013da: PUSH1 0x01
000013dc: PUSH1 0x01
000013de: PUSH1 0xa0
000013e0: SHL
000013e1: SUB
000013e2: DUP8
000013e3: DUP2
000013e4: AND
000013e5: PUSH1 0x44
000013e7: DUP5
000013e8: ADD
000013e9: MSTORE
000013ea: PUSH1 0x64
000013ec: DUP4
000013ed: ADD
000013ee: DUP8
000013ef: SWAP1
000013f0: MSTORE
000013f1: PUSH1 0x80
000013f3: PUSH1 0x24
000013f5: DUP5
000013f6: ADD
000013f7: SWAP1
000013f8: DUP2
000013f9: MSTORE
000013fa: DUP10
000013fb: MLOAD
000013fc: PUSH1 0x84
000013fe: DUP6
000013ff: ADD
00001400: MSTORE
00001401: DUP10
00001402: MLOAD
00001403: SWAP2
00001404: SWAP1
00001405: SWAP5
00001406: AND
00001407: SWAP4
00001408: PUSH4 0x7ff36ab5
0000140d: SWAP4
0000140e: DUP13
0000140f: SWAP4
00001410: DUP13
00001411: SWAP4
00001412: DUP13
00001413: SWAP4
00001414: DUP13
00001415: SWAP4
00001416: DUP13
00001417: SWAP4
00001418: SWAP3
00001419: PUSH1 0xa4
0000141b: SWAP1
0000141c: SWAP2
0000141d: ADD
0000141e: SWAP1
0000141f: PUSH1 0x20
00001421: DUP1
00001422: DUP9
00001423: ADD
00001424: SWAP2
00001425: MUL
00001426: DUP1
00001427: DUP4
00001428: DUP4
00001429: PUSH1 0x00
0000142b: JUMPDEST
0000142c: DUP4
0000142d: DUP2
0000142e: LT
0000142f: ISZERO
00001430: PUSH2 0x1443
00001433: JUMPI
00001434: DUP2
00001435: DUP2
00001436: ADD
00001437: MLOAD
00001438: DUP4
00001439: DUP3
0000143a: ADD
0000143b: MSTORE
0000143c: PUSH1 0x20
0000143e: ADD
0000143f: PUSH2 0x142b
00001442: JUMP
00001443: JUMPDEST
00001444: POP
00001445: POP
00001446: POP
00001447: POP
00001448: SWAP1
00001449: POP
0000144a: ADD
0000144b: SWAP6
0000144c: POP
0000144d: POP
0000144e: POP
0000144f: POP
00001450: POP
00001451: POP
00001452: PUSH1 0x00
00001454: PUSH1 0x40
00001456: MLOAD
00001457: DUP1
00001458: DUP4
00001459: SUB
0000145a: DUP2
0000145b: DUP6
0000145c: DUP9
0000145d: DUP1
0000145e: EXTCODESIZE
0000145f: ISZERO
00001460: DUP1
00001461: ISZERO
00001462: PUSH2 0x146a
00001465: JUMPI
00001466: PUSH1 0x00
00001468: DUP1
00001469: REVERT
0000146a: JUMPDEST
0000146b: POP
0000146c: GAS
0000146d: CALL
0000146e: ISZERO
0000146f: DUP1
00001470: ISZERO
00001471: PUSH2 0x147e
00001474: JUMPI
00001475: RETURNDATASIZE
00001476: PUSH1 0x00
00001478: DUP1
00001479: RETURNDATACOPY
0000147a: RETURNDATASIZE
0000147b: PUSH1 0x00
0000147d: REVERT
0000147e: JUMPDEST
0000147f: POP
00001480: POP
00001481: POP
00001482: POP
00001483: POP
00001484: PUSH1 0x40
00001486: MLOAD
00001487: RETURNDATASIZE
00001488: PUSH1 0x00
0000148a: DUP3
0000148b: RETURNDATACOPY
0000148c: PUSH1 0x1f
0000148e: RETURNDATASIZE
0000148f: SWAP1
00001490: DUP2
00001491: ADD
00001492: PUSH1 0x1f
00001494: NOT
00001495: AND
00001496: DUP3
00001497: ADD
00001498: PUSH1 0x40
0000149a: MSTORE
0000149b: PUSH1 0x20
0000149d: DUP2
0000149e: LT
0000149f: ISZERO
000014a0: PUSH2 0x14a8
000014a3: JUMPI
000014a4: PUSH1 0x00
000014a6: DUP1
000014a7: REVERT
000014a8: JUMPDEST
000014a9: DUP2
000014aa: ADD
000014ab: SWAP1
000014ac: DUP1
000014ad: DUP1
000014ae: MLOAD
000014af: PUSH1 0x40
000014b1: MLOAD
000014b2: SWAP4
000014b3: SWAP3
000014b4: SWAP2
000014b5: SWAP1
000014b6: DUP5
000014b7: PUSH5 0x0100000000
000014bd: DUP3
000014be: GT
000014bf: ISZERO
000014c0: PUSH2 0x14c8
000014c3: JUMPI
000014c4: PUSH1 0x00
000014c6: DUP1
000014c7: REVERT
000014c8: JUMPDEST
000014c9: SWAP1
000014ca: DUP4
000014cb: ADD
000014cc: SWAP1
000014cd: PUSH1 0x20
000014cf: DUP3
000014d0: ADD
000014d1: DUP6
000014d2: DUP2
000014d3: GT
000014d4: ISZERO
000014d5: PUSH2 0x14dd
000014d8: JUMPI
000014d9: PUSH1 0x00
000014db: DUP1
000014dc: REVERT
000014dd: JUMPDEST
000014de: DUP3
000014df: MLOAD
000014e0: DUP7
000014e1: PUSH1 0x20
000014e3: DUP3
000014e4: MUL
000014e5: DUP4
000014e6: ADD
000014e7: GT
000014e8: PUSH5 0x0100000000
000014ee: DUP3
000014ef: GT
000014f0: OR
000014f1: ISZERO
000014f2: PUSH2 0x14fa
000014f5: JUMPI
000014f6: PUSH1 0x00
000014f8: DUP1
000014f9: REVERT
000014fa: JUMPDEST
000014fb: DUP3
000014fc: MSTORE
000014fd: POP
000014fe: DUP2
000014ff: MLOAD
00001500: PUSH1 0x20
00001502: SWAP2
00001503: DUP3
00001504: ADD
00001505: SWAP3
00001506: DUP3
00001507: ADD
00001508: SWAP2
00001509: MUL
0000150a: DUP1
0000150b: DUP4
0000150c: DUP4
0000150d: PUSH1 0x00
0000150f: JUMPDEST
00001510: DUP4
00001511: DUP2
00001512: LT
00001513: ISZERO
00001514: PUSH2 0x1527
00001517: JUMPI
00001518: DUP2
00001519: DUP2
0000151a: ADD
0000151b: MLOAD
0000151c: DUP4
0000151d: DUP3
0000151e: ADD
0000151f: MSTORE
00001520: PUSH1 0x20
00001522: ADD
00001523: PUSH2 0x150f
00001526: JUMP
00001527: JUMPDEST
00001528: POP
00001529: POP
0000152a: POP
0000152b: POP
0000152c: SWAP1
0000152d: POP
0000152e: ADD
0000152f: PUSH1 0x40
00001531: MSTORE
00001532: POP
00001533: POP
00001534: POP
00001535: POP
00001536: DUP4
00001537: PUSH1 0x01
00001539: PUSH1 0x01
0000153b: PUSH1 0xa0
0000153d: SHL
0000153e: SUB
0000153f: AND
00001540: DUP6
00001541: PUSH1 0x01
00001543: DUP2
00001544: MLOAD
00001545: DUP2
00001546: LT
00001547: PUSH2 0x154c
0000154a: JUMPI
0000154b: INVALID
0000154c: JUMPDEST
0000154d: PUSH1 0x20
0000154f: MUL
00001550: PUSH1 0x20
00001552: ADD
00001553: ADD
00001554: MLOAD
00001555: PUSH1 0x01
00001557: PUSH1 0x01
00001559: PUSH1 0xa0
0000155b: SHL
0000155c: SUB
0000155d: AND
0000155e: DUP9
0000155f: PUSH32 0x818e36cd4b3f0eac892fd350da90fcce818345df1831ab3c41abd5a1efafba70
00001580: PUSH1 0x40
00001582: MLOAD
00001583: PUSH1 0x40
00001585: MLOAD
00001586: DUP1
00001587: SWAP2
00001588: SUB
00001589: SWAP1
0000158a: LOG4
0000158b: PUSH1 0x01
0000158d: ADD
0000158e: PUSH2 0x13a1
00001591: JUMP
00001592: JUMPDEST
00001593: POP
00001594: POP
00001595: POP
00001596: POP
00001597: POP
00001598: POP
00001599: POP
0000159a: JUMP
0000159b: JUMPDEST
0000159c: PUSH1 0x03
0000159e: SLOAD
0000159f: PUSH1 0x01
000015a1: PUSH1 0xa0
000015a3: SHL
000015a4: SWAP1
000015a5: DIV
000015a6: PUSH1 0xff
000015a8: AND
000015a9: DUP3
000015aa: GT
000015ab: ISZERO
000015ac: PUSH2 0x15e6
000015af: JUMPI
000015b0: PUSH1 0x40
000015b2: MLOAD
000015b3: PUSH3 0x461bcd
000015b7: PUSH1 0xe5
000015b9: SHL
000015ba: DUP2
000015bb: MSTORE
000015bc: PUSH1 0x04
000015be: ADD
000015bf: DUP1
000015c0: DUP1
000015c1: PUSH1 0x20
000015c3: ADD
000015c4: DUP3
000015c5: DUP2
000015c6: SUB
000015c7: DUP3
000015c8: MSTORE
000015c9: PUSH1 0x37
000015cb: DUP2
000015cc: MSTORE
000015cd: PUSH1 0x20
000015cf: ADD
000015d0: DUP1
000015d1: PUSH2 0x1b6d
000015d4: PUSH1 0x37
000015d6: SWAP2
000015d7: CODECOPY
000015d8: PUSH1 0x40
000015da: ADD
000015db: SWAP2
000015dc: POP
000015dd: POP
000015de: PUSH1 0x40
000015e0: MLOAD
000015e1: DUP1
000015e2: SWAP2
000015e3: SUB
000015e4: SWAP1
000015e5: REVERT
000015e6: JUMPDEST
000015e7: PUSH1 0x00
000015e9: JUMPDEST
000015ea: DUP3
000015eb: DUP2
000015ec: LT
000015ed: ISZERO
000015ee: PUSH2 0x1592
000015f1: JUMPI
000015f2: PUSH1 0x03
000015f4: SLOAD
000015f5: PUSH1 0x40
000015f7: MLOAD
000015f8: PUSH32 0xfb3bdb4100000000000000000000000000000000000000000000000000000000
00001619: DUP2
0000161a: MSTORE
0000161b: PUSH1 0x04
0000161d: DUP2
0000161e: ADD
0000161f: DUP10
00001620: DUP2
00001621: MSTORE
00001622: PUSH1 0x01
00001624: PUSH1 0x01
00001626: PUSH1 0xa0
00001628: SHL
00001629: SUB
0000162a: DUP9
0000162b: DUP2
0000162c: AND
0000162d: PUSH1 0x44
0000162f: DUP5
00001630: ADD
00001631: MSTORE
00001632: PUSH1 0x64
00001634: DUP4
00001635: ADD
00001636: DUP9
00001637: SWAP1
00001638: MSTORE
00001639: PUSH1 0x80
0000163b: PUSH1 0x24
0000163d: DUP5
0000163e: ADD
0000163f: SWAP1
00001640: DUP2
00001641: MSTORE
00001642: DUP11
00001643: MLOAD
00001644: PUSH1 0x84
00001646: DUP6
00001647: ADD
00001648: MSTORE
00001649: DUP11
0000164a: MLOAD
0000164b: SWAP2
0000164c: SWAP1
0000164d: SWAP5
0000164e: AND
0000164f: SWAP4
00001650: PUSH4 0xfb3bdb41
00001655: SWAP4
00001656: DUP8
00001657: SWAP4
00001658: DUP14
00001659: SWAP4
0000165a: DUP14
0000165b: SWAP4
0000165c: DUP14
0000165d: SWAP4
0000165e: DUP14
0000165f: SWAP4
00001660: SWAP3
00001661: PUSH1 0xa4
00001663: SWAP1
00001664: SWAP2
00001665: ADD
00001666: SWAP1
00001667: PUSH1 0x20
00001669: DUP1
0000166a: DUP9
0000166b: ADD
0000166c: SWAP2
0000166d: MUL
0000166e: DUP1
0000166f: DUP4
00001670: DUP4
00001671: PUSH1 0x00
00001673: JUMPDEST
00001674: DUP4
00001675: DUP2
00001676: LT
00001677: ISZERO
00001678: PUSH2 0x168b
0000167b: JUMPI
0000167c: DUP2
0000167d: DUP2
0000167e: ADD
0000167f: MLOAD
00001680: DUP4
00001681: DUP3
00001682: ADD
00001683: MSTORE
00001684: PUSH1 0x20
00001686: ADD
00001687: PUSH2 0x1673
0000168a: JUMP
0000168b: JUMPDEST
0000168c: POP
0000168d: POP
0000168e: POP
0000168f: POP
00001690: SWAP1
00001691: POP
00001692: ADD
00001693: SWAP6
00001694: POP
00001695: POP
00001696: POP
00001697: POP
00001698: POP
00001699: POP
0000169a: PUSH1 0x00
0000169c: PUSH1 0x40
0000169e: MLOAD
0000169f: DUP1
000016a0: DUP4
000016a1: SUB
000016a2: DUP2
000016a3: DUP6
000016a4: DUP9
000016a5: DUP1
000016a6: EXTCODESIZE
000016a7: ISZERO
000016a8: DUP1
000016a9: ISZERO
000016aa: PUSH2 0x16b2
000016ad: JUMPI
000016ae: PUSH1 0x00
000016b0: DUP1
000016b1: REVERT
000016b2: JUMPDEST
000016b3: POP
000016b4: GAS
000016b5: CALL
000016b6: ISZERO
000016b7: DUP1
000016b8: ISZERO
000016b9: PUSH2 0x16c6
000016bc: JUMPI
000016bd: RETURNDATASIZE
000016be: PUSH1 0x00
000016c0: DUP1
000016c1: RETURNDATACOPY
000016c2: RETURNDATASIZE
000016c3: PUSH1 0x00
000016c5: REVERT
000016c6: JUMPDEST
000016c7: POP
000016c8: POP
000016c9: POP
000016ca: POP
000016cb: POP
000016cc: PUSH1 0x40
000016ce: MLOAD
000016cf: RETURNDATASIZE
000016d0: PUSH1 0x00
000016d2: DUP3
000016d3: RETURNDATACOPY
000016d4: PUSH1 0x1f
000016d6: RETURNDATASIZE
000016d7: SWAP1
000016d8: DUP2
000016d9: ADD
000016da: PUSH1 0x1f
000016dc: NOT
000016dd: AND
000016de: DUP3
000016df: ADD
000016e0: PUSH1 0x40
000016e2: MSTORE
000016e3: PUSH1 0x20
000016e5: DUP2
000016e6: LT
000016e7: ISZERO
000016e8: PUSH2 0x16f0
000016eb: JUMPI
000016ec: PUSH1 0x00
000016ee: DUP1
000016ef: REVERT
000016f0: JUMPDEST
000016f1: DUP2
000016f2: ADD
000016f3: SWAP1
000016f4: DUP1
000016f5: DUP1
000016f6: MLOAD
000016f7: PUSH1 0x40
000016f9: MLOAD
000016fa: SWAP4
000016fb: SWAP3
000016fc: SWAP2
000016fd: SWAP1
000016fe: DUP5
000016ff: PUSH5 0x0100000000
00001705: DUP3
00001706: GT
00001707: ISZERO
00001708: PUSH2 0x1710
0000170b: JUMPI
0000170c: PUSH1 0x00
0000170e: DUP1
0000170f: REVERT
00001710: JUMPDEST
00001711: SWAP1
00001712: DUP4
00001713: ADD
00001714: SWAP1
00001715: PUSH1 0x20
00001717: DUP3
00001718: ADD
00001719: DUP6
0000171a: DUP2
0000171b: GT
0000171c: ISZERO
0000171d: PUSH2 0x1725
00001720: JUMPI
00001721: PUSH1 0x00
00001723: DUP1
00001724: REVERT
00001725: JUMPDEST
00001726: DUP3
00001727: MLOAD
00001728: DUP7
00001729: PUSH1 0x20
0000172b: DUP3
0000172c: MUL
0000172d: DUP4
0000172e: ADD
0000172f: GT
00001730: PUSH5 0x0100000000
00001736: DUP3
00001737: GT
00001738: OR
00001739: ISZERO
0000173a: PUSH2 0x1742
0000173d: JUMPI
0000173e: PUSH1 0x00
00001740: DUP1
00001741: REVERT
00001742: JUMPDEST
00001743: DUP3
00001744: MSTORE
00001745: POP
00001746: DUP2
00001747: MLOAD
00001748: PUSH1 0x20
0000174a: SWAP2
0000174b: DUP3
0000174c: ADD
0000174d: SWAP3
0000174e: DUP3
0000174f: ADD
00001750: SWAP2
00001751: MUL
00001752: DUP1
00001753: DUP4
00001754: DUP4
00001755: PUSH1 0x00
00001757: JUMPDEST
00001758: DUP4
00001759: DUP2
0000175a: LT
0000175b: ISZERO
0000175c: PUSH2 0x176f
0000175f: JUMPI
00001760: DUP2
00001761: DUP2
00001762: ADD
00001763: MLOAD
00001764: DUP4
00001765: DUP3
00001766: ADD
00001767: MSTORE
00001768: PUSH1 0x20
0000176a: ADD
0000176b: PUSH2 0x1757
0000176e: JUMP
0000176f: JUMPDEST
00001770: POP
00001771: POP
00001772: POP
00001773: POP
00001774: SWAP1
00001775: POP
00001776: ADD
00001777: PUSH1 0x40
00001779: MSTORE
0000177a: POP
0000177b: POP
0000177c: POP
0000177d: POP
0000177e: DUP5
0000177f: PUSH1 0x01
00001781: PUSH1 0x01
00001783: PUSH1 0xa0
00001785: SHL
00001786: SUB
00001787: AND
00001788: DUP7
00001789: PUSH1 0x01
0000178b: DUP2
0000178c: MLOAD
0000178d: DUP2
0000178e: LT
0000178f: PUSH2 0x1794
00001792: JUMPI
00001793: INVALID
00001794: JUMPDEST
00001795: PUSH1 0x20
00001797: MUL
00001798: PUSH1 0x20
0000179a: ADD
0000179b: ADD
0000179c: MLOAD
0000179d: PUSH1 0x01
0000179f: PUSH1 0x01
000017a1: PUSH1 0xa0
000017a3: SHL
000017a4: SUB
000017a5: AND
000017a6: DUP4
000017a7: PUSH32 0x818e36cd4b3f0eac892fd350da90fcce818345df1831ab3c41abd5a1efafba70
000017c8: PUSH1 0x40
000017ca: MLOAD
000017cb: PUSH1 0x40
000017cd: MLOAD
000017ce: DUP1
000017cf: SWAP2
000017d0: SUB
000017d1: SWAP1
000017d2: LOG4
000017d3: PUSH1 0x01
000017d5: ADD
000017d6: PUSH2 0x15e9
000017d9: JUMP
000017da: JUMPDEST
000017db: PUSH1 0x00
000017dd: DUP3
000017de: DUP2
000017df: MSTORE
000017e0: PUSH1 0x20
000017e2: DUP2
000017e3: SWAP1
000017e4: MSTORE
000017e5: PUSH1 0x40
000017e7: SWAP1
000017e8: KECCAK256
000017e9: PUSH2 0x17f8
000017ec: SWAP1
000017ed: DUP3
000017ee: PUSH4 0xffffffff
000017f3: PUSH2 0x18f1
000017f6: AND
000017f7: JUMP
000017f8: JUMPDEST
000017f9: ISZERO
000017fa: PUSH2 0x0cc7
000017fd: JUMPI
000017fe: PUSH2 0x1805
00001801: PUSH2 0x134f
00001804: JUMP
00001805: JUMPDEST
00001806: PUSH1 0x01
00001808: PUSH1 0x01
0000180a: PUSH1 0xa0
0000180c: SHL
0000180d: SUB
0000180e: AND
0000180f: DUP2
00001810: PUSH1 0x01
00001812: PUSH1 0x01
00001814: PUSH1 0xa0
00001816: SHL
00001817: SUB
00001818: AND
00001819: DUP4
0000181a: PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d
0000183b: PUSH1 0x40
0000183d: MLOAD
0000183e: PUSH1 0x40
00001840: MLOAD
00001841: DUP1
00001842: SWAP2
00001843: SUB
00001844: SWAP1
00001845: LOG4
00001846: POP
00001847: POP
00001848: JUMP
00001849: JUMPDEST
0000184a: PUSH1 0x00
0000184c: DUP3
0000184d: DUP2
0000184e: MSTORE
0000184f: PUSH1 0x20
00001851: DUP2
00001852: SWAP1
00001853: MSTORE
00001854: PUSH1 0x40
00001856: SWAP1
00001857: KECCAK256
00001858: PUSH2 0x1867
0000185b: SWAP1
0000185c: DUP3
0000185d: PUSH4 0xffffffff
00001862: PUSH2 0x1906
00001865: AND
00001866: JUMP
00001867: JUMPDEST
00001868: ISZERO
00001869: PUSH2 0x0cc7
0000186c: JUMPI
0000186d: PUSH2 0x1874
00001870: PUSH2 0x134f
00001873: JUMP
00001874: JUMPDEST
00001875: PUSH1 0x01
00001877: PUSH1 0x01
00001879: PUSH1 0xa0
0000187b: SHL
0000187c: SUB
0000187d: AND
0000187e: DUP2
0000187f: PUSH1 0x01
00001881: PUSH1 0x01
00001883: PUSH1 0xa0
00001885: SHL
00001886: SUB
00001887: AND
00001888: DUP4
00001889: PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b
000018aa: PUSH1 0x40
000018ac: MLOAD
000018ad: PUSH1 0x40
000018af: MLOAD
000018b0: DUP1
000018b1: SWAP2
000018b2: SUB
000018b3: SWAP1
000018b4: LOG4
000018b5: POP
000018b6: POP
000018b7: JUMP
000018b8: JUMPDEST
000018b9: PUSH1 0x00
000018bb: PUSH2 0x108b
000018be: DUP4
000018bf: DUP4
000018c0: PUSH2 0x191b
000018c3: JUMP
000018c4: JUMPDEST
000018c5: PUSH1 0x00
000018c7: PUSH2 0x108b
000018ca: DUP4
000018cb: PUSH1 0x01
000018cd: PUSH1 0x01
000018cf: PUSH1 0xa0
000018d1: SHL
000018d2: SUB
000018d3: DUP5
000018d4: AND
000018d5: PUSH2 0x197f
000018d8: JUMP
000018d9: JUMPDEST
000018da: SLOAD
000018db: SWAP1
000018dc: JUMP
000018dd: JUMPDEST
000018de: DUP1
000018df: SLOAD
000018e0: PUSH1 0x01
000018e2: ADD
000018e3: SWAP1
000018e4: SSTORE
000018e5: JUMP
000018e6: JUMPDEST
000018e7: PUSH1 0x00
000018e9: PUSH2 0x108e
000018ec: DUP3
000018ed: PUSH2 0x18d9
000018f0: JUMP
000018f1: JUMPDEST
000018f2: PUSH1 0x00
000018f4: PUSH2 0x108b
000018f7: DUP4
000018f8: PUSH1 0x01
000018fa: PUSH1 0x01
000018fc: PUSH1 0xa0
000018fe: SHL
000018ff: SUB
00001900: DUP5
00001901: AND
00001902: PUSH2 0x1997
00001905: JUMP
00001906: JUMPDEST
00001907: PUSH1 0x00
00001909: PUSH2 0x108b
0000190c: DUP4
0000190d: PUSH1 0x01
0000190f: PUSH1 0x01
00001911: PUSH1 0xa0
00001913: SHL
00001914: SUB
00001915: DUP5
00001916: AND
00001917: PUSH2 0x19e1
0000191a: JUMP
0000191b: JUMPDEST
0000191c: DUP2
0000191d: SLOAD
0000191e: PUSH1 0x00
00001920: SWAP1
00001921: DUP3
00001922: LT
00001923: PUSH2 0x195d
00001926: JUMPI
00001927: PUSH1 0x40
00001929: MLOAD
0000192a: PUSH3 0x461bcd
0000192e: PUSH1 0xe5
00001930: SHL
00001931: DUP2
00001932: MSTORE
00001933: PUSH1 0x04
00001935: ADD
00001936: DUP1
00001937: DUP1
00001938: PUSH1 0x20
0000193a: ADD
0000193b: DUP3
0000193c: DUP2
0000193d: SUB
0000193e: DUP3
0000193f: MSTORE
00001940: PUSH1 0x22
00001942: DUP2
00001943: MSTORE
00001944: PUSH1 0x20
00001946: ADD
00001947: DUP1
00001948: PUSH2 0x1aa8
0000194b: PUSH1 0x22
0000194d: SWAP2
0000194e: CODECOPY
0000194f: PUSH1 0x40
00001951: ADD
00001952: SWAP2
00001953: POP
00001954: POP
00001955: PUSH1 0x40
00001957: MLOAD
00001958: DUP1
00001959: SWAP2
0000195a: SUB
0000195b: SWAP1
0000195c: REVERT
0000195d: JUMPDEST
0000195e: DUP3
0000195f: PUSH1 0x00
00001961: ADD
00001962: DUP3
00001963: DUP2
00001964: SLOAD
00001965: DUP2
00001966: LT
00001967: PUSH2 0x196c
0000196a: JUMPI
0000196b: INVALID
0000196c: JUMPDEST
0000196d: SWAP1
0000196e: PUSH1 0x00
00001970: MSTORE
00001971: PUSH1 0x20
00001973: PUSH1 0x00
00001975: KECCAK256
00001976: ADD
00001977: SLOAD
00001978: SWAP1
00001979: POP
0000197a: SWAP3
0000197b: SWAP2
0000197c: POP
0000197d: POP
0000197e: JUMP
0000197f: JUMPDEST
00001980: PUSH1 0x00
00001982: SWAP1
00001983: DUP2
00001984: MSTORE
00001985: PUSH1 0x01
00001987: SWAP2
00001988: SWAP1
00001989: SWAP2
0000198a: ADD
0000198b: PUSH1 0x20
0000198d: MSTORE
0000198e: PUSH1 0x40
00001990: SWAP1
00001991: KECCAK256
00001992: SLOAD
00001993: ISZERO
00001994: ISZERO
00001995: SWAP1
00001996: JUMP
00001997: JUMPDEST
00001998: PUSH1 0x00
0000199a: PUSH2 0x19a3
0000199d: DUP4
0000199e: DUP4
0000199f: PUSH2 0x197f
000019a2: JUMP
000019a3: JUMPDEST
000019a4: PUSH2 0x19d9
000019a7: JUMPI
000019a8: POP
000019a9: DUP2
000019aa: SLOAD
000019ab: PUSH1 0x01
000019ad: DUP2
000019ae: DUP2
000019af: ADD
000019b0: DUP5
000019b1: SSTORE
000019b2: PUSH1 0x00
000019b4: DUP5
000019b5: DUP2
000019b6: MSTORE
000019b7: PUSH1 0x20
000019b9: DUP1
000019ba: DUP3
000019bb: KECCAK256
000019bc: SWAP1
000019bd: SWAP4
000019be: ADD
000019bf: DUP5
000019c0: SWAP1
000019c1: SSTORE
000019c2: DUP5
000019c3: SLOAD
000019c4: DUP5
000019c5: DUP3
000019c6: MSTORE
000019c7: DUP3
000019c8: DUP7
000019c9: ADD
000019ca: SWAP1
000019cb: SWAP4
000019cc: MSTORE
000019cd: PUSH1 0x40
000019cf: SWAP1
000019d0: KECCAK256
000019d1: SWAP2
000019d2: SWAP1
000019d3: SWAP2
000019d4: SSTORE
000019d5: PUSH2 0x108e
000019d8: JUMP
000019d9: JUMPDEST
000019da: POP
000019db: PUSH1 0x00
000019dd: PUSH2 0x108e
000019e0: JUMP
000019e1: JUMPDEST
000019e2: PUSH1 0x00
000019e4: DUP2
000019e5: DUP2
000019e6: MSTORE
000019e7: PUSH1 0x01
000019e9: DUP4
000019ea: ADD
000019eb: PUSH1 0x20
000019ed: MSTORE
000019ee: PUSH1 0x40
000019f0: DUP2
000019f1: KECCAK256
000019f2: SLOAD
000019f3: DUP1
000019f4: ISZERO
000019f5: PUSH2 0x1a9d
000019f8: JUMPI
000019f9: DUP4
000019fa: SLOAD
000019fb: PUSH1 0x00
000019fd: NOT
000019fe: DUP1
000019ff: DUP4
00001a00: ADD
00001a01: SWAP2
00001a02: SWAP1
00001a03: DUP2
00001a04: ADD
00001a05: SWAP1
00001a06: PUSH1 0x00
00001a08: SWAP1
00001a09: DUP8
00001a0a: SWAP1
00001a0b: DUP4
00001a0c: SWAP1
00001a0d: DUP2
00001a0e: LT
00001a0f: PUSH2 0x1a14
00001a12: JUMPI
00001a13: INVALID
00001a14: JUMPDEST
00001a15: SWAP1
00001a16: PUSH1 0x00
00001a18: MSTORE
00001a19: PUSH1 0x20
00001a1b: PUSH1 0x00
00001a1d: KECCAK256
00001a1e: ADD
00001a1f: SLOAD
00001a20: SWAP1
00001a21: POP
00001a22: DUP1
00001a23: DUP8
00001a24: PUSH1 0x00
00001a26: ADD
00001a27: DUP5
00001a28: DUP2
00001a29: SLOAD
00001a2a: DUP2
00001a2b: LT
00001a2c: PUSH2 0x1a31
00001a2f: JUMPI
00001a30: INVALID
00001a31: JUMPDEST
00001a32: PUSH1 0x00
00001a34: SWAP2
00001a35: DUP3
00001a36: MSTORE
00001a37: PUSH1 0x20
00001a39: DUP1
00001a3a: DUP4
00001a3b: KECCAK256
00001a3c: SWAP1
00001a3d: SWAP2
00001a3e: ADD
00001a3f: SWAP3
00001a40: SWAP1
00001a41: SWAP3
00001a42: SSTORE
00001a43: DUP3
00001a44: DUP2
00001a45: MSTORE
00001a46: PUSH1 0x01
00001a48: DUP10
00001a49: DUP2
00001a4a: ADD
00001a4b: SWAP1
00001a4c: SWAP3
00001a4d: MSTORE
00001a4e: PUSH1 0x40
00001a50: SWAP1
00001a51: KECCAK256
00001a52: SWAP1
00001a53: DUP5
00001a54: ADD
00001a55: SWAP1
00001a56: SSTORE
00001a57: DUP7
00001a58: SLOAD
00001a59: DUP8
00001a5a: SWAP1
00001a5b: DUP1
00001a5c: PUSH2 0x1a61
00001a5f: JUMPI
00001a60: INVALID
00001a61: JUMPDEST
00001a62: PUSH1 0x01
00001a64: SWAP1
00001a65: SUB
00001a66: DUP2
00001a67: DUP2
00001a68: SWAP1
00001a69: PUSH1 0x00
00001a6b: MSTORE
00001a6c: PUSH1 0x20
00001a6e: PUSH1 0x00
00001a70: KECCAK256
00001a71: ADD
00001a72: PUSH1 0x00
00001a74: SWAP1
00001a75: SSTORE
00001a76: SWAP1
00001a77: SSTORE
00001a78: DUP7
00001a79: PUSH1 0x01
00001a7b: ADD
00001a7c: PUSH1 0x00
00001a7e: DUP8
00001a7f: DUP2
00001a80: MSTORE
00001a81: PUSH1 0x20
00001a83: ADD
00001a84: SWAP1
00001a85: DUP2
00001a86: MSTORE
00001a87: PUSH1 0x20
00001a89: ADD
00001a8a: PUSH1 0x00
00001a8c: KECCAK256
00001a8d: PUSH1 0x00
00001a8f: SWAP1
00001a90: SSTORE
00001a91: PUSH1 0x01
00001a93: SWAP5
00001a94: POP
00001a95: POP
00001a96: POP
00001a97: POP
00001a98: POP
00001a99: PUSH2 0x108e
00001a9c: JUMP
00001a9d: JUMPDEST
00001a9e: PUSH1 0x00
00001aa0: SWAP2
00001aa1: POP
00001aa2: POP
00001aa3: PUSH2 0x108e
00001aa6: JUMP
00001aa7: INVALID
00001aa8: GASLIMIT
00001aa9: PUSH15 0x756d657261626c655365743a20696e
00001ab9: PUSH5 0x6578206f75
00001abf: PUSH21 0x206f6620626f756e6473416363657373436f6e7472
00001ad5: PUSH16 0x6c3a2073656e646572206d7573742062
00001ae6: PUSH6 0x20616e206164
00001aed: PUSH14 0x696e20746f206772616e74416363
00001afc: PUSH6 0x7373436f6e74
00001b03: PUSH19 0x6f6c3a2073656e646572206d75737420626520
00001b17: PUSH2 0x6e20
00001b1a: PUSH2 0x646d
00001b1d: PUSH10 0x6e20746f207265766f6b
00001b28: PUSH6 0x547261646520
00001b2f: PUSH24 0x6974682073616d6520696e64657820616c72656164792069
00001b48: PUSH15 0x2070726f63657373206f7220747261
00001b58: PUSH5 0x6520697320
00001b5e: PUSH15 0x6f7420726567697374657265642e4e
00001b6e: PUSH22 0x6d626572206f66207472616465732063616e206e6f74
00001b85: KECCAK256
00001b86: PUSH3 0x752062
00001b8a: PUSH10 0x67676572207468616e20
00001b95: UNKNOWN(0x4D)
00001b96: COINBASE
00001b97: PC
00001b98: PUSH0
00001b99: TIMESTAMP
00001b9a: COINBASE
00001b9b: SLOAD
00001b9c: NUMBER
00001b9d: BASEFEE
00001b9e: PUSH0
00001b9f: MSTORE8
00001ba0: BLOBHASH
00001ba1: GAS
00001ba2: GASLIMIT
00001ba3: UNKNOWN(0x2E)
00001ba4: COINBASE
00001ba5: PUSH4 0x63657373
00001baa: NUMBER
00001bab: PUSH16 0x6e74726f6c3a2063616e206f6e6c7920
00001bbc: PUSH19 0x656e6f756e636520726f6c657320666f722073
00001bd0: PUSH6 0x6c66a2646970
00001bd7: PUSH7 0x7358221220486a
00001bdf: ADDRESS
00001be0: UNKNOWN(0x0E)
00001be1: UNKNOWN(0xDF)
00001be2: DUP4
00001be3: EXP
00001be4: SLOAD
00001be5: DUP7
00001be6: SWAP15
00001be7: SWAP10
00001be8: CALLER
00001be9: UNKNOWN(0x22)
00001bea: SLOAD
00001beb: UNKNOWN(0xDA)
00001bec: UNKNOWN(0x25)
00001bed: SLOAD
00001bee: UNKNOWN(0xA9)
00001bef: INVALID
00001bf0: UNKNOWN(0xEE)
00001bf1: UNKNOWN(0xF7)
00001bf2: UNKNOWN(0xBA)
00001bf3: UNKNOWN(0x29)
00001bf4: UNKNOWN(0xCE)
00001bf5: UNKNOWN(0xCC)
00001bf6: UNKNOWN(0xD7)
00001bf7: LOG0
00001bf8: UNKNOWN(0x2A)
00001bf9: DUP7
00001bfa: MCOPY
00001bfb: UNKNOWN(0xB5)
00001bfc: SIGNEXTEND
00001bfd: PUSH5 0x736f6c6343
00001c03: STOP
00001c04: MOD
00001c05: MOD
00001c06: STOP
00001c07: CALLER