Analysis Run

{"no_findings":false,"summary":"Bytecode shows low-level CALLs with computed targets/values and no explicit guard metadata; confidence is limited without source, so findings focus on potential unsafe external calls.","findings":[{"severity":"low","category":"other","title":"Low-level CALL with computed target/value may allow unintended external calls or ETH transfers","exploit_scenario":"If any public/external function can influence the CALL target or value (e.g., via calldata or mutable storage without strict access control), an attacker could trigger the CALL to an arbitrary address and/or send ETH out of the contract. This could be abused to drain ETH or execute unexpected external logic. Bytecode evidence is incomplete; the target might be a fixed token/known address and value might be zero in practice.","recommendation":"Confirm the CALL target is immutable or tightly validated, and ensure any setters are access-controlled. If ETH transfers are intended, use checks-effects-interactions (and/or a reentrancy guard) and validate return data where applicable.","evidence":"Detector flagged untrusted CALL target/value and possible ETH value transfer; callsites at pc 0x07b2 and 0x147c show computed target usage with CALL. No guards detected in heuristics for these sinks.","locations":["pc:0x7b2","pc:0x147c"]}]}

OpenAI Codex v0.77.0 (research preview)
--------
workdir: /tmp/codex-r1gek8w5
model: gpt-5.2-codex
provider: openai
approval: never
sandbox: read-only
reasoning effort: high
reasoning summaries: auto
session id: 019bb387-242c-7fa0-81af-d21b6ae3d1b2
--------
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**
exec
/bin/bash -lc ls in /tmp/codex-r1gek8w5 succeeded in 6ms:
BYTECODE_BUNDLE.json
codex-output-schema.json
exec
/bin/bash -lc 'cat BYTECODE_BUNDLE.json' in /tmp/codex-r1gek8w5 succeeded in 7ms:
{
  "analysis_artifact": {
    "address": "0xf9742810d596769d6cb54799eb1e2ccda03aeb9c",
    "artifact_hash": "0xaa706da4e87d6cfc921774b2ed79f220a547b2b2b9335eabda19222d8b315ded",
    "artifact_json": {
      "auth": {
        "guards": []
      },
      "basic_blocks": [
        {
          "end_pc": 12,
          "hash": "0x9f8ccb418e8de572c2da548432a224657d4d8e5cac17c1c1aa7b9dc44f28f5a6",
          "opcodes": [
            "PUSH1",
            "PUSH1",
            "MSTORE",
            "PUSH1",
            "CALLDATASIZE",
            "LT",
            "PUSH2",

thinking
**Analyzing bytecode callsites and access control**

I'm planning to investigate suspicious CALL instructions at specific program counters by parsing large JSON artifacts with Python scripts to understand call targets, check for self-calls versus untrusted external calls, and assess potential reentrancy and access control risks indicated by presence or absence of ownership selectors in the bytecode.
exec
/bin/bash -lc "python - <<'PY'
import json
import bisect
from pathlib import Path
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
art=j['analysis_artifact']['artifact_json']
# find basic block containing pc 1970
bbs=art.get('basic_blocks',[])
# Some entries are not full? But there are full opcodes maybe for early blocks. We only need start/end
for bb in bbs:
    if isinstance(bb,dict) and bb.get('start_pc') is not None and bb.get('end_pc') is not None:
        if bb['start_pc']<=1970<=bb['end_pc']:
            print('bb', bb.get('start_pc'), bb.get('end_pc'))
            print(bb.get('opcodes')[:50])
            break
else:
    print('not found')
# also for 5244
for bb in bbs:
    if isinstance(bb,dict) and bb.get('start_pc') is not None and bb.get('end_pc') is not None:
        if bb['start_pc']<=5244<=bb['end_pc']:
            print('bb5244', bb.get('start_pc'), bb.get('end_pc'))
            print(bb.get('opcodes')[:80])
            break
PY" in /tmp/codex-r1gek8w5 succeeded in 82ms:
bb 1914 1983
['JUMPDEST', 'OP_90', 'OP_91', 'SSTORE', 'POP', 'POP', 'CALLER', 'PUSH0', 'OP_81', 'OP_81', 'MSTORE', 'PUSH1', 'PUSH1', 'OP_90', 'OP_81', 'MSTORE', 'PUSH1', 'OP_80', 'OP_83', 'SHA3', 'OP_89', 'OP_84', 'MSTORE', 'OP_90', 'OP_91', 'MSTORE', 'OP_80', 'OP_82', 'SHA3', 'OP_80', 'SLOAD', 'PUSH1', 'NOT', 'AND', 'PUSH1', 'OR', 'OP_90', 'SSTORE', 'MLOAD', 'OP_90', 'OP_91', 'OP_90', 'OP_85', 'OP_90', 'OP_83', 'OP_81', 'OP_81', 'OP_81', 'OP_85', 'OP_87']
bb5244 5229 5249
['JUMPDEST', 'PUSH0', 'PUSH0', 'PUSH1', 'PUSH0', 'OP_84', 'MLOAD', 'PUSH1', 'OP_86', 'ADD', 'PUSH0', 'OP_88', 'GAS', 'CALL', 'OP_80', 'PUSH2', 'JUMPI']

thinking
**Investigating bytecode presence**
exec
/bin/bash -lc 'rg -n "bytecode" BYTECODE_BUNDLE.json' in /tmp/codex-r1gek8w5 succeeded in 8ms:
10469:    "runtime_bytecode": {
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
rb=j['analysis_artifact']['artifact_json'].get('runtime_bytecode')
print(type(rb))
print(rb.keys())
print('length', len(rb.get('bytecode','')))
PY" in /tmp/codex-r1gek8w5 exited 1 in 41ms:
<class 'NoneType'>
Traceback (most recent call last):
  File "<stdin>", line 5, in <module>
AttributeError: 'NoneType' object has no attribute 'keys'

thinking
**Inspecting runtime_bytecode**
exec
/bin/bash -lc "python - <<'PY'
import json, itertools
p='/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'
# read limited
with open(p) as f:
    for i,line in zip(range(10460,10480), f):
        pass
# Actually, use sed
PY" in /tmp/codex-r1gek8w5 succeeded in 81ms:


thinking
**Choosing text-processing tool**
exec
/bin/bash -lc "sed -n '10460,10490p' BYTECODE_BUNDLE.json" in /tmp/codex-r1gek8w5 succeeded in 6ms:
      },
      "optimizer_enabled": false,
      "optimizer_runs": 0,
      "proxy_evidence": {
        "status": "not_proxy"
      }
    },
    "implementation_address": null,
    "is_proxy": false,
    "runtime_bytecode": {
      "full": "0x6080604052600436106100fa575f3560e01c80638252097d11610092578063b293109611610062578063b2931096146102c8578063b5d5b5fa14610311578063b62e1efc1461035f578063dc8d31b61461038a578063f2fde38b1461039f575f5ffd5b80638252097d14610218578063842e29811461026d5780638bdf67f2146102995780638da5cb5b146102ac575f5ffd5b8063715018a6116100cd578063715018a61461018557806371b63aae146101995780637b0472f0146101e4578063817b1cd214610203575f5ffd5b80630962ef79146100fe5780630cc2b37e1461011f5780632e17de78146101475780633c7d0d9614610166575b5f5ffd5b348015610109575f5ffd5b5061011d6101183660046114d9565b6103be565b005b34801561012a575f5ffd5b5061013460065481565b6040519081526020015b60405180910390f35b348015610152575f5ffd5b5061011d6101613660046114d9565b610878565b348015610171575f5ffd5b5061011d6101803660046114d9565b610ac1565b348015610190575f5ffd5b5061011d610b60565b3480156101a4575f5ffd5b506101cc7f000000000000000000000000f94e7d0710709388bce3161c32b4eea56d3f91cc81565b6040516001600160a01b03909116815260200161013e565b3480156101ef575f5ffd5b5061011d6101fe3660046114f0565b610b73565b34801561020e575f5ffd5b5061013460075481565b348015610223575f5ffd5b506102526102323660046114d9565b60036020525f908152604090208054600182015460029092015490919083565b6040805193845260208401929092529082015260600161013e565b348015610278575f5ffd5b5061028c610287366004611526565b610da9565b60405161013e919061153f565b61011d6102a73660046114d9565b610e57565b3480156102b7575f5ffd5b505f546001600160a01b03166101cc565b3480156102d3575f5ffd5b506103016102e23660046115bd565b600560209081525f928352604080842090915290825290205460ff1681565b604051901515815260200161013e565b34801561031c575f5ffd5b5061033061032b3660046115bd565b610f49565b6040805196875260208701959095529385019290925260608401521515608083015260a082015260c00161013e565b34801561036a575f5ffd5b506101346103793660046114d9565b60046020525f908152604090205481565b348015610395575f5ffd5b5061013460085481565b3480156103aa575f5ffd5b5061011d6103b9366004611526565b610f9f565b6103c6610fd9565b6103ce611003565b60065481111561041d5760405162461bcd60e51b8152602060048201526015602482015274125b9d985b1a59081c995dd85c99081c195c9a5bd9605a1b60448201526064015b60405180910390fd5b5f8181526003602052604090206002015442101561047d5760405162461bcd60e51b815260206004820152601760248201527f52657761726420706572696f64206e6f7420656e6465640000000000000000006044820152606401610414565b335f90815260056020908152604080832084845290915290205460ff16156104e75760405162461bcd60e51b815260206004820152601f60248201527f5265776172647320636c61696d656420666f72207468697320706572696f64006044820152606401610414565b335f908152600260205260408120548190815b8181101561062457335f908152600260205260408120805483908110610522576105226115e5565b5f9182526020909120600690910201600481015490915060ff16158015610570575060035f8781526020019081526020015f20600201548160030154826002015461056d919061160d565b11155b80156105b1575060035f8781526020019081526020015f20600201548160030154826001015483600201546105a5919061160d565b6105af919061160d565b115b1561061b575f62278d008260010154146105f6576276a7008260010154146105ef5762ed4e008260010154146105e85760046105f9565b60036105f9565b60026105f9565b60015b60ff16905080825f015461060d9190611626565b610617908761160d565b9550505b506001016104fa565b505f83116106745760405162461bcd60e51b815260206004820152601e60248201527f4e6f20656c696769626c65207374616b657320666f72207265776172647300006044820152606401610414565b5f84815260046020526040902054806106cf5760405162461bcd60e51b815260206004820152601f60248201527f52657761726420646973747269627574696f6e206e6f742073746172746564006044820152606401610414565b5f8581526003602052604090205481906106ea908690611626565b6106f4919061163d565b92505f831161073b5760405162461bcd60e51b81526020600482015260136024820152724e6f207265776172647320746f20636c61696d60681b6044820152606401610414565b5f858152600360205260408120805485929061075890849061165c565b90915550505f858152600460205260408120805486929061077a90849061165c565b9091555050335f818152600560209081526040808320898452909152808220805460ff191660011790555190919085908381818185875af1925050503d805f81146107e0576040519150601f19603f3d011682016040523d82523d5f602084013e6107e5565b606091505b505090508061082c5760405162461bcd60e51b8152602060048201526013602482015272115512081d1c985b9cd9995c8819985a5b1959606a1b6044820152606401610414565b604080518781526020810186905233917ff01da32686223933d8a18a391060918c7f11a3648639edd87ae013e2e2731743910160405180910390a2505050505061087560018055565b50565b610880610fd9565b335f9081526002602052604090205481106108d35760405162461bcd60e51b8152602060048201526013602482015272092dcecc2d8d2c840e6e8c2d6ca40d2dcc8caf606b1b6044820152606401610414565b335f9081526002602052604081208054839081106108f3576108f36115e5565b5f9182526020909120600690910201600481015490915060ff161561094e5760405162461bcd60e51b815260206004820152601160248201527020b63932b0b23c903bb4ba34323930bbb760791b6044820152606401610414565b610958815f611124565b8054600182015460028301545f92916109709161160d565b4210156109d75762278d008360010154146109b6576276a7008360010154146109af5762ed4e008360010154146109a857600a6109b9565b600c6109b9565b600d6109b9565b600f5b60ff16915060646109ca8383611626565b6109d4919061163d565b91505b5f6109e2838361165c565b90508160075f8282546109f5919061165c565b909155505060048401805460ff191660011790558215610a4557610a456001600160a01b037f000000000000000000000000f94e7d0710709388bce3161c32b4eea56d3f91cc1661dead856112e3565b610a796001600160a01b037f000000000000000000000000f94e7d0710709388bce3161c32b4eea56d3f91cc1633836112e3565b604080518381526020810185905233917f7fc4727e062e336010f2c282598ef5f14facb3de68cf8195c2f23e1454b2b74e910160405180910390a25050505061087560018055565b610ac9611347565b620697808110158015610adf5750621a5e008111155b610b245760405162461bcd60e51b81526020600482015260166024820152755468726573686f6c64206f7574206f662072616e676560501b6044820152606401610414565b60088190556040518181527fadebce7a5ac7f8970d9f38c5d050b091f0210351f4dcf86301867a4214abfb92906020015b60405180910390a150565b610b68611347565b610b715f611373565b565b610b7b610fd9565b62278d00811480610b8e57506276a70081145b80610b9b575062ed4e0081145b80610ba957506301da9c0081145b610bee5760405162461bcd60e51b8152602060048201526016602482015275125b9d985b1a59081b1bd8dacb5a5b881c195c9a5bd960521b6044820152606401610414565b5f8211610c355760405162461bcd60e51b815260206004820152601560248201527410d85b9b9bdd081cdd185ad9480c08185b5bdd5b9d605a1b6044820152606401610414565b610c6a6001600160a01b037f000000000000000000000000f94e7d0710709388bce3161c32b4eea56d3f91cc163330856113c2565b610c72611003565b335f908152600260208181526040808420815160c0810183528781528084018781524293820193845260085460608301908152608083018881526006805460a08601908152865460018082018955978c52988b209551989091029094019687559151938601939093559251948401949094555160038301555160048201805460ff1916911515919091179055905160059091015560078054849290610d1890849061160d565b9091555050335f9081526002602052604090208054610d619190610d3e9060019061165c565b81548110610d4e57610d4e6115e5565b905f5260205f2090600602016001611124565b604080518381526020810183905233917f1449c6dd7851abc30abf37f57715f492010519147cc2652fbc38202c18a6ee90910160405180910390a2610da560018055565b5050565b6001600160a01b0381165f908152600260209081526040808320805482518185028101850190935280835260609492939192909184015b82821015610e4c575f8481526020908190206040805160c08101825260068602909201805483526001808201548486015260028201549284019290925260038101546060840152600481015460ff16151560808401526005015460a08301529083529092019101610de0565b505050509050919050565b610e5f611347565b610e67611003565b5f3411610ea95760405162461bcd60e51b815260206004820152601060248201526f139bc81155120819195c1bdcda5d195960821b6044820152606401610414565b6006548114610ef25760405162461bcd60e51b8152602060048201526015602482015274125b9d985b1a59081c995dd85c99081c195c9a5bd9605a1b6044820152606401610414565b5f8181526003602052604081208054349290610f0f90849061160d565b9091555050604080518281523460208201527fbf2ebcc991369bcf488ef5738352a5d8998bd7a2c138128ca91ec96afe123fd69101610b55565b6002602052815f5260405f208181548110610f62575f80fd5b5f91825260209091206006909102018054600182015460028301546003840154600485015460059095015493965091945092909160ff9091169086565b610fa7611347565b6001600160a01b038116610fd057604051631e4fbdf760e01b81525f6004820152602401610414565b61087581611373565b600260015403610ffc57604051633ee5aeb560e01b815260040160405180910390fd5b6002600155565b6006545f908152600360205260409020600201544210610b7157600680549081905f61102e8361166f565b919050555060405180606001604052805f815260200160035f6001600654611056919061165c565b81526020019081526020015f2060020154815260200162278d0060035f6001600654611082919061165c565b81526020019081526020015f206002015461109d919061160d565b9052600680545f9081526003602090815260408083208551815591850151600180840191909155948101516002928301559254808352918390209384015493015491517f629c7b02d1ce7802556d2aa33f6af027bafe0d096664562d0ecf40b6bdc33c8f93610b559386939293845260208401929092526040830152606082015260800190565b5f62278d00836001015414611164576276a70083600101541461115d5762ed4e00836001015414611156576004611167565b6003611167565b6002611167565b60015b60ff1690505f81845f015461117c9190611626565b90505f62278d008560010154611192919061163d565b90505f8186600501546111a5919061160d565b6111b090600161160d565b60058701549091505b8181116112da575f6111ca82611401565b9050861580156111da5750804210155b156111e557506112c8565b80886003015489600201546111fa919061160d565b11158015611229575080886003015489600101548a6002015461121d919061160d565b611227919061160d565b115b156112c657861561125c575f828152600460205260408120805487929061125190849061160d565b9091555061127f9050565b5f828152600460205260408120805487929061127990849061165c565b90915550505b5f82815260046020908152604091829020548251858152918201527f86dcf86b12dfeedea74ae9300dbdaa193bcce5809369c8177ea2f4eaaa65729b910160405180910390a15b505b806112d28161166f565b9150506111b9565b50505050505050565b6040516001600160a01b0383811660248301526044820183905261134291859182169063a9059cbb906064015b604051602081830303815290604052915060e01b6020820180516001600160e01b03838183161783525050505061146d565b505050565b5f546001600160a01b03163314610b715760405163118cdaa760e01b8152336004820152602401610414565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6040516001600160a01b0384811660248301528381166044830152606482018390526113fb9186918216906323b872dd90608401611310565b50505050565b5f600654821161142057505f9081526003602052604090206002015490565b5f805260036020527f3617319a054d772f909f7c479a2cebe5066e836a939412e32403c99029b92f015461145762278d0084611626565b611461908261160d565b9392505050565b919050565b5f5f60205f8451602086015f885af18061148c576040513d5f823e3d81fd5b50505f513d915081156114a35780600114156114b0565b6001600160a01b0384163b155b156113fb57604051635274afe760e01b81526001600160a01b0385166004820152602401610414565b5f602082840312156114e9575f5ffd5b5035919050565b5f5f60408385031215611501575f5ffd5b50508035926020909101359150565b80356001600160a01b0381168114611468575f5ffd5b5f60208284031215611536575f5ffd5b61146182611510565b602080825282518282018190525f918401906040840190835b818110156115b25783518051845260208101516020850152604081015160408501526060810151606085015260808101511515608085015260a081015160a08501525060c083019250602084019350600181019050611558565b509095945050505050565b5f5f604083850312156115ce575f5ffd5b6115d783611510565b946020939093013593505050565b634e487b7160e01b5f52603260045260245ffd5b634e487b7160e01b5f52601160045260245ffd5b80820180821115611620576116206115f9565b92915050565b8082028115828204841417611620576116206115f9565b5f8261165757634e487b7160e01b5f52601260045260245ffd5b500490565b81810381811115611620576116206115f9565b5f60018201611680576116806115f9565b506001019056fea26469706673582212208557c59427298dd0366d43c7b670b8ba75c1ef4f64e06f789d1f01b6661ba40b64736f6c634300081c0033",
      "head": null,
      "length": 11644,
      "tail": null,
      "truncated": false
    },
    "verified_source": false
  },
  "capability_graph": {
    "address": "0xf9742810d596769d6cb54799eb1e2ccda03aeb9c",

thinking
**Analyzing runtime bytecode calls**
exec
/bin/bash -lc "python - <<'PY'
import json
from binascii import unhexlify
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['analysis_artifact']['artifact_json']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bytecode=bytes.fromhex(code)
# opcode table
opnames = {i: f'PUSH{i-0x5f}' for i in range(0x60,0x80)}
opnames.update({i: f'DUP{i-0x7f}' for i in range(0x80,0x90)})
opnames.update({i: f'SWAP{i-0x8f}' for i in range(0x90,0xa0)})
opnames.update({i: f'LOG{i-0xa0}' for i in range(0xa0,0xa5)})
# base
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)

# disassemble around pc range

def disasm(start,end):
    pc=0
    out=[]
    while pc < len(bytecode):
        op=bytecode[pc]
        name=opnames.get(op, f'OP_{op:02x}')
        if pc>=start and pc<=end:
            if 0x60<=op<=0x7f:
                n=op-0x5f
                data=bytecode[pc+1:pc+1+n]
                out.append((pc,name,data.hex()))
                pc+=1+n
            else:
                out.append((pc,name,''))
                pc+=1
        else:
            if 0x60<=op<=0x7f:
                pc+=1+(op-0x5f)
            else:
                pc+=1
        if pc> end and pc>start:
            # but continue to ensure we don't miss mid push
            pass
    return out

for rng in [(1930,1985),(5230,5255)]:
    print('---',rng)
    for pc,name,data in disasm(*rng):
        if pc<rng[0] or pc>rng[1]:
            continue
        if data:
            print(f'{pc:04x} {name} 0x{data}')
        else:
            print(f'{pc:04x} {name}')
PY" in /tmp/codex-r1gek8w5 exited 1 in 32ms:
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
KeyError: 'runtime_bytecode'

thinking
**Inspecting JSON structure for keys**
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
print(j.keys())
PY" in /tmp/codex-r1gek8w5 succeeded in 29ms:
dict_keys(['analysis_artifact', 'analysis_run', 'artifact', 'capability_graph', 'detector_findings', 'heuristics_summary'])

thinking
**Exploring runtime_bytecode location**
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
print(j['analysis_run'].keys())
print(j['analysis_run'].get('runtime_bytecode', None) is not None)
print(j['analysis_run'].get('runtime_bytecode', {}).keys() if isinstance(j['analysis_run'].get('runtime_bytecode'), dict) else None)
PY" in /tmp/codex-r1gek8w5 succeeded in 29ms:
dict_keys(['address', 'block_number', 'chain_id', 'child_links', 'created_at', 'id', 'parent_links', 'status', 'updated_at'])
False
None

thinking
**Checking artifact keys for runtime_bytecode**
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
print(j['artifact'].keys())
print(j['artifact'].get('runtime_bytecode') is not None)
print(j['artifact'].get('runtime_bytecode', {}).keys() if isinstance(j['artifact'].get('runtime_bytecode'), dict) else None)
PY" in /tmp/codex-r1gek8w5 succeeded in 27ms:
dict_keys(['codehash', 'compiler_json', 'implementation_address', 'is_proxy', 'runtime_bytecode', 'verified_source'])
True
dict_keys(['full', 'head', 'length', 'tail', 'truncated'])

thinking
**Locating runtime bytecode**
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bytecode=bytes.fromhex(code)
# opcode table
opnames = {i: f'PUSH{i-0x5f}' for i in range(0x60,0x80)}
opnames.update({i: f'DUP{i-0x7f}' for i in range(0x80,0x90)})
opnames.update({i: f'SWAP{i-0x8f}' for i in range(0x90,0xa0)})
opnames.update({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)

def disasm(start,end):
    pc=0
    out=[]
    while pc < len(bytecode):
        op=bytecode[pc]
        name=opnames.get(op, f'OP_{op:02x}')
        if 0x60<=op<=0x7f:
            n=op-0x5f
            data=bytecode[pc+1:pc+1+n]
            if start<=pc<=end:
                out.append((pc,name,data.hex()))
            pc+=1+n
        else:
            if start<=pc<=end:
                out.append((pc,name,''))
            pc+=1
    return out

for rng in [(1930,1985),(5230,5255)]:
    print('---',rng)
    for pc,name,data in disasm(*rng):
        if data:
            print(f'{pc:04x} {name} 0x{data}')
        else:
            print(f'{pc:04x} {name}')
PY" in /tmp/codex-r1gek8w5 succeeded in 36ms:
--- (1930, 1985)
078a DUP2
078b MSTORE
078c PUSH1 0x40
078e DUP1
078f DUP4
0790 SHA3
0791 DUP10
0792 DUP5
0793 MSTORE
0794 SWAP1
0795 SWAP2
0796 MSTORE
0797 DUP1
0798 DUP3
0799 SHA3
079a DUP1
079b SLOAD
079c PUSH1 0xff
079e NOT

thinking
**Analyzing CALL instruction context**

I’m examining the call instructions at two program counters to understand their targets and parameters. Since calls rely on the stack without explicit symbolic analysis, I’m inferring possible token contract calls by inspecting surrounding opcodes, constants, and memory operations. I’m planning to expand disassembly ranges around these calls and look for PUSH20 constants nearby to identify token addresses or contract calls related to transfers. This should help clarify if these low-level calls correspond to safe ERC20 transfers or other operations.
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['artifact']['runtime_bytecode']['full'][2:]
bytecode=bytes.fromhex(code)
# opcode table
opnames = {i: f'PUSH{i-0x5f}' for i in range(0x60,0x80)}
opnames.update({i: f'DUP{i-0x7f}' for i in range(0x80,0x90)})
opnames.update({i: f'SWAP{i-0x8f}' for i in range(0x90,0xa0)})
opnames.update({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)

def disasm(start,end):
    pc=0
    out=[]
    while pc < len(bytecode):
        op=bytecode[pc]
        name=opnames.get(op, f'OP_{op:02x}')
        if 0x60<=op<=0x7f:
            n=op-0x5f
            data=bytecode[pc+1:pc+1+n]
            if start<=pc<=end:
                out.append((pc,name,data.hex()))
            pc+=1+n
        else:
            if start<=pc<=end:
                out.append((pc,name,''))
            pc+=1
    return out

start=0x740; end=0x820
for pc,name,data in disasm(start,end):
    if data:
        print(f'{pc:04x} {name} 0x{data}')
    else:
        print(f'{pc:04x} {name}')
PY" in /tmp/codex-r1gek8w5 succeeded in 43ms:
0740 PUSH1 0x03
0742 PUSH1 0x20
0744 MSTORE
0745 PUSH1 0x40
0747 DUP2
0748 SHA3
0749 DUP1
074a SLOAD
074b DUP6
074c SWAP3
074d SWAP1
074e PUSH2 0x0758
0751 SWAP1
0752 DUP5
0753 SWAP1
0754 PUSH2 0x165c
0757 JUMP
0758 JUMPDEST
0759 SWAP1
075a SWAP2

thinking
**Analyzing low-level call safety in reward claim**
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['artifact']['runtime_bytecode']['full'][2:]
bytecode=bytes.fromhex(code)
# opcode table
def opnames():
    opnames = {i: f'PUSH{i-0x5f}' for i in range(0x60,0x80)}
    opnames.update({i: f'DUP{i-0x7f}' for i in range(0x80,0x90)})
    opnames.update({i: f'SWAP{i-0x8f}' for i in range(0x90,0xa0)})
    opnames.update({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)
    return opnames
ops=opnames()

def disasm(start,end):
    pc=0
    out=[]
    while pc < len(bytecode):
        op=bytecode[pc]
        name=ops.get(op, f'OP_{op:02x}')
        if 0x60<=op<=0x7f:
            n=op-0x5f
            data=bytecode[pc+1:pc+1+n]
            if start<=pc<=end:
                out.append((pc,name,data.hex()))
            pc+=1+n
        else:
            if start<=pc<=end:
                out.append((pc,name,''))
            pc+=1
    return out

start=0x680; end=0x740
for pc,name,data in disasm(start,end):
    if data:
        print(f'{pc:04x} {name} 0x{data}')
    else:
        print(f'{pc:04x} {name}')
PY" in /tmp/codex-r1gek8w5 succeeded in 55ms:
0680 SWAP1
0681 SHA3
0682 SLOAD
0683 DUP1
0684 PUSH2 0x06cf
0687 JUMPI
0688 PUSH1 0x40
068a MLOAD
068b PUSH3 0x461bcd
068f PUSH1 0xe5
0691 SHL
0692 DUP2
0693 MSTORE
0694 PUSH1 0x20
0696 PUSH1 0x04
0698 DUP3
0699 ADD
069a MSTORE
069b PUSH1 0x1f
069d PUSH1 0x24

thinking
**Analyzing potential external call targets**

I'm piecing together whether the call targets are constant addresses or user-controlled, focusing on evidence from storage slots and call patterns. It looks like calls might target a constant reward token address, with some low-level calls resembling SafeERC20 transfers that handle return data checks, but I'll verify the return value handling in subsequent disassembly to be sure.
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['artifact']['runtime_bytecode']['full'][2:]
bytecode=bytes.fromhex(code)
# build op table
opnames = {i: f'PUSH{i-0x5f}' for i in range(0x60,0x80)}
opnames.update({i: f'DUP{i-0x7f}' for i in range(0x80,0x90)})
opnames.update({i: f'SWAP{i-0x8f}' for i in range(0x90,0xa0)})
opnames.update({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)

def disasm(start,end):
    pc=0
    out=[]
    while pc < len(bytecode):
        op=bytecode[pc]
        name=opnames.get(op, f'OP_{op:02x}')
        if 0x60<=op<=0x7f:
            n=op-0x5f
            data=bytecode[pc+1:pc+1+n]
            if start<=pc<=end:
                out.append((pc,name,data.hex()))
            pc+=1+n
        else:
            if start<=pc<=end:
                out.append((pc,name,''))
            pc+=1
    return out

start=0x7e0; end=0x84a
for pc,name,data in disasm(start,end):
    if data:
        print(f'{pc:04x} {name} 0x{data}')
    else:
        print(f'{pc:04x} {name}')
PY" in /tmp/codex-r1gek8w5 succeeded in 37ms:
07e0 JUMPDEST
07e1 PUSH1 0x60
07e3 SWAP2
07e4 POP
07e5 JUMPDEST
07e6 POP
07e7 POP
07e8 SWAP1
07e9 POP
07ea DUP1
07eb PUSH2 0x082c
07ee JUMPI
07ef PUSH1 0x40
07f1 MLOAD
07f2 PUSH3 0x461bcd
07f6 PUSH1 0xe5
07f8 SHL
07f9 DUP2
07fa MSTORE
07fb PUSH1 0x20

thinking
**Analyzing call success and revert logic**
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['artifact']['runtime_bytecode']['full'][2:]
bytecode=bytes.fromhex(code)
# opnames
opnames = {i: f'PUSH{i-0x5f}' for i in range(0x60,0x80)}
opnames.update({i: f'DUP{i-0x7f}' for i in range(0x80,0x90)})
opnames.update({i: f'SWAP{i-0x8f}' for i in range(0x90,0xa0)})
opnames.update({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)

def disasm(start,end):
    pc=0
    out=[]
    while pc < len(bytecode):
        op=bytecode[pc]
        name=opnames.get(op, f'OP_{op:02x}')
        if 0x60<=op<=0x7f:
            n=op-0x5f
            data=bytecode[pc+1:pc+1+n]
            if start<=pc<=end:
                out.append((pc,name,data.hex()))
            pc+=1+n
        else:
            if start<=pc<=end:
                out.append((pc,name,''))
            pc+=1
    return out

for pc,name,data in disasm(0x1440,0x14b0):
    if data:
        print(f'{pc:04x} {name} 0x{data}')
    else:
        print(f'{pc:04x} {name}')
PY" in /tmp/codex-r1gek8w5 succeeded in 30ms:
144a SLOAD
144b PUSH2 0x1457
144e PUSH3 0x278d00
1452 DUP5
1453 PUSH2 0x1626
1456 JUMP
1457 JUMPDEST
1458 PUSH2 0x1461
145b SWAP1
145c DUP3
145d PUSH2 0x160d
1460 JUMP
1461 JUMPDEST
1462 SWAP4
1463 SWAP3
1464 POP
1465 POP
1466 POP
1467 JUMP
1468 JUMPDEST

thinking
**Analyzing CALL instructions and ETH value transfers**

I'm examining the safe token transfer helper using low-level CALL and extcodesize checks, trying to determine if and where ETH might be transferred via calls with nonzero value—especially around bytecode offset 0x7b2. Since the contract mostly rejects nonzero CALLVALUE, ETH may come from forced transfers or selfdestruct. To clarify if the CALL sends value or just token calls, I'm considering implementing symbolic stack tracking from function entry to CALL to see if the call value is truly zero or computed dynamically. This could reveal whether some calls send ETH out despite non-payable function constraints. I'll look for JUMPDEST markers near call to isolate the function for stack analysis.
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['artifact']['runtime_bytecode']['full'][2:]
bytecode=bytes.fromhex(code)
# find JUMPDESTs around 0x600-0x7b2
for pc,b in enumerate(bytecode):
    if b==0x5b and 0x600<=pc<=0x7b2:
        print(hex(pc))
PY" in /tmp/codex-r1gek8w5 succeeded in 39ms:
0x60d
0x617
0x61b
0x624
0x674
0x6cf
0x6ea
0x6f4
0x73b
0x758
0x77a

thinking
**Analyzing external calls and reentrancy risks**
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['artifact']['runtime_bytecode']['full']
print('a9059cbb' in code)
print('23b872dd' in code)
# find offsets of a9059cbb in bytecode
code_hex=code[2:]
idx=code_hex.find('a9059cbb')
print('idx', idx)
# convert hex index to pc (each byte 2 hex chars)
if idx"'!=-1:
    pc=idx//2
    print('"'pc', hex(pc))
# find other occurrences
start=0
while True:
    idx=code_hex.find('a9059cbb', start)
    if idx==-1: break
    print('pc', hex(idx//2))
    start=idx+1
PY" in /tmp/codex-r1gek8w5 succeeded in 29ms:
True
True
idx 9744
pc 0x1308
pc 0x1308

thinking
**Analyzing call locations for method selectors**
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code_hex=j['artifact']['runtime_bytecode']['full'][2:]
idx=code_hex.find('23b872dd')
print('idx', idx, 'pc', hex(idx//2))
PY" in /tmp/codex-r1gek8w5 succeeded in 31ms:
idx 10206 pc 0x13ef

thinking
**Analyzing suspicious CALL instruction**

I'm exploring the call at 0x7b2 that lacks a typical function selector, suspecting it might be transferring ETH directly rather than calling a token transfer function. To understand if the call targets the caller and to assess reentrancy risks, I'm planning a symbolic stack simulation from 0x73b to 0x7b2 to track stack contents like CALLER and call parameters, aiming to clarify the call's behavior despite complex control flow.
exec
/bin/bash -lc "python - <<'PY'
import json
j=json.load(open('/tmp/codex-r1gek8w5/BYTECODE_BUNDLE.json'))
code=j['artifact']['runtime_bytecode']['full'][2:]
bytecode=bytes.fromhex(code)
# decode opcodes between start and end
start=0x73b; end=0x7b2
# create disasm with pc
ops={}
# op length
pc=0
ops_list=[]
while pc < len(bytecode):
    op=bytecode[pc]
    name=None
    if 0x60<=op<=0x7f:
        n=op-0x5f
        data=bytecode[pc+1:pc+1+n]
        name=f'PUSH{n}'
        if start<=pc<=end:
            ops_list.append((pc,name,data))
        pc+=1+n
    else:
        name=op
        if start<=pc<=end:
            ops_list.append((pc,op,None))
        pc+=1

# map opcodes to names and stack effects
opname_map={
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',0xf1:'CALL'}

# Stack effect for subset
stack_effect={
'STOP':(0,0), 'ADD':(2,1), 'SUB':(2,1), 'MUL':(2,1), 'DIV':(2,1), 'MOD':(2,1),
'LT':(2,1), 'GT':(2,1), 'EQ':(2,1), 'ISZERO':(1,1), 'AND':(2,1), 'OR':(2,1), 'NOT':(1,1),
'SHL':(2,1), 'SHR':(2,1), 'SHA3':(2,1),
'POP':(1,0), 'MLOAD':(1,1), 'MSTORE':(2,0), 'SLOAD':(1,1), 'SSTORE':(2,0),
'JUMP':(1,0), 'JUMPI':(2,0), 'CALLER':(0,1), 'CALLVALUE':(0,1), 'CALLDATASIZE':(0,1), 'CALLDATALOAD':(1,1),
'GAS':(0,1), 'RETURNDATASIZE':(0,1), 'CALL':(7,1),
}
# DUP/SWAP effects
def is_dup(name):
    return name.startswith('DUP')
def is_swap(name):
    return name.startswith('SWAP')

# start with stack of unknowns size 12
stack=[f'unk{i}' for i in range(12)]  # bottom to top

# function to pop

def popn(n):
    global stack
    if n>len(stack):
        # extend with unknowns at bottom
        stack=[f'unkX{len(stack)+i}' for i in range(n-len(stack))]+stack
    vals=[stack.pop() for _ in range(n)]
    return vals

def push(v):
    stack.append(v)

# simulate
for pc,op,data in ops_list:
    if isinstance(op,str) and op.startswith('PUSH'):
        # push constant
        val=int.from_bytes(data,'big') if data else 0
        push(f'const({val})')
        continue
    name=opname_map.get(op, f'OP_{op:02x}')
    if name=='JUMPDEST':
        continue
    if is_dup(name):
        n=int(name[3:])
        if n>len(stack):
            stack=[f'unkX{len(stack)+i}' for i in range(n-len(stack))]+stack
        push(stack[-n])
        continue
    if is_swap(name):
        n=int(name[4:])
        if n>=len(stack):
            stack=[f'unkX{len(stack)+i}' for i in range(n-len(stack)+1)]+stack
        # swap top with nth element
        stack[-1],stack[-1-n]=stack[-1-n],stack[-1]
        continue
    if name=='CALLER':
        push('CALLER')
        continue
    # default stack effect
    popc,pushc=stack_effect.get(name,(0,0))
    if popc:
        vals=popn(popc)
    else:
        vals=[]
    # for some ops, output may depend; we mark unknown
    if pushc:
        if name in ('CALL','SLOAD','MLOAD','CALLDATALOAD'):
            push(f'{name}_ret')
        elif name=='GAS':
            push('GAS')
        elif name=='RETURNDATASIZE':
            push('RETURNDATASIZE')
        else:
            push(f'{name}_ret')
    # print at CALL
    if name=='CALL':
        # stack after call has success on top, but we care about inputs that were popped
        # vals contains popped items in order top-first (due to popn)
        # CALL pops: gas, to, value, in_offset, in_size, out_offset, out_size (top-first)
        labels=['gas','to','value','in_offset','in_size','out_offset','out_size']
        popped=list(vals)
        print('CALL at',hex(pc),'popped(top->bottom):',popped)
        # show mapping
        for lab,val in zip(labels,popped):
            print(' ',lab,':',val)
PY" in /tmp/codex-r1gek8w5 succeeded in 31ms:
CALL at 0x7b2 popped(top->bottom): ['GAS', 'MLOAD_ret', 'unkX6', 'unkX5', 'unkX4', 'unkX3', 'unkX2']
  gas : GAS
  to : MLOAD_ret
  value : unkX6
  in_offset : unkX5
  in_size : unkX4
  out_offset : unkX3
  out_size : unkX2

thinking
**Analyzing low-level CALL usage and risks**
codex
{"no_findings":false,"summary":"Bytecode shows low-level CALLs with computed targets/values and no explicit guard metadata; confidence is limited without source, so findings focus on potential unsafe external calls.","findings":[{"severity":"low","category":"other","title":"Low-level CALL with computed target/value may allow unintended external calls or ETH transfers","exploit_scenario":"If any public/external function can influence the CALL target or value (e.g., via calldata or mutable storage without strict access control), an attacker could trigger the CALL to an arbitrary address and/or send ETH out of the contract. This could be abused to drain ETH or execute unexpected external logic. Bytecode evidence is incomplete; the target might be a fixed token/known address and value might be zero in practice.","recommendation":"Confirm the CALL target is immutable or tightly validated, and ensure any setters are access-controlled. If ETH transfers are intended, use checks-effects-interactions (and/or a reentrancy guard) and validate return data where applicable.","evidence":"Detector flagged untrusted CALL target/value and possible ETH value transfer; callsites at pc 0x07b2 and 0x147c show computed target usage with CALL. No guards detected in heuristics for these sinks.","locations":["pc:0x7b2","pc:0x147c"]}]}
tokens used
87,186

{
    "codex": {
        "ran_at": "2026-01-12T18:51:48.577098+00:00",
        "returncode": 0
    },
    "project": {
        "mode": "bytecode",
        "bytecode_length": 11644,
        "bytecode_truncated": false,
        "capability_graph_present": true,
        "analysis_artifact_present": true
    },
    "summary": "Bytecode shows low-level CALLs with computed targets/values and no explicit guard metadata; confidence is limited without source, so findings focus on potential unsafe external calls.",
    "raw_final": {
        "summary": "Bytecode shows low-level CALLs with computed targets/values and no explicit guard metadata; confidence is limited without source, so findings focus on potential unsafe external calls.",
        "findings": [
            {
                "title": "Low-level CALL with computed target/value may allow unintended external calls or ETH transfers",
                "category": "other",
                "evidence": "Detector flagged untrusted CALL target/value and possible ETH value transfer; callsites at pc 0x07b2 and 0x147c show computed target usage with CALL. No guards detected in heuristics for these sinks.",
                "severity": "low",
                "locations": [
                    "pc:0x7b2",
                    "pc:0x147c"
                ],
                "recommendation": "Confirm the CALL target is immutable or tightly validated, and ensure any setters are access-controlled. If ETH transfers are intended, use checks-effects-interactions (and/or a reentrancy guard) and validate return data where applicable.",
                "exploit_scenario": "If any public/external function can influence the CALL target or value (e.g., via calldata or mutable storage without strict access control), an attacker could trigger the CALL to an arbitrary address and/or send ETH out of the contract. This could be abused to drain ETH or execute unexpected external logic. Bytecode evidence is incomplete; the target might be a fixed token/known address and value might be zero in practice."
            }
        ],
        "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 0x00fa
0000000c: JUMPI
0000000d: PUSH0
0000000e: CALLDATALOAD
0000000f: PUSH1 0xe0
00000011: SHR
00000012: DUP1
00000013: PUSH4 0x8252097d
00000018: GT
00000019: PUSH2 0x0092
0000001c: JUMPI
0000001d: DUP1
0000001e: PUSH4 0xb2931096
00000023: GT
00000024: PUSH2 0x0062
00000027: JUMPI
00000028: DUP1
00000029: PUSH4 0xb2931096
0000002e: EQ
0000002f: PUSH2 0x02c8
00000032: JUMPI
00000033: DUP1
00000034: PUSH4 0xb5d5b5fa
00000039: EQ
0000003a: PUSH2 0x0311
0000003d: JUMPI
0000003e: DUP1
0000003f: PUSH4 0xb62e1efc
00000044: EQ
00000045: PUSH2 0x035f
00000048: JUMPI
00000049: DUP1
0000004a: PUSH4 0xdc8d31b6
0000004f: EQ
00000050: PUSH2 0x038a
00000053: JUMPI
00000054: DUP1
00000055: PUSH4 0xf2fde38b
0000005a: EQ
0000005b: PUSH2 0x039f
0000005e: JUMPI
0000005f: PUSH0
00000060: PUSH0
00000061: REVERT
00000062: JUMPDEST
00000063: DUP1
00000064: PUSH4 0x8252097d
00000069: EQ
0000006a: PUSH2 0x0218
0000006d: JUMPI
0000006e: DUP1
0000006f: PUSH4 0x842e2981
00000074: EQ
00000075: PUSH2 0x026d
00000078: JUMPI
00000079: DUP1
0000007a: PUSH4 0x8bdf67f2
0000007f: EQ
00000080: PUSH2 0x0299
00000083: JUMPI
00000084: DUP1
00000085: PUSH4 0x8da5cb5b
0000008a: EQ
0000008b: PUSH2 0x02ac
0000008e: JUMPI
0000008f: PUSH0
00000090: PUSH0
00000091: REVERT
00000092: JUMPDEST
00000093: DUP1
00000094: PUSH4 0x715018a6
00000099: GT
0000009a: PUSH2 0x00cd
0000009d: JUMPI
0000009e: DUP1
0000009f: PUSH4 0x715018a6
000000a4: EQ
000000a5: PUSH2 0x0185
000000a8: JUMPI
000000a9: DUP1
000000aa: PUSH4 0x71b63aae
000000af: EQ
000000b0: PUSH2 0x0199
000000b3: JUMPI
000000b4: DUP1
000000b5: PUSH4 0x7b0472f0
000000ba: EQ
000000bb: PUSH2 0x01e4
000000be: JUMPI
000000bf: DUP1
000000c0: PUSH4 0x817b1cd2
000000c5: EQ
000000c6: PUSH2 0x0203
000000c9: JUMPI
000000ca: PUSH0
000000cb: PUSH0
000000cc: REVERT
000000cd: JUMPDEST
000000ce: DUP1
000000cf: PUSH4 0x0962ef79
000000d4: EQ
000000d5: PUSH2 0x00fe
000000d8: JUMPI
000000d9: DUP1
000000da: PUSH4 0x0cc2b37e
000000df: EQ
000000e0: PUSH2 0x011f
000000e3: JUMPI
000000e4: DUP1
000000e5: PUSH4 0x2e17de78
000000ea: EQ
000000eb: PUSH2 0x0147
000000ee: JUMPI
000000ef: DUP1
000000f0: PUSH4 0x3c7d0d96
000000f5: EQ
000000f6: PUSH2 0x0166
000000f9: JUMPI
000000fa: JUMPDEST
000000fb: PUSH0
000000fc: PUSH0
000000fd: REVERT
000000fe: JUMPDEST
000000ff: CALLVALUE
00000100: DUP1
00000101: ISZERO
00000102: PUSH2 0x0109
00000105: JUMPI
00000106: PUSH0
00000107: PUSH0
00000108: REVERT
00000109: JUMPDEST
0000010a: POP
0000010b: PUSH2 0x011d
0000010e: PUSH2 0x0118
00000111: CALLDATASIZE
00000112: PUSH1 0x04
00000114: PUSH2 0x14d9
00000117: JUMP
00000118: JUMPDEST
00000119: PUSH2 0x03be
0000011c: JUMP
0000011d: JUMPDEST
0000011e: STOP
0000011f: JUMPDEST
00000120: CALLVALUE
00000121: DUP1
00000122: ISZERO
00000123: PUSH2 0x012a
00000126: JUMPI
00000127: PUSH0
00000128: PUSH0
00000129: REVERT
0000012a: JUMPDEST
0000012b: POP
0000012c: PUSH2 0x0134
0000012f: PUSH1 0x06
00000131: SLOAD
00000132: DUP2
00000133: JUMP
00000134: JUMPDEST
00000135: PUSH1 0x40
00000137: MLOAD
00000138: SWAP1
00000139: DUP2
0000013a: MSTORE
0000013b: PUSH1 0x20
0000013d: ADD
0000013e: JUMPDEST
0000013f: PUSH1 0x40
00000141: MLOAD
00000142: DUP1
00000143: SWAP2
00000144: SUB
00000145: SWAP1
00000146: RETURN
00000147: JUMPDEST
00000148: CALLVALUE
00000149: DUP1
0000014a: ISZERO
0000014b: PUSH2 0x0152
0000014e: JUMPI
0000014f: PUSH0
00000150: PUSH0
00000151: REVERT
00000152: JUMPDEST
00000153: POP
00000154: PUSH2 0x011d
00000157: PUSH2 0x0161
0000015a: CALLDATASIZE
0000015b: PUSH1 0x04
0000015d: PUSH2 0x14d9
00000160: JUMP
00000161: JUMPDEST
00000162: PUSH2 0x0878
00000165: JUMP
00000166: JUMPDEST
00000167: CALLVALUE
00000168: DUP1
00000169: ISZERO
0000016a: PUSH2 0x0171
0000016d: JUMPI
0000016e: PUSH0
0000016f: PUSH0
00000170: REVERT
00000171: JUMPDEST
00000172: POP
00000173: PUSH2 0x011d
00000176: PUSH2 0x0180
00000179: CALLDATASIZE
0000017a: PUSH1 0x04
0000017c: PUSH2 0x14d9
0000017f: JUMP
00000180: JUMPDEST
00000181: PUSH2 0x0ac1
00000184: JUMP
00000185: JUMPDEST
00000186: CALLVALUE
00000187: DUP1
00000188: ISZERO
00000189: PUSH2 0x0190
0000018c: JUMPI
0000018d: PUSH0
0000018e: PUSH0
0000018f: REVERT
00000190: JUMPDEST
00000191: POP
00000192: PUSH2 0x011d
00000195: PUSH2 0x0b60
00000198: JUMP
00000199: JUMPDEST
0000019a: CALLVALUE
0000019b: DUP1
0000019c: ISZERO
0000019d: PUSH2 0x01a4
000001a0: JUMPI
000001a1: PUSH0
000001a2: PUSH0
000001a3: REVERT
000001a4: JUMPDEST
000001a5: POP
000001a6: PUSH2 0x01cc
000001a9: PUSH32 0x000000000000000000000000f94e7d0710709388bce3161c32b4eea56d3f91cc
000001ca: DUP2
000001cb: JUMP
000001cc: JUMPDEST
000001cd: PUSH1 0x40
000001cf: MLOAD
000001d0: PUSH1 0x01
000001d2: PUSH1 0x01
000001d4: PUSH1 0xa0
000001d6: SHL
000001d7: SUB
000001d8: SWAP1
000001d9: SWAP2
000001da: AND
000001db: DUP2
000001dc: MSTORE
000001dd: PUSH1 0x20
000001df: ADD
000001e0: PUSH2 0x013e
000001e3: JUMP
000001e4: JUMPDEST
000001e5: CALLVALUE
000001e6: DUP1
000001e7: ISZERO
000001e8: PUSH2 0x01ef
000001eb: JUMPI
000001ec: PUSH0
000001ed: PUSH0
000001ee: REVERT
000001ef: JUMPDEST
000001f0: POP
000001f1: PUSH2 0x011d
000001f4: PUSH2 0x01fe
000001f7: CALLDATASIZE
000001f8: PUSH1 0x04
000001fa: PUSH2 0x14f0
000001fd: JUMP
000001fe: JUMPDEST
000001ff: PUSH2 0x0b73
00000202: JUMP
00000203: JUMPDEST
00000204: CALLVALUE
00000205: DUP1
00000206: ISZERO
00000207: PUSH2 0x020e
0000020a: JUMPI
0000020b: PUSH0
0000020c: PUSH0
0000020d: REVERT
0000020e: JUMPDEST
0000020f: POP
00000210: PUSH2 0x0134
00000213: PUSH1 0x07
00000215: SLOAD
00000216: DUP2
00000217: JUMP
00000218: JUMPDEST
00000219: CALLVALUE
0000021a: DUP1
0000021b: ISZERO
0000021c: PUSH2 0x0223
0000021f: JUMPI
00000220: PUSH0
00000221: PUSH0
00000222: REVERT
00000223: JUMPDEST
00000224: POP
00000225: PUSH2 0x0252
00000228: PUSH2 0x0232
0000022b: CALLDATASIZE
0000022c: PUSH1 0x04
0000022e: PUSH2 0x14d9
00000231: JUMP
00000232: JUMPDEST
00000233: PUSH1 0x03
00000235: PUSH1 0x20
00000237: MSTORE
00000238: PUSH0
00000239: SWAP1
0000023a: DUP2
0000023b: MSTORE
0000023c: PUSH1 0x40
0000023e: SWAP1
0000023f: KECCAK256
00000240: DUP1
00000241: SLOAD
00000242: PUSH1 0x01
00000244: DUP3
00000245: ADD
00000246: SLOAD
00000247: PUSH1 0x02
00000249: SWAP1
0000024a: SWAP3
0000024b: ADD
0000024c: SLOAD
0000024d: SWAP1
0000024e: SWAP2
0000024f: SWAP1
00000250: DUP4
00000251: JUMP
00000252: JUMPDEST
00000253: PUSH1 0x40
00000255: DUP1
00000256: MLOAD
00000257: SWAP4
00000258: DUP5
00000259: MSTORE
0000025a: PUSH1 0x20
0000025c: DUP5
0000025d: ADD
0000025e: SWAP3
0000025f: SWAP1
00000260: SWAP3
00000261: MSTORE
00000262: SWAP1
00000263: DUP3
00000264: ADD
00000265: MSTORE
00000266: PUSH1 0x60
00000268: ADD
00000269: PUSH2 0x013e
0000026c: JUMP
0000026d: JUMPDEST
0000026e: CALLVALUE
0000026f: DUP1
00000270: ISZERO
00000271: PUSH2 0x0278
00000274: JUMPI
00000275: PUSH0
00000276: PUSH0
00000277: REVERT
00000278: JUMPDEST
00000279: POP
0000027a: PUSH2 0x028c
0000027d: PUSH2 0x0287
00000280: CALLDATASIZE
00000281: PUSH1 0x04
00000283: PUSH2 0x1526
00000286: JUMP
00000287: JUMPDEST
00000288: PUSH2 0x0da9
0000028b: JUMP
0000028c: JUMPDEST
0000028d: PUSH1 0x40
0000028f: MLOAD
00000290: PUSH2 0x013e
00000293: SWAP2
00000294: SWAP1
00000295: PUSH2 0x153f
00000298: JUMP
00000299: JUMPDEST
0000029a: PUSH2 0x011d
0000029d: PUSH2 0x02a7
000002a0: CALLDATASIZE
000002a1: PUSH1 0x04
000002a3: PUSH2 0x14d9
000002a6: JUMP
000002a7: JUMPDEST
000002a8: PUSH2 0x0e57
000002ab: JUMP
000002ac: JUMPDEST
000002ad: CALLVALUE
000002ae: DUP1
000002af: ISZERO
000002b0: PUSH2 0x02b7
000002b3: JUMPI
000002b4: PUSH0
000002b5: PUSH0
000002b6: REVERT
000002b7: JUMPDEST
000002b8: POP
000002b9: PUSH0
000002ba: SLOAD
000002bb: PUSH1 0x01
000002bd: PUSH1 0x01
000002bf: PUSH1 0xa0
000002c1: SHL
000002c2: SUB
000002c3: AND
000002c4: PUSH2 0x01cc
000002c7: JUMP
000002c8: JUMPDEST
000002c9: CALLVALUE
000002ca: DUP1
000002cb: ISZERO
000002cc: PUSH2 0x02d3
000002cf: JUMPI
000002d0: PUSH0
000002d1: PUSH0
000002d2: REVERT
000002d3: JUMPDEST
000002d4: POP
000002d5: PUSH2 0x0301
000002d8: PUSH2 0x02e2
000002db: CALLDATASIZE
000002dc: PUSH1 0x04
000002de: PUSH2 0x15bd
000002e1: JUMP
000002e2: JUMPDEST
000002e3: PUSH1 0x05
000002e5: PUSH1 0x20
000002e7: SWAP1
000002e8: DUP2
000002e9: MSTORE
000002ea: PUSH0
000002eb: SWAP3
000002ec: DUP4
000002ed: MSTORE
000002ee: PUSH1 0x40
000002f0: DUP1
000002f1: DUP5
000002f2: KECCAK256
000002f3: SWAP1
000002f4: SWAP2
000002f5: MSTORE
000002f6: SWAP1
000002f7: DUP3
000002f8: MSTORE
000002f9: SWAP1
000002fa: KECCAK256
000002fb: SLOAD
000002fc: PUSH1 0xff
000002fe: AND
000002ff: DUP2
00000300: JUMP
00000301: JUMPDEST
00000302: PUSH1 0x40
00000304: MLOAD
00000305: SWAP1
00000306: ISZERO
00000307: ISZERO
00000308: DUP2
00000309: MSTORE
0000030a: PUSH1 0x20
0000030c: ADD
0000030d: PUSH2 0x013e
00000310: JUMP
00000311: JUMPDEST
00000312: CALLVALUE
00000313: DUP1
00000314: ISZERO
00000315: PUSH2 0x031c
00000318: JUMPI
00000319: PUSH0
0000031a: PUSH0
0000031b: REVERT
0000031c: JUMPDEST
0000031d: POP
0000031e: PUSH2 0x0330
00000321: PUSH2 0x032b
00000324: CALLDATASIZE
00000325: PUSH1 0x04
00000327: PUSH2 0x15bd
0000032a: JUMP
0000032b: JUMPDEST
0000032c: PUSH2 0x0f49
0000032f: JUMP
00000330: JUMPDEST
00000331: PUSH1 0x40
00000333: DUP1
00000334: MLOAD
00000335: SWAP7
00000336: DUP8
00000337: MSTORE
00000338: PUSH1 0x20
0000033a: DUP8
0000033b: ADD
0000033c: SWAP6
0000033d: SWAP1
0000033e: SWAP6
0000033f: MSTORE
00000340: SWAP4
00000341: DUP6
00000342: ADD
00000343: SWAP3
00000344: SWAP1
00000345: SWAP3
00000346: MSTORE
00000347: PUSH1 0x60
00000349: DUP5
0000034a: ADD
0000034b: MSTORE
0000034c: ISZERO
0000034d: ISZERO
0000034e: PUSH1 0x80
00000350: DUP4
00000351: ADD
00000352: MSTORE
00000353: PUSH1 0xa0
00000355: DUP3
00000356: ADD
00000357: MSTORE
00000358: PUSH1 0xc0
0000035a: ADD
0000035b: PUSH2 0x013e
0000035e: JUMP
0000035f: JUMPDEST
00000360: CALLVALUE
00000361: DUP1
00000362: ISZERO
00000363: PUSH2 0x036a
00000366: JUMPI
00000367: PUSH0
00000368: PUSH0
00000369: REVERT
0000036a: JUMPDEST
0000036b: POP
0000036c: PUSH2 0x0134
0000036f: PUSH2 0x0379
00000372: CALLDATASIZE
00000373: PUSH1 0x04
00000375: PUSH2 0x14d9
00000378: JUMP
00000379: JUMPDEST
0000037a: PUSH1 0x04
0000037c: PUSH1 0x20
0000037e: MSTORE
0000037f: PUSH0
00000380: SWAP1
00000381: DUP2
00000382: MSTORE
00000383: PUSH1 0x40
00000385: SWAP1
00000386: KECCAK256
00000387: SLOAD
00000388: DUP2
00000389: JUMP
0000038a: JUMPDEST
0000038b: CALLVALUE
0000038c: DUP1
0000038d: ISZERO
0000038e: PUSH2 0x0395
00000391: JUMPI
00000392: PUSH0
00000393: PUSH0
00000394: REVERT
00000395: JUMPDEST
00000396: POP
00000397: PUSH2 0x0134
0000039a: PUSH1 0x08
0000039c: SLOAD
0000039d: DUP2
0000039e: JUMP
0000039f: JUMPDEST
000003a0: CALLVALUE
000003a1: DUP1
000003a2: ISZERO
000003a3: PUSH2 0x03aa
000003a6: JUMPI
000003a7: PUSH0
000003a8: PUSH0
000003a9: REVERT
000003aa: JUMPDEST
000003ab: POP
000003ac: PUSH2 0x011d
000003af: PUSH2 0x03b9
000003b2: CALLDATASIZE
000003b3: PUSH1 0x04
000003b5: PUSH2 0x1526
000003b8: JUMP
000003b9: JUMPDEST
000003ba: PUSH2 0x0f9f
000003bd: JUMP
000003be: JUMPDEST
000003bf: PUSH2 0x03c6
000003c2: PUSH2 0x0fd9
000003c5: JUMP
000003c6: JUMPDEST
000003c7: PUSH2 0x03ce
000003ca: PUSH2 0x1003
000003cd: JUMP
000003ce: JUMPDEST
000003cf: PUSH1 0x06
000003d1: SLOAD
000003d2: DUP2
000003d3: GT
000003d4: ISZERO
000003d5: PUSH2 0x041d
000003d8: JUMPI
000003d9: PUSH1 0x40
000003db: MLOAD
000003dc: PUSH3 0x461bcd
000003e0: PUSH1 0xe5
000003e2: SHL
000003e3: DUP2
000003e4: MSTORE
000003e5: PUSH1 0x20
000003e7: PUSH1 0x04
000003e9: DUP3
000003ea: ADD
000003eb: MSTORE
000003ec: PUSH1 0x15
000003ee: PUSH1 0x24
000003f0: DUP3
000003f1: ADD
000003f2: MSTORE
000003f3: PUSH21 0x125b9d985b1a59081c995dd85c99081c195c9a5bd9
00000409: PUSH1 0x5a
0000040b: SHL
0000040c: PUSH1 0x44
0000040e: DUP3
0000040f: ADD
00000410: MSTORE
00000411: PUSH1 0x64
00000413: ADD
00000414: JUMPDEST
00000415: PUSH1 0x40
00000417: MLOAD
00000418: DUP1
00000419: SWAP2
0000041a: SUB
0000041b: SWAP1
0000041c: REVERT
0000041d: JUMPDEST
0000041e: PUSH0
0000041f: DUP2
00000420: DUP2
00000421: MSTORE
00000422: PUSH1 0x03
00000424: PUSH1 0x20
00000426: MSTORE
00000427: PUSH1 0x40
00000429: SWAP1
0000042a: KECCAK256
0000042b: PUSH1 0x02
0000042d: ADD
0000042e: SLOAD
0000042f: TIMESTAMP
00000430: LT
00000431: ISZERO
00000432: PUSH2 0x047d
00000435: JUMPI
00000436: PUSH1 0x40
00000438: MLOAD
00000439: PUSH3 0x461bcd
0000043d: PUSH1 0xe5
0000043f: SHL
00000440: DUP2
00000441: MSTORE
00000442: PUSH1 0x20
00000444: PUSH1 0x04
00000446: DUP3
00000447: ADD
00000448: MSTORE
00000449: PUSH1 0x17
0000044b: PUSH1 0x24
0000044d: DUP3
0000044e: ADD
0000044f: MSTORE
00000450: PUSH32 0x52657761726420706572696f64206e6f7420656e646564000000000000000000
00000471: PUSH1 0x44
00000473: DUP3
00000474: ADD
00000475: MSTORE
00000476: PUSH1 0x64
00000478: ADD
00000479: PUSH2 0x0414
0000047c: JUMP
0000047d: JUMPDEST
0000047e: CALLER
0000047f: PUSH0
00000480: SWAP1
00000481: DUP2
00000482: MSTORE
00000483: PUSH1 0x05
00000485: PUSH1 0x20
00000487: SWAP1
00000488: DUP2
00000489: MSTORE
0000048a: PUSH1 0x40
0000048c: DUP1
0000048d: DUP4
0000048e: KECCAK256
0000048f: DUP5
00000490: DUP5
00000491: MSTORE
00000492: SWAP1
00000493: SWAP2
00000494: MSTORE
00000495: SWAP1
00000496: KECCAK256
00000497: SLOAD
00000498: PUSH1 0xff
0000049a: AND
0000049b: ISZERO
0000049c: PUSH2 0x04e7
0000049f: JUMPI
000004a0: PUSH1 0x40
000004a2: MLOAD
000004a3: PUSH3 0x461bcd
000004a7: PUSH1 0xe5
000004a9: SHL
000004aa: DUP2
000004ab: MSTORE
000004ac: PUSH1 0x20
000004ae: PUSH1 0x04
000004b0: DUP3
000004b1: ADD
000004b2: MSTORE
000004b3: PUSH1 0x1f
000004b5: PUSH1 0x24
000004b7: DUP3
000004b8: ADD
000004b9: MSTORE
000004ba: PUSH32 0x5265776172647320636c61696d656420666f72207468697320706572696f6400
000004db: PUSH1 0x44
000004dd: DUP3
000004de: ADD
000004df: MSTORE
000004e0: PUSH1 0x64
000004e2: ADD
000004e3: PUSH2 0x0414
000004e6: JUMP
000004e7: JUMPDEST
000004e8: CALLER
000004e9: PUSH0
000004ea: SWAP1
000004eb: DUP2
000004ec: MSTORE
000004ed: PUSH1 0x02
000004ef: PUSH1 0x20
000004f1: MSTORE
000004f2: PUSH1 0x40
000004f4: DUP2
000004f5: KECCAK256
000004f6: SLOAD
000004f7: DUP2
000004f8: SWAP1
000004f9: DUP2
000004fa: JUMPDEST
000004fb: DUP2
000004fc: DUP2
000004fd: LT
000004fe: ISZERO
000004ff: PUSH2 0x0624
00000502: JUMPI
00000503: CALLER
00000504: PUSH0
00000505: SWAP1
00000506: DUP2
00000507: MSTORE
00000508: PUSH1 0x02
0000050a: PUSH1 0x20
0000050c: MSTORE
0000050d: PUSH1 0x40
0000050f: DUP2
00000510: KECCAK256
00000511: DUP1
00000512: SLOAD
00000513: DUP4
00000514: SWAP1
00000515: DUP2
00000516: LT
00000517: PUSH2 0x0522
0000051a: JUMPI
0000051b: PUSH2 0x0522
0000051e: PUSH2 0x15e5
00000521: JUMP
00000522: JUMPDEST
00000523: PUSH0
00000524: SWAP2
00000525: DUP3
00000526: MSTORE
00000527: PUSH1 0x20
00000529: SWAP1
0000052a: SWAP2
0000052b: KECCAK256
0000052c: PUSH1 0x06
0000052e: SWAP1
0000052f: SWAP2
00000530: MUL
00000531: ADD
00000532: PUSH1 0x04
00000534: DUP2
00000535: ADD
00000536: SLOAD
00000537: SWAP1
00000538: SWAP2
00000539: POP
0000053a: PUSH1 0xff
0000053c: AND
0000053d: ISZERO
0000053e: DUP1
0000053f: ISZERO
00000540: PUSH2 0x0570
00000543: JUMPI
00000544: POP
00000545: PUSH1 0x03
00000547: PUSH0
00000548: DUP8
00000549: DUP2
0000054a: MSTORE
0000054b: PUSH1 0x20
0000054d: ADD
0000054e: SWAP1
0000054f: DUP2
00000550: MSTORE
00000551: PUSH1 0x20
00000553: ADD
00000554: PUSH0
00000555: KECCAK256
00000556: PUSH1 0x02
00000558: ADD
00000559: SLOAD
0000055a: DUP2
0000055b: PUSH1 0x03
0000055d: ADD
0000055e: SLOAD
0000055f: DUP3
00000560: PUSH1 0x02
00000562: ADD
00000563: SLOAD
00000564: PUSH2 0x056d
00000567: SWAP2
00000568: SWAP1
00000569: PUSH2 0x160d
0000056c: JUMP
0000056d: JUMPDEST
0000056e: GT
0000056f: ISZERO
00000570: JUMPDEST
00000571: DUP1
00000572: ISZERO
00000573: PUSH2 0x05b1
00000576: JUMPI
00000577: POP
00000578: PUSH1 0x03
0000057a: PUSH0
0000057b: DUP8
0000057c: DUP2
0000057d: MSTORE
0000057e: PUSH1 0x20
00000580: ADD
00000581: SWAP1
00000582: DUP2
00000583: MSTORE
00000584: PUSH1 0x20
00000586: ADD
00000587: PUSH0
00000588: KECCAK256
00000589: PUSH1 0x02
0000058b: ADD
0000058c: SLOAD
0000058d: DUP2
0000058e: PUSH1 0x03
00000590: ADD
00000591: SLOAD
00000592: DUP3
00000593: PUSH1 0x01
00000595: ADD
00000596: SLOAD
00000597: DUP4
00000598: PUSH1 0x02
0000059a: ADD
0000059b: SLOAD
0000059c: PUSH2 0x05a5
0000059f: SWAP2
000005a0: SWAP1
000005a1: PUSH2 0x160d
000005a4: JUMP
000005a5: JUMPDEST
000005a6: PUSH2 0x05af
000005a9: SWAP2
000005aa: SWAP1
000005ab: PUSH2 0x160d
000005ae: JUMP
000005af: JUMPDEST
000005b0: GT
000005b1: JUMPDEST
000005b2: ISZERO
000005b3: PUSH2 0x061b
000005b6: JUMPI
000005b7: PUSH0
000005b8: PUSH3 0x278d00
000005bc: DUP3
000005bd: PUSH1 0x01
000005bf: ADD
000005c0: SLOAD
000005c1: EQ
000005c2: PUSH2 0x05f6
000005c5: JUMPI
000005c6: PUSH3 0x76a700
000005ca: DUP3
000005cb: PUSH1 0x01
000005cd: ADD
000005ce: SLOAD
000005cf: EQ
000005d0: PUSH2 0x05ef
000005d3: JUMPI
000005d4: PUSH3 0xed4e00
000005d8: DUP3
000005d9: PUSH1 0x01
000005db: ADD
000005dc: SLOAD
000005dd: EQ
000005de: PUSH2 0x05e8
000005e1: JUMPI
000005e2: PUSH1 0x04
000005e4: PUSH2 0x05f9
000005e7: JUMP
000005e8: JUMPDEST
000005e9: PUSH1 0x03
000005eb: PUSH2 0x05f9
000005ee: JUMP
000005ef: JUMPDEST
000005f0: PUSH1 0x02
000005f2: PUSH2 0x05f9
000005f5: JUMP
000005f6: JUMPDEST
000005f7: PUSH1 0x01
000005f9: JUMPDEST
000005fa: PUSH1 0xff
000005fc: AND
000005fd: SWAP1
000005fe: POP
000005ff: DUP1
00000600: DUP3
00000601: PUSH0
00000602: ADD
00000603: SLOAD
00000604: PUSH2 0x060d
00000607: SWAP2
00000608: SWAP1
00000609: PUSH2 0x1626
0000060c: JUMP
0000060d: JUMPDEST
0000060e: PUSH2 0x0617
00000611: SWAP1
00000612: DUP8
00000613: PUSH2 0x160d
00000616: JUMP
00000617: JUMPDEST
00000618: SWAP6
00000619: POP
0000061a: POP
0000061b: JUMPDEST
0000061c: POP
0000061d: PUSH1 0x01
0000061f: ADD
00000620: PUSH2 0x04fa
00000623: JUMP
00000624: JUMPDEST
00000625: POP
00000626: PUSH0
00000627: DUP4
00000628: GT
00000629: PUSH2 0x0674
0000062c: JUMPI
0000062d: PUSH1 0x40
0000062f: MLOAD
00000630: PUSH3 0x461bcd
00000634: PUSH1 0xe5
00000636: SHL
00000637: DUP2
00000638: MSTORE
00000639: PUSH1 0x20
0000063b: PUSH1 0x04
0000063d: DUP3
0000063e: ADD
0000063f: MSTORE
00000640: PUSH1 0x1e
00000642: PUSH1 0x24
00000644: DUP3
00000645: ADD
00000646: MSTORE
00000647: PUSH32 0x4e6f20656c696769626c65207374616b657320666f7220726577617264730000
00000668: PUSH1 0x44
0000066a: DUP3
0000066b: ADD
0000066c: MSTORE
0000066d: PUSH1 0x64
0000066f: ADD
00000670: PUSH2 0x0414
00000673: JUMP
00000674: JUMPDEST
00000675: PUSH0
00000676: DUP5
00000677: DUP2
00000678: MSTORE
00000679: PUSH1 0x04
0000067b: PUSH1 0x20
0000067d: MSTORE
0000067e: PUSH1 0x40
00000680: SWAP1
00000681: KECCAK256
00000682: SLOAD
00000683: DUP1
00000684: PUSH2 0x06cf
00000687: JUMPI
00000688: PUSH1 0x40
0000068a: MLOAD
0000068b: PUSH3 0x461bcd
0000068f: PUSH1 0xe5
00000691: SHL
00000692: DUP2
00000693: MSTORE
00000694: PUSH1 0x20
00000696: PUSH1 0x04
00000698: DUP3
00000699: ADD
0000069a: MSTORE
0000069b: PUSH1 0x1f
0000069d: PUSH1 0x24
0000069f: DUP3
000006a0: ADD
000006a1: MSTORE
000006a2: PUSH32 0x52657761726420646973747269627574696f6e206e6f74207374617274656400
000006c3: PUSH1 0x44
000006c5: DUP3
000006c6: ADD
000006c7: MSTORE
000006c8: PUSH1 0x64
000006ca: ADD
000006cb: PUSH2 0x0414
000006ce: JUMP
000006cf: JUMPDEST
000006d0: PUSH0
000006d1: DUP6
000006d2: DUP2
000006d3: MSTORE
000006d4: PUSH1 0x03
000006d6: PUSH1 0x20
000006d8: MSTORE
000006d9: PUSH1 0x40
000006db: SWAP1
000006dc: KECCAK256
000006dd: SLOAD
000006de: DUP2
000006df: SWAP1
000006e0: PUSH2 0x06ea
000006e3: SWAP1
000006e4: DUP7
000006e5: SWAP1
000006e6: PUSH2 0x1626
000006e9: JUMP
000006ea: JUMPDEST
000006eb: PUSH2 0x06f4
000006ee: SWAP2
000006ef: SWAP1
000006f0: PUSH2 0x163d
000006f3: JUMP
000006f4: JUMPDEST
000006f5: SWAP3
000006f6: POP
000006f7: PUSH0
000006f8: DUP4
000006f9: GT
000006fa: PUSH2 0x073b
000006fd: JUMPI
000006fe: PUSH1 0x40
00000700: MLOAD
00000701: PUSH3 0x461bcd
00000705: PUSH1 0xe5
00000707: SHL
00000708: DUP2
00000709: MSTORE
0000070a: PUSH1 0x20
0000070c: PUSH1 0x04
0000070e: DUP3
0000070f: ADD
00000710: MSTORE
00000711: PUSH1 0x13
00000713: PUSH1 0x24
00000715: DUP3
00000716: ADD
00000717: MSTORE
00000718: PUSH19 0x4e6f207265776172647320746f20636c61696d
0000072c: PUSH1 0x68
0000072e: SHL
0000072f: PUSH1 0x44
00000731: DUP3
00000732: ADD
00000733: MSTORE
00000734: PUSH1 0x64
00000736: ADD
00000737: PUSH2 0x0414
0000073a: JUMP
0000073b: JUMPDEST
0000073c: PUSH0
0000073d: DUP6
0000073e: DUP2
0000073f: MSTORE
00000740: PUSH1 0x03
00000742: PUSH1 0x20
00000744: MSTORE
00000745: PUSH1 0x40
00000747: DUP2
00000748: KECCAK256
00000749: DUP1
0000074a: SLOAD
0000074b: DUP6
0000074c: SWAP3
0000074d: SWAP1
0000074e: PUSH2 0x0758
00000751: SWAP1
00000752: DUP5
00000753: SWAP1
00000754: PUSH2 0x165c
00000757: JUMP
00000758: JUMPDEST
00000759: SWAP1
0000075a: SWAP2
0000075b: SSTORE
0000075c: POP
0000075d: POP
0000075e: PUSH0
0000075f: DUP6
00000760: DUP2
00000761: MSTORE
00000762: PUSH1 0x04
00000764: PUSH1 0x20
00000766: MSTORE
00000767: PUSH1 0x40
00000769: DUP2
0000076a: KECCAK256
0000076b: DUP1
0000076c: SLOAD
0000076d: DUP7
0000076e: SWAP3
0000076f: SWAP1
00000770: PUSH2 0x077a
00000773: SWAP1
00000774: DUP5
00000775: SWAP1
00000776: PUSH2 0x165c
00000779: JUMP
0000077a: JUMPDEST
0000077b: SWAP1
0000077c: SWAP2
0000077d: SSTORE
0000077e: POP
0000077f: POP
00000780: CALLER
00000781: PUSH0
00000782: DUP2
00000783: DUP2
00000784: MSTORE
00000785: PUSH1 0x05
00000787: PUSH1 0x20
00000789: SWAP1
0000078a: DUP2
0000078b: MSTORE
0000078c: PUSH1 0x40
0000078e: DUP1
0000078f: DUP4
00000790: KECCAK256
00000791: DUP10
00000792: DUP5
00000793: MSTORE
00000794: SWAP1
00000795: SWAP2
00000796: MSTORE
00000797: DUP1
00000798: DUP3
00000799: KECCAK256
0000079a: DUP1
0000079b: SLOAD
0000079c: PUSH1 0xff
0000079e: NOT
0000079f: AND
000007a0: PUSH1 0x01
000007a2: OR
000007a3: SWAP1
000007a4: SSTORE
000007a5: MLOAD
000007a6: SWAP1
000007a7: SWAP2
000007a8: SWAP1
000007a9: DUP6
000007aa: SWAP1
000007ab: DUP4
000007ac: DUP2
000007ad: DUP2
000007ae: DUP2
000007af: DUP6
000007b0: DUP8
000007b1: GAS
000007b2: CALL
000007b3: SWAP3
000007b4: POP
000007b5: POP
000007b6: POP
000007b7: RETURNDATASIZE
000007b8: DUP1
000007b9: PUSH0
000007ba: DUP2
000007bb: EQ
000007bc: PUSH2 0x07e0
000007bf: JUMPI
000007c0: PUSH1 0x40
000007c2: MLOAD
000007c3: SWAP2
000007c4: POP
000007c5: PUSH1 0x1f
000007c7: NOT
000007c8: PUSH1 0x3f
000007ca: RETURNDATASIZE
000007cb: ADD
000007cc: AND
000007cd: DUP3
000007ce: ADD
000007cf: PUSH1 0x40
000007d1: MSTORE
000007d2: RETURNDATASIZE
000007d3: DUP3
000007d4: MSTORE
000007d5: RETURNDATASIZE
000007d6: PUSH0
000007d7: PUSH1 0x20
000007d9: DUP5
000007da: ADD
000007db: RETURNDATACOPY
000007dc: PUSH2 0x07e5
000007df: JUMP
000007e0: JUMPDEST
000007e1: PUSH1 0x60
000007e3: SWAP2
000007e4: POP
000007e5: JUMPDEST
000007e6: POP
000007e7: POP
000007e8: SWAP1
000007e9: POP
000007ea: DUP1
000007eb: PUSH2 0x082c
000007ee: JUMPI
000007ef: PUSH1 0x40
000007f1: MLOAD
000007f2: PUSH3 0x461bcd
000007f6: PUSH1 0xe5
000007f8: SHL
000007f9: DUP2
000007fa: MSTORE
000007fb: PUSH1 0x20
000007fd: PUSH1 0x04
000007ff: DUP3
00000800: ADD
00000801: MSTORE
00000802: PUSH1 0x13
00000804: PUSH1 0x24
00000806: DUP3
00000807: ADD
00000808: MSTORE
00000809: PUSH19 0x115512081d1c985b9cd9995c8819985a5b1959
0000081d: PUSH1 0x6a
0000081f: SHL
00000820: PUSH1 0x44
00000822: DUP3
00000823: ADD
00000824: MSTORE
00000825: PUSH1 0x64
00000827: ADD
00000828: PUSH2 0x0414
0000082b: JUMP
0000082c: JUMPDEST
0000082d: PUSH1 0x40
0000082f: DUP1
00000830: MLOAD
00000831: DUP8
00000832: DUP2
00000833: MSTORE
00000834: PUSH1 0x20
00000836: DUP2
00000837: ADD
00000838: DUP7
00000839: SWAP1
0000083a: MSTORE
0000083b: CALLER
0000083c: SWAP2
0000083d: PUSH32 0xf01da32686223933d8a18a391060918c7f11a3648639edd87ae013e2e2731743
0000085e: SWAP2
0000085f: ADD
00000860: PUSH1 0x40
00000862: MLOAD
00000863: DUP1
00000864: SWAP2
00000865: SUB
00000866: SWAP1
00000867: LOG2
00000868: POP
00000869: POP
0000086a: POP
0000086b: POP
0000086c: POP
0000086d: PUSH2 0x0875
00000870: PUSH1 0x01
00000872: DUP1
00000873: SSTORE
00000874: JUMP
00000875: JUMPDEST
00000876: POP
00000877: JUMP
00000878: JUMPDEST
00000879: PUSH2 0x0880
0000087c: PUSH2 0x0fd9
0000087f: JUMP
00000880: JUMPDEST
00000881: CALLER
00000882: PUSH0
00000883: SWAP1
00000884: DUP2
00000885: MSTORE
00000886: PUSH1 0x02
00000888: PUSH1 0x20
0000088a: MSTORE
0000088b: PUSH1 0x40
0000088d: SWAP1
0000088e: KECCAK256
0000088f: SLOAD
00000890: DUP2
00000891: LT
00000892: PUSH2 0x08d3
00000895: JUMPI
00000896: PUSH1 0x40
00000898: MLOAD
00000899: PUSH3 0x461bcd
0000089d: PUSH1 0xe5
0000089f: SHL
000008a0: DUP2
000008a1: MSTORE
000008a2: PUSH1 0x20
000008a4: PUSH1 0x04
000008a6: DUP3
000008a7: ADD
000008a8: MSTORE
000008a9: PUSH1 0x13
000008ab: PUSH1 0x24
000008ad: DUP3
000008ae: ADD
000008af: MSTORE
000008b0: PUSH19 0x092dcecc2d8d2c840e6e8c2d6ca40d2dcc8caf
000008c4: PUSH1 0x6b
000008c6: SHL
000008c7: PUSH1 0x44
000008c9: DUP3
000008ca: ADD
000008cb: MSTORE
000008cc: PUSH1 0x64
000008ce: ADD
000008cf: PUSH2 0x0414
000008d2: JUMP
000008d3: JUMPDEST
000008d4: CALLER
000008d5: PUSH0
000008d6: SWAP1
000008d7: DUP2
000008d8: MSTORE
000008d9: PUSH1 0x02
000008db: PUSH1 0x20
000008dd: MSTORE
000008de: PUSH1 0x40
000008e0: DUP2
000008e1: KECCAK256
000008e2: DUP1
000008e3: SLOAD
000008e4: DUP4
000008e5: SWAP1
000008e6: DUP2
000008e7: LT
000008e8: PUSH2 0x08f3
000008eb: JUMPI
000008ec: PUSH2 0x08f3
000008ef: PUSH2 0x15e5
000008f2: JUMP
000008f3: JUMPDEST
000008f4: PUSH0
000008f5: SWAP2
000008f6: DUP3
000008f7: MSTORE
000008f8: PUSH1 0x20
000008fa: SWAP1
000008fb: SWAP2
000008fc: KECCAK256
000008fd: PUSH1 0x06
000008ff: SWAP1
00000900: SWAP2
00000901: MUL
00000902: ADD
00000903: PUSH1 0x04
00000905: DUP2
00000906: ADD
00000907: SLOAD
00000908: SWAP1
00000909: SWAP2
0000090a: POP
0000090b: PUSH1 0xff
0000090d: AND
0000090e: ISZERO
0000090f: PUSH2 0x094e
00000912: JUMPI
00000913: PUSH1 0x40
00000915: MLOAD
00000916: PUSH3 0x461bcd
0000091a: PUSH1 0xe5
0000091c: SHL
0000091d: DUP2
0000091e: MSTORE
0000091f: PUSH1 0x20
00000921: PUSH1 0x04
00000923: DUP3
00000924: ADD
00000925: MSTORE
00000926: PUSH1 0x11
00000928: PUSH1 0x24
0000092a: DUP3
0000092b: ADD
0000092c: MSTORE
0000092d: PUSH17 0x20b63932b0b23c903bb4ba34323930bbb7
0000093f: PUSH1 0x79
00000941: SHL
00000942: PUSH1 0x44
00000944: DUP3
00000945: ADD
00000946: MSTORE
00000947: PUSH1 0x64
00000949: ADD
0000094a: PUSH2 0x0414
0000094d: JUMP
0000094e: JUMPDEST
0000094f: PUSH2 0x0958
00000952: DUP2
00000953: PUSH0
00000954: PUSH2 0x1124
00000957: JUMP
00000958: JUMPDEST
00000959: DUP1
0000095a: SLOAD
0000095b: PUSH1 0x01
0000095d: DUP3
0000095e: ADD
0000095f: SLOAD
00000960: PUSH1 0x02
00000962: DUP4
00000963: ADD
00000964: SLOAD
00000965: PUSH0
00000966: SWAP3
00000967: SWAP2
00000968: PUSH2 0x0970
0000096b: SWAP2
0000096c: PUSH2 0x160d
0000096f: JUMP
00000970: JUMPDEST
00000971: TIMESTAMP
00000972: LT
00000973: ISZERO
00000974: PUSH2 0x09d7
00000977: JUMPI
00000978: PUSH3 0x278d00
0000097c: DUP4
0000097d: PUSH1 0x01
0000097f: ADD
00000980: SLOAD
00000981: EQ
00000982: PUSH2 0x09b6
00000985: JUMPI
00000986: PUSH3 0x76a700
0000098a: DUP4
0000098b: PUSH1 0x01
0000098d: ADD
0000098e: SLOAD
0000098f: EQ
00000990: PUSH2 0x09af
00000993: JUMPI
00000994: PUSH3 0xed4e00
00000998: DUP4
00000999: PUSH1 0x01
0000099b: ADD
0000099c: SLOAD
0000099d: EQ
0000099e: PUSH2 0x09a8
000009a1: JUMPI
000009a2: PUSH1 0x0a
000009a4: PUSH2 0x09b9
000009a7: JUMP
000009a8: JUMPDEST
000009a9: PUSH1 0x0c
000009ab: PUSH2 0x09b9
000009ae: JUMP
000009af: JUMPDEST
000009b0: PUSH1 0x0d
000009b2: PUSH2 0x09b9
000009b5: JUMP
000009b6: JUMPDEST
000009b7: PUSH1 0x0f
000009b9: JUMPDEST
000009ba: PUSH1 0xff
000009bc: AND
000009bd: SWAP2
000009be: POP
000009bf: PUSH1 0x64
000009c1: PUSH2 0x09ca
000009c4: DUP4
000009c5: DUP4
000009c6: PUSH2 0x1626
000009c9: JUMP
000009ca: JUMPDEST
000009cb: PUSH2 0x09d4
000009ce: SWAP2
000009cf: SWAP1
000009d0: PUSH2 0x163d
000009d3: JUMP
000009d4: JUMPDEST
000009d5: SWAP2
000009d6: POP
000009d7: JUMPDEST
000009d8: PUSH0
000009d9: PUSH2 0x09e2
000009dc: DUP4
000009dd: DUP4
000009de: PUSH2 0x165c
000009e1: JUMP
000009e2: JUMPDEST
000009e3: SWAP1
000009e4: POP
000009e5: DUP2
000009e6: PUSH1 0x07
000009e8: PUSH0
000009e9: DUP3
000009ea: DUP3
000009eb: SLOAD
000009ec: PUSH2 0x09f5
000009ef: SWAP2
000009f0: SWAP1
000009f1: PUSH2 0x165c
000009f4: JUMP
000009f5: JUMPDEST
000009f6: SWAP1
000009f7: SWAP2
000009f8: SSTORE
000009f9: POP
000009fa: POP
000009fb: PUSH1 0x04
000009fd: DUP5
000009fe: ADD
000009ff: DUP1
00000a00: SLOAD
00000a01: PUSH1 0xff
00000a03: NOT
00000a04: AND
00000a05: PUSH1 0x01
00000a07: OR
00000a08: SWAP1
00000a09: SSTORE
00000a0a: DUP3
00000a0b: ISZERO
00000a0c: PUSH2 0x0a45
00000a0f: JUMPI
00000a10: PUSH2 0x0a45
00000a13: PUSH1 0x01
00000a15: PUSH1 0x01
00000a17: PUSH1 0xa0
00000a19: SHL
00000a1a: SUB
00000a1b: PUSH32 0x000000000000000000000000f94e7d0710709388bce3161c32b4eea56d3f91cc
00000a3c: AND
00000a3d: PUSH2 0xdead
00000a40: DUP6
00000a41: PUSH2 0x12e3
00000a44: JUMP
00000a45: JUMPDEST
00000a46: PUSH2 0x0a79
00000a49: PUSH1 0x01
00000a4b: PUSH1 0x01
00000a4d: PUSH1 0xa0
00000a4f: SHL
00000a50: SUB
00000a51: PUSH32 0x000000000000000000000000f94e7d0710709388bce3161c32b4eea56d3f91cc
00000a72: AND
00000a73: CALLER
00000a74: DUP4
00000a75: PUSH2 0x12e3
00000a78: JUMP
00000a79: JUMPDEST
00000a7a: PUSH1 0x40
00000a7c: DUP1
00000a7d: MLOAD
00000a7e: DUP4
00000a7f: DUP2
00000a80: MSTORE
00000a81: PUSH1 0x20
00000a83: DUP2
00000a84: ADD
00000a85: DUP6
00000a86: SWAP1
00000a87: MSTORE
00000a88: CALLER
00000a89: SWAP2
00000a8a: PUSH32 0x7fc4727e062e336010f2c282598ef5f14facb3de68cf8195c2f23e1454b2b74e
00000aab: SWAP2
00000aac: ADD
00000aad: PUSH1 0x40
00000aaf: MLOAD
00000ab0: DUP1
00000ab1: SWAP2
00000ab2: SUB
00000ab3: SWAP1
00000ab4: LOG2
00000ab5: POP
00000ab6: POP
00000ab7: POP
00000ab8: POP
00000ab9: PUSH2 0x0875
00000abc: PUSH1 0x01
00000abe: DUP1
00000abf: SSTORE
00000ac0: JUMP
00000ac1: JUMPDEST
00000ac2: PUSH2 0x0ac9
00000ac5: PUSH2 0x1347
00000ac8: JUMP
00000ac9: JUMPDEST
00000aca: PUSH3 0x069780
00000ace: DUP2
00000acf: LT
00000ad0: ISZERO
00000ad1: DUP1
00000ad2: ISZERO
00000ad3: PUSH2 0x0adf
00000ad6: JUMPI
00000ad7: POP
00000ad8: PUSH3 0x1a5e00
00000adc: DUP2
00000add: GT
00000ade: ISZERO
00000adf: JUMPDEST
00000ae0: PUSH2 0x0b24
00000ae3: JUMPI
00000ae4: PUSH1 0x40
00000ae6: MLOAD
00000ae7: PUSH3 0x461bcd
00000aeb: PUSH1 0xe5
00000aed: SHL
00000aee: DUP2
00000aef: MSTORE
00000af0: PUSH1 0x20
00000af2: PUSH1 0x04
00000af4: DUP3
00000af5: ADD
00000af6: MSTORE
00000af7: PUSH1 0x16
00000af9: PUSH1 0x24
00000afb: DUP3
00000afc: ADD
00000afd: MSTORE
00000afe: PUSH22 0x5468726573686f6c64206f7574206f662072616e6765
00000b15: PUSH1 0x50
00000b17: SHL
00000b18: PUSH1 0x44
00000b1a: DUP3
00000b1b: ADD
00000b1c: MSTORE
00000b1d: PUSH1 0x64
00000b1f: ADD
00000b20: PUSH2 0x0414
00000b23: JUMP
00000b24: JUMPDEST
00000b25: PUSH1 0x08
00000b27: DUP2
00000b28: SWAP1
00000b29: SSTORE
00000b2a: PUSH1 0x40
00000b2c: MLOAD
00000b2d: DUP2
00000b2e: DUP2
00000b2f: MSTORE
00000b30: PUSH32 0xadebce7a5ac7f8970d9f38c5d050b091f0210351f4dcf86301867a4214abfb92
00000b51: SWAP1
00000b52: PUSH1 0x20
00000b54: ADD
00000b55: JUMPDEST
00000b56: PUSH1 0x40
00000b58: MLOAD
00000b59: DUP1
00000b5a: SWAP2
00000b5b: SUB
00000b5c: SWAP1
00000b5d: LOG1
00000b5e: POP
00000b5f: JUMP
00000b60: JUMPDEST
00000b61: PUSH2 0x0b68
00000b64: PUSH2 0x1347
00000b67: JUMP
00000b68: JUMPDEST
00000b69: PUSH2 0x0b71
00000b6c: PUSH0
00000b6d: PUSH2 0x1373
00000b70: JUMP
00000b71: JUMPDEST
00000b72: JUMP
00000b73: JUMPDEST
00000b74: PUSH2 0x0b7b
00000b77: PUSH2 0x0fd9
00000b7a: JUMP
00000b7b: JUMPDEST
00000b7c: PUSH3 0x278d00
00000b80: DUP2
00000b81: EQ
00000b82: DUP1
00000b83: PUSH2 0x0b8e
00000b86: JUMPI
00000b87: POP
00000b88: PUSH3 0x76a700
00000b8c: DUP2
00000b8d: EQ
00000b8e: JUMPDEST
00000b8f: DUP1
00000b90: PUSH2 0x0b9b
00000b93: JUMPI
00000b94: POP
00000b95: PUSH3 0xed4e00
00000b99: DUP2
00000b9a: EQ
00000b9b: JUMPDEST
00000b9c: DUP1
00000b9d: PUSH2 0x0ba9
00000ba0: JUMPI
00000ba1: POP
00000ba2: PUSH4 0x01da9c00
00000ba7: DUP2
00000ba8: EQ
00000ba9: JUMPDEST
00000baa: PUSH2 0x0bee
00000bad: JUMPI
00000bae: PUSH1 0x40
00000bb0: MLOAD
00000bb1: PUSH3 0x461bcd
00000bb5: PUSH1 0xe5
00000bb7: SHL
00000bb8: DUP2
00000bb9: MSTORE
00000bba: PUSH1 0x20
00000bbc: PUSH1 0x04
00000bbe: DUP3
00000bbf: ADD
00000bc0: MSTORE
00000bc1: PUSH1 0x16
00000bc3: PUSH1 0x24
00000bc5: DUP3
00000bc6: ADD
00000bc7: MSTORE
00000bc8: PUSH22 0x125b9d985b1a59081b1bd8dacb5a5b881c195c9a5bd9
00000bdf: PUSH1 0x52
00000be1: SHL
00000be2: PUSH1 0x44
00000be4: DUP3
00000be5: ADD
00000be6: MSTORE
00000be7: PUSH1 0x64
00000be9: ADD
00000bea: PUSH2 0x0414
00000bed: JUMP
00000bee: JUMPDEST
00000bef: PUSH0
00000bf0: DUP3
00000bf1: GT
00000bf2: PUSH2 0x0c35
00000bf5: JUMPI
00000bf6: PUSH1 0x40
00000bf8: MLOAD
00000bf9: PUSH3 0x461bcd
00000bfd: PUSH1 0xe5
00000bff: SHL
00000c00: DUP2
00000c01: MSTORE
00000c02: PUSH1 0x20
00000c04: PUSH1 0x04
00000c06: DUP3
00000c07: ADD
00000c08: MSTORE
00000c09: PUSH1 0x15
00000c0b: PUSH1 0x24
00000c0d: DUP3
00000c0e: ADD
00000c0f: MSTORE
00000c10: PUSH21 0x10d85b9b9bdd081cdd185ad9480c08185b5bdd5b9d
00000c26: PUSH1 0x5a
00000c28: SHL
00000c29: PUSH1 0x44
00000c2b: DUP3
00000c2c: ADD
00000c2d: MSTORE
00000c2e: PUSH1 0x64
00000c30: ADD
00000c31: PUSH2 0x0414
00000c34: JUMP
00000c35: JUMPDEST
00000c36: PUSH2 0x0c6a
00000c39: PUSH1 0x01
00000c3b: PUSH1 0x01
00000c3d: PUSH1 0xa0
00000c3f: SHL
00000c40: SUB
00000c41: PUSH32 0x000000000000000000000000f94e7d0710709388bce3161c32b4eea56d3f91cc
00000c62: AND
00000c63: CALLER
00000c64: ADDRESS
00000c65: DUP6
00000c66: PUSH2 0x13c2
00000c69: JUMP
00000c6a: JUMPDEST
00000c6b: PUSH2 0x0c72
00000c6e: PUSH2 0x1003
00000c71: JUMP
00000c72: JUMPDEST
00000c73: CALLER
00000c74: PUSH0
00000c75: SWAP1
00000c76: DUP2
00000c77: MSTORE
00000c78: PUSH1 0x02
00000c7a: PUSH1 0x20
00000c7c: DUP2
00000c7d: DUP2
00000c7e: MSTORE
00000c7f: PUSH1 0x40
00000c81: DUP1
00000c82: DUP5
00000c83: KECCAK256
00000c84: DUP2
00000c85: MLOAD
00000c86: PUSH1 0xc0
00000c88: DUP2
00000c89: ADD
00000c8a: DUP4
00000c8b: MSTORE
00000c8c: DUP8
00000c8d: DUP2
00000c8e: MSTORE
00000c8f: DUP1
00000c90: DUP5
00000c91: ADD
00000c92: DUP8
00000c93: DUP2
00000c94: MSTORE
00000c95: TIMESTAMP
00000c96: SWAP4
00000c97: DUP3
00000c98: ADD
00000c99: SWAP4
00000c9a: DUP5
00000c9b: MSTORE
00000c9c: PUSH1 0x08
00000c9e: SLOAD
00000c9f: PUSH1 0x60
00000ca1: DUP4
00000ca2: ADD
00000ca3: SWAP1
00000ca4: DUP2
00000ca5: MSTORE
00000ca6: PUSH1 0x80
00000ca8: DUP4
00000ca9: ADD
00000caa: DUP9
00000cab: DUP2
00000cac: MSTORE
00000cad: PUSH1 0x06
00000caf: DUP1
00000cb0: SLOAD
00000cb1: PUSH1 0xa0
00000cb3: DUP7
00000cb4: ADD
00000cb5: SWAP1
00000cb6: DUP2
00000cb7: MSTORE
00000cb8: DUP7
00000cb9: SLOAD
00000cba: PUSH1 0x01
00000cbc: DUP1
00000cbd: DUP3
00000cbe: ADD
00000cbf: DUP10
00000cc0: SSTORE
00000cc1: SWAP8
00000cc2: DUP13
00000cc3: MSTORE
00000cc4: SWAP9
00000cc5: DUP12
00000cc6: KECCAK256
00000cc7: SWAP6
00000cc8: MLOAD
00000cc9: SWAP9
00000cca: SWAP1
00000ccb: SWAP2
00000ccc: MUL
00000ccd: SWAP1
00000cce: SWAP5
00000ccf: ADD
00000cd0: SWAP7
00000cd1: DUP8
00000cd2: SSTORE
00000cd3: SWAP2
00000cd4: MLOAD
00000cd5: SWAP4
00000cd6: DUP7
00000cd7: ADD
00000cd8: SWAP4
00000cd9: SWAP1
00000cda: SWAP4
00000cdb: SSTORE
00000cdc: SWAP3
00000cdd: MLOAD
00000cde: SWAP5
00000cdf: DUP5
00000ce0: ADD
00000ce1: SWAP5
00000ce2: SWAP1
00000ce3: SWAP5
00000ce4: SSTORE
00000ce5: MLOAD
00000ce6: PUSH1 0x03
00000ce8: DUP4
00000ce9: ADD
00000cea: SSTORE
00000ceb: MLOAD
00000cec: PUSH1 0x04
00000cee: DUP3
00000cef: ADD
00000cf0: DUP1
00000cf1: SLOAD
00000cf2: PUSH1 0xff
00000cf4: NOT
00000cf5: AND
00000cf6: SWAP2
00000cf7: ISZERO
00000cf8: ISZERO
00000cf9: SWAP2
00000cfa: SWAP1
00000cfb: SWAP2
00000cfc: OR
00000cfd: SWAP1
00000cfe: SSTORE
00000cff: SWAP1
00000d00: MLOAD
00000d01: PUSH1 0x05
00000d03: SWAP1
00000d04: SWAP2
00000d05: ADD
00000d06: SSTORE
00000d07: PUSH1 0x07
00000d09: DUP1
00000d0a: SLOAD
00000d0b: DUP5
00000d0c: SWAP3
00000d0d: SWAP1
00000d0e: PUSH2 0x0d18
00000d11: SWAP1
00000d12: DUP5
00000d13: SWAP1
00000d14: PUSH2 0x160d
00000d17: JUMP
00000d18: JUMPDEST
00000d19: SWAP1
00000d1a: SWAP2
00000d1b: SSTORE
00000d1c: POP
00000d1d: POP
00000d1e: CALLER
00000d1f: PUSH0
00000d20: SWAP1
00000d21: DUP2
00000d22: MSTORE
00000d23: PUSH1 0x02
00000d25: PUSH1 0x20
00000d27: MSTORE
00000d28: PUSH1 0x40
00000d2a: SWAP1
00000d2b: KECCAK256
00000d2c: DUP1
00000d2d: SLOAD
00000d2e: PUSH2 0x0d61
00000d31: SWAP2
00000d32: SWAP1
00000d33: PUSH2 0x0d3e
00000d36: SWAP1
00000d37: PUSH1 0x01
00000d39: SWAP1
00000d3a: PUSH2 0x165c
00000d3d: JUMP
00000d3e: JUMPDEST
00000d3f: DUP2
00000d40: SLOAD
00000d41: DUP2
00000d42: LT
00000d43: PUSH2 0x0d4e
00000d46: JUMPI
00000d47: PUSH2 0x0d4e
00000d4a: PUSH2 0x15e5
00000d4d: JUMP
00000d4e: JUMPDEST
00000d4f: SWAP1
00000d50: PUSH0
00000d51: MSTORE
00000d52: PUSH1 0x20
00000d54: PUSH0
00000d55: KECCAK256
00000d56: SWAP1
00000d57: PUSH1 0x06
00000d59: MUL
00000d5a: ADD
00000d5b: PUSH1 0x01
00000d5d: PUSH2 0x1124
00000d60: JUMP
00000d61: JUMPDEST
00000d62: PUSH1 0x40
00000d64: DUP1
00000d65: MLOAD
00000d66: DUP4
00000d67: DUP2
00000d68: MSTORE
00000d69: PUSH1 0x20
00000d6b: DUP2
00000d6c: ADD
00000d6d: DUP4
00000d6e: SWAP1
00000d6f: MSTORE
00000d70: CALLER
00000d71: SWAP2
00000d72: PUSH32 0x1449c6dd7851abc30abf37f57715f492010519147cc2652fbc38202c18a6ee90
00000d93: SWAP2
00000d94: ADD
00000d95: PUSH1 0x40
00000d97: MLOAD
00000d98: DUP1
00000d99: SWAP2
00000d9a: SUB
00000d9b: SWAP1
00000d9c: LOG2
00000d9d: PUSH2 0x0da5
00000da0: PUSH1 0x01
00000da2: DUP1
00000da3: SSTORE
00000da4: JUMP
00000da5: JUMPDEST
00000da6: POP
00000da7: POP
00000da8: JUMP
00000da9: JUMPDEST
00000daa: PUSH1 0x01
00000dac: PUSH1 0x01
00000dae: PUSH1 0xa0
00000db0: SHL
00000db1: SUB
00000db2: DUP2
00000db3: AND
00000db4: PUSH0
00000db5: SWAP1
00000db6: DUP2
00000db7: MSTORE
00000db8: PUSH1 0x02
00000dba: PUSH1 0x20
00000dbc: SWAP1
00000dbd: DUP2
00000dbe: MSTORE
00000dbf: PUSH1 0x40
00000dc1: DUP1
00000dc2: DUP4
00000dc3: KECCAK256
00000dc4: DUP1
00000dc5: SLOAD
00000dc6: DUP3
00000dc7: MLOAD
00000dc8: DUP2
00000dc9: DUP6
00000dca: MUL
00000dcb: DUP2
00000dcc: ADD
00000dcd: DUP6
00000dce: ADD
00000dcf: SWAP1
00000dd0: SWAP4
00000dd1: MSTORE
00000dd2: DUP1
00000dd3: DUP4
00000dd4: MSTORE
00000dd5: PUSH1 0x60
00000dd7: SWAP5
00000dd8: SWAP3
00000dd9: SWAP4
00000dda: SWAP2
00000ddb: SWAP3
00000ddc: SWAP1
00000ddd: SWAP2
00000dde: DUP5
00000ddf: ADD
00000de0: JUMPDEST
00000de1: DUP3
00000de2: DUP3
00000de3: LT
00000de4: ISZERO
00000de5: PUSH2 0x0e4c
00000de8: JUMPI
00000de9: PUSH0
00000dea: DUP5
00000deb: DUP2
00000dec: MSTORE
00000ded: PUSH1 0x20
00000def: SWAP1
00000df0: DUP2
00000df1: SWAP1
00000df2: KECCAK256
00000df3: PUSH1 0x40
00000df5: DUP1
00000df6: MLOAD
00000df7: PUSH1 0xc0
00000df9: DUP2
00000dfa: ADD
00000dfb: DUP3
00000dfc: MSTORE
00000dfd: PUSH1 0x06
00000dff: DUP7
00000e00: MUL
00000e01: SWAP1
00000e02: SWAP3
00000e03: ADD
00000e04: DUP1
00000e05: SLOAD
00000e06: DUP4
00000e07: MSTORE
00000e08: PUSH1 0x01
00000e0a: DUP1
00000e0b: DUP3
00000e0c: ADD
00000e0d: SLOAD
00000e0e: DUP5
00000e0f: DUP7
00000e10: ADD
00000e11: MSTORE
00000e12: PUSH1 0x02
00000e14: DUP3
00000e15: ADD
00000e16: SLOAD
00000e17: SWAP3
00000e18: DUP5
00000e19: ADD
00000e1a: SWAP3
00000e1b: SWAP1
00000e1c: SWAP3
00000e1d: MSTORE
00000e1e: PUSH1 0x03
00000e20: DUP2
00000e21: ADD
00000e22: SLOAD
00000e23: PUSH1 0x60
00000e25: DUP5
00000e26: ADD
00000e27: MSTORE
00000e28: PUSH1 0x04
00000e2a: DUP2
00000e2b: ADD
00000e2c: SLOAD
00000e2d: PUSH1 0xff
00000e2f: AND
00000e30: ISZERO
00000e31: ISZERO
00000e32: PUSH1 0x80
00000e34: DUP5
00000e35: ADD
00000e36: MSTORE
00000e37: PUSH1 0x05
00000e39: ADD
00000e3a: SLOAD
00000e3b: PUSH1 0xa0
00000e3d: DUP4
00000e3e: ADD
00000e3f: MSTORE
00000e40: SWAP1
00000e41: DUP4
00000e42: MSTORE
00000e43: SWAP1
00000e44: SWAP3
00000e45: ADD
00000e46: SWAP2
00000e47: ADD
00000e48: PUSH2 0x0de0
00000e4b: JUMP
00000e4c: JUMPDEST
00000e4d: POP
00000e4e: POP
00000e4f: POP
00000e50: POP
00000e51: SWAP1
00000e52: POP
00000e53: SWAP2
00000e54: SWAP1
00000e55: POP
00000e56: JUMP
00000e57: JUMPDEST
00000e58: PUSH2 0x0e5f
00000e5b: PUSH2 0x1347
00000e5e: JUMP
00000e5f: JUMPDEST
00000e60: PUSH2 0x0e67
00000e63: PUSH2 0x1003
00000e66: JUMP
00000e67: JUMPDEST
00000e68: PUSH0
00000e69: CALLVALUE
00000e6a: GT
00000e6b: PUSH2 0x0ea9
00000e6e: JUMPI
00000e6f: PUSH1 0x40
00000e71: MLOAD
00000e72: PUSH3 0x461bcd
00000e76: PUSH1 0xe5
00000e78: SHL
00000e79: DUP2
00000e7a: MSTORE
00000e7b: PUSH1 0x20
00000e7d: PUSH1 0x04
00000e7f: DUP3
00000e80: ADD
00000e81: MSTORE
00000e82: PUSH1 0x10
00000e84: PUSH1 0x24
00000e86: DUP3
00000e87: ADD
00000e88: MSTORE
00000e89: PUSH16 0x139bc81155120819195c1bdcda5d1959
00000e9a: PUSH1 0x82
00000e9c: SHL
00000e9d: PUSH1 0x44
00000e9f: DUP3
00000ea0: ADD
00000ea1: MSTORE
00000ea2: PUSH1 0x64
00000ea4: ADD
00000ea5: PUSH2 0x0414
00000ea8: JUMP
00000ea9: JUMPDEST
00000eaa: PUSH1 0x06
00000eac: SLOAD
00000ead: DUP2
00000eae: EQ
00000eaf: PUSH2 0x0ef2
00000eb2: JUMPI
00000eb3: PUSH1 0x40
00000eb5: MLOAD
00000eb6: PUSH3 0x461bcd
00000eba: PUSH1 0xe5
00000ebc: SHL
00000ebd: DUP2
00000ebe: MSTORE
00000ebf: PUSH1 0x20
00000ec1: PUSH1 0x04
00000ec3: DUP3
00000ec4: ADD
00000ec5: MSTORE
00000ec6: PUSH1 0x15
00000ec8: PUSH1 0x24
00000eca: DUP3
00000ecb: ADD
00000ecc: MSTORE
00000ecd: PUSH21 0x125b9d985b1a59081c995dd85c99081c195c9a5bd9
00000ee3: PUSH1 0x5a
00000ee5: SHL
00000ee6: PUSH1 0x44
00000ee8: DUP3
00000ee9: ADD
00000eea: MSTORE
00000eeb: PUSH1 0x64
00000eed: ADD
00000eee: PUSH2 0x0414
00000ef1: JUMP
00000ef2: JUMPDEST
00000ef3: PUSH0
00000ef4: DUP2
00000ef5: DUP2
00000ef6: MSTORE
00000ef7: PUSH1 0x03
00000ef9: PUSH1 0x20
00000efb: MSTORE
00000efc: PUSH1 0x40
00000efe: DUP2
00000eff: KECCAK256
00000f00: DUP1
00000f01: SLOAD
00000f02: CALLVALUE
00000f03: SWAP3
00000f04: SWAP1
00000f05: PUSH2 0x0f0f
00000f08: SWAP1
00000f09: DUP5
00000f0a: SWAP1
00000f0b: PUSH2 0x160d
00000f0e: JUMP
00000f0f: JUMPDEST
00000f10: SWAP1
00000f11: SWAP2
00000f12: SSTORE
00000f13: POP
00000f14: POP
00000f15: PUSH1 0x40
00000f17: DUP1
00000f18: MLOAD
00000f19: DUP3
00000f1a: DUP2
00000f1b: MSTORE
00000f1c: CALLVALUE
00000f1d: PUSH1 0x20
00000f1f: DUP3
00000f20: ADD
00000f21: MSTORE
00000f22: PUSH32 0xbf2ebcc991369bcf488ef5738352a5d8998bd7a2c138128ca91ec96afe123fd6
00000f43: SWAP2
00000f44: ADD
00000f45: PUSH2 0x0b55
00000f48: JUMP
00000f49: JUMPDEST
00000f4a: PUSH1 0x02
00000f4c: PUSH1 0x20
00000f4e: MSTORE
00000f4f: DUP2
00000f50: PUSH0
00000f51: MSTORE
00000f52: PUSH1 0x40
00000f54: PUSH0
00000f55: KECCAK256
00000f56: DUP2
00000f57: DUP2
00000f58: SLOAD
00000f59: DUP2
00000f5a: LT
00000f5b: PUSH2 0x0f62
00000f5e: JUMPI
00000f5f: PUSH0
00000f60: DUP1
00000f61: REVERT
00000f62: JUMPDEST
00000f63: PUSH0
00000f64: SWAP2
00000f65: DUP3
00000f66: MSTORE
00000f67: PUSH1 0x20
00000f69: SWAP1
00000f6a: SWAP2
00000f6b: KECCAK256
00000f6c: PUSH1 0x06
00000f6e: SWAP1
00000f6f: SWAP2
00000f70: MUL
00000f71: ADD
00000f72: DUP1
00000f73: SLOAD
00000f74: PUSH1 0x01
00000f76: DUP3
00000f77: ADD
00000f78: SLOAD
00000f79: PUSH1 0x02
00000f7b: DUP4
00000f7c: ADD
00000f7d: SLOAD
00000f7e: PUSH1 0x03
00000f80: DUP5
00000f81: ADD
00000f82: SLOAD
00000f83: PUSH1 0x04
00000f85: DUP6
00000f86: ADD
00000f87: SLOAD
00000f88: PUSH1 0x05
00000f8a: SWAP1
00000f8b: SWAP6
00000f8c: ADD
00000f8d: SLOAD
00000f8e: SWAP4
00000f8f: SWAP7
00000f90: POP
00000f91: SWAP2
00000f92: SWAP5
00000f93: POP
00000f94: SWAP3
00000f95: SWAP1
00000f96: SWAP2
00000f97: PUSH1 0xff
00000f99: SWAP1
00000f9a: SWAP2
00000f9b: AND
00000f9c: SWAP1
00000f9d: DUP7
00000f9e: JUMP
00000f9f: JUMPDEST
00000fa0: PUSH2 0x0fa7
00000fa3: PUSH2 0x1347
00000fa6: JUMP
00000fa7: JUMPDEST
00000fa8: PUSH1 0x01
00000faa: PUSH1 0x01
00000fac: PUSH1 0xa0
00000fae: SHL
00000faf: SUB
00000fb0: DUP2
00000fb1: AND
00000fb2: PUSH2 0x0fd0
00000fb5: JUMPI
00000fb6: PUSH1 0x40
00000fb8: MLOAD
00000fb9: PUSH4 0x1e4fbdf7
00000fbe: PUSH1 0xe0
00000fc0: SHL
00000fc1: DUP2
00000fc2: MSTORE
00000fc3: PUSH0
00000fc4: PUSH1 0x04
00000fc6: DUP3
00000fc7: ADD
00000fc8: MSTORE
00000fc9: PUSH1 0x24
00000fcb: ADD
00000fcc: PUSH2 0x0414
00000fcf: JUMP
00000fd0: JUMPDEST
00000fd1: PUSH2 0x0875
00000fd4: DUP2
00000fd5: PUSH2 0x1373
00000fd8: JUMP
00000fd9: JUMPDEST
00000fda: PUSH1 0x02
00000fdc: PUSH1 0x01
00000fde: SLOAD
00000fdf: SUB
00000fe0: PUSH2 0x0ffc
00000fe3: JUMPI
00000fe4: PUSH1 0x40
00000fe6: MLOAD
00000fe7: PUSH4 0x3ee5aeb5
00000fec: PUSH1 0xe0
00000fee: SHL
00000fef: DUP2
00000ff0: MSTORE
00000ff1: PUSH1 0x04
00000ff3: ADD
00000ff4: PUSH1 0x40
00000ff6: MLOAD
00000ff7: DUP1
00000ff8: SWAP2
00000ff9: SUB
00000ffa: SWAP1
00000ffb: REVERT
00000ffc: JUMPDEST
00000ffd: PUSH1 0x02
00000fff: PUSH1 0x01
00001001: SSTORE
00001002: JUMP
00001003: JUMPDEST
00001004: PUSH1 0x06
00001006: SLOAD
00001007: PUSH0
00001008: SWAP1
00001009: DUP2
0000100a: MSTORE
0000100b: PUSH1 0x03
0000100d: PUSH1 0x20
0000100f: MSTORE
00001010: PUSH1 0x40
00001012: SWAP1
00001013: KECCAK256
00001014: PUSH1 0x02
00001016: ADD
00001017: SLOAD
00001018: TIMESTAMP
00001019: LT
0000101a: PUSH2 0x0b71
0000101d: JUMPI
0000101e: PUSH1 0x06
00001020: DUP1
00001021: SLOAD
00001022: SWAP1
00001023: DUP2
00001024: SWAP1
00001025: PUSH0
00001026: PUSH2 0x102e
00001029: DUP4
0000102a: PUSH2 0x166f
0000102d: JUMP
0000102e: JUMPDEST
0000102f: SWAP2
00001030: SWAP1
00001031: POP
00001032: SSTORE
00001033: POP
00001034: PUSH1 0x40
00001036: MLOAD
00001037: DUP1
00001038: PUSH1 0x60
0000103a: ADD
0000103b: PUSH1 0x40
0000103d: MSTORE
0000103e: DUP1
0000103f: PUSH0
00001040: DUP2
00001041: MSTORE
00001042: PUSH1 0x20
00001044: ADD
00001045: PUSH1 0x03
00001047: PUSH0
00001048: PUSH1 0x01
0000104a: PUSH1 0x06
0000104c: SLOAD
0000104d: PUSH2 0x1056
00001050: SWAP2
00001051: SWAP1
00001052: PUSH2 0x165c
00001055: JUMP
00001056: JUMPDEST
00001057: DUP2
00001058: MSTORE
00001059: PUSH1 0x20
0000105b: ADD
0000105c: SWAP1
0000105d: DUP2
0000105e: MSTORE
0000105f: PUSH1 0x20
00001061: ADD
00001062: PUSH0
00001063: KECCAK256
00001064: PUSH1 0x02
00001066: ADD
00001067: SLOAD
00001068: DUP2
00001069: MSTORE
0000106a: PUSH1 0x20
0000106c: ADD
0000106d: PUSH3 0x278d00
00001071: PUSH1 0x03
00001073: PUSH0
00001074: PUSH1 0x01
00001076: PUSH1 0x06
00001078: SLOAD
00001079: PUSH2 0x1082
0000107c: SWAP2
0000107d: SWAP1
0000107e: PUSH2 0x165c
00001081: JUMP
00001082: JUMPDEST
00001083: DUP2
00001084: MSTORE
00001085: PUSH1 0x20
00001087: ADD
00001088: SWAP1
00001089: DUP2
0000108a: MSTORE
0000108b: PUSH1 0x20
0000108d: ADD
0000108e: PUSH0
0000108f: KECCAK256
00001090: PUSH1 0x02
00001092: ADD
00001093: SLOAD
00001094: PUSH2 0x109d
00001097: SWAP2
00001098: SWAP1
00001099: PUSH2 0x160d
0000109c: JUMP
0000109d: JUMPDEST
0000109e: SWAP1
0000109f: MSTORE
000010a0: PUSH1 0x06
000010a2: DUP1
000010a3: SLOAD
000010a4: PUSH0
000010a5: SWAP1
000010a6: DUP2
000010a7: MSTORE
000010a8: PUSH1 0x03
000010aa: PUSH1 0x20
000010ac: SWAP1
000010ad: DUP2
000010ae: MSTORE
000010af: PUSH1 0x40
000010b1: DUP1
000010b2: DUP4
000010b3: KECCAK256
000010b4: DUP6
000010b5: MLOAD
000010b6: DUP2
000010b7: SSTORE
000010b8: SWAP2
000010b9: DUP6
000010ba: ADD
000010bb: MLOAD
000010bc: PUSH1 0x01
000010be: DUP1
000010bf: DUP5
000010c0: ADD
000010c1: SWAP2
000010c2: SWAP1
000010c3: SWAP2
000010c4: SSTORE
000010c5: SWAP5
000010c6: DUP2
000010c7: ADD
000010c8: MLOAD
000010c9: PUSH1 0x02
000010cb: SWAP3
000010cc: DUP4
000010cd: ADD
000010ce: SSTORE
000010cf: SWAP3
000010d0: SLOAD
000010d1: DUP1
000010d2: DUP4
000010d3: MSTORE
000010d4: SWAP2
000010d5: DUP4
000010d6: SWAP1
000010d7: KECCAK256
000010d8: SWAP4
000010d9: DUP5
000010da: ADD
000010db: SLOAD
000010dc: SWAP4
000010dd: ADD
000010de: SLOAD
000010df: SWAP2
000010e0: MLOAD
000010e1: PUSH32 0x629c7b02d1ce7802556d2aa33f6af027bafe0d096664562d0ecf40b6bdc33c8f
00001102: SWAP4
00001103: PUSH2 0x0b55
00001106: SWAP4
00001107: DUP7
00001108: SWAP4
00001109: SWAP3
0000110a: SWAP4
0000110b: DUP5
0000110c: MSTORE
0000110d: PUSH1 0x20
0000110f: DUP5
00001110: ADD
00001111: SWAP3
00001112: SWAP1
00001113: SWAP3
00001114: MSTORE
00001115: PUSH1 0x40
00001117: DUP4
00001118: ADD
00001119: MSTORE
0000111a: PUSH1 0x60
0000111c: DUP3
0000111d: ADD
0000111e: MSTORE
0000111f: PUSH1 0x80
00001121: ADD
00001122: SWAP1
00001123: JUMP
00001124: JUMPDEST
00001125: PUSH0
00001126: PUSH3 0x278d00
0000112a: DUP4
0000112b: PUSH1 0x01
0000112d: ADD
0000112e: SLOAD
0000112f: EQ
00001130: PUSH2 0x1164
00001133: JUMPI
00001134: PUSH3 0x76a700
00001138: DUP4
00001139: PUSH1 0x01
0000113b: ADD
0000113c: SLOAD
0000113d: EQ
0000113e: PUSH2 0x115d
00001141: JUMPI
00001142: PUSH3 0xed4e00
00001146: DUP4
00001147: PUSH1 0x01
00001149: ADD
0000114a: SLOAD
0000114b: EQ
0000114c: PUSH2 0x1156
0000114f: JUMPI
00001150: PUSH1 0x04
00001152: PUSH2 0x1167
00001155: JUMP
00001156: JUMPDEST
00001157: PUSH1 0x03
00001159: PUSH2 0x1167
0000115c: JUMP
0000115d: JUMPDEST
0000115e: PUSH1 0x02
00001160: PUSH2 0x1167
00001163: JUMP
00001164: JUMPDEST
00001165: PUSH1 0x01
00001167: JUMPDEST
00001168: PUSH1 0xff
0000116a: AND
0000116b: SWAP1
0000116c: POP
0000116d: PUSH0
0000116e: DUP2
0000116f: DUP5
00001170: PUSH0
00001171: ADD
00001172: SLOAD
00001173: PUSH2 0x117c
00001176: SWAP2
00001177: SWAP1
00001178: PUSH2 0x1626
0000117b: JUMP
0000117c: JUMPDEST
0000117d: SWAP1
0000117e: POP
0000117f: PUSH0
00001180: PUSH3 0x278d00
00001184: DUP6
00001185: PUSH1 0x01
00001187: ADD
00001188: SLOAD
00001189: PUSH2 0x1192
0000118c: SWAP2
0000118d: SWAP1
0000118e: PUSH2 0x163d
00001191: JUMP
00001192: JUMPDEST
00001193: SWAP1
00001194: POP
00001195: PUSH0
00001196: DUP2
00001197: DUP7
00001198: PUSH1 0x05
0000119a: ADD
0000119b: SLOAD
0000119c: PUSH2 0x11a5
0000119f: SWAP2
000011a0: SWAP1
000011a1: PUSH2 0x160d
000011a4: JUMP
000011a5: JUMPDEST
000011a6: PUSH2 0x11b0
000011a9: SWAP1
000011aa: PUSH1 0x01
000011ac: PUSH2 0x160d
000011af: JUMP
000011b0: JUMPDEST
000011b1: PUSH1 0x05
000011b3: DUP8
000011b4: ADD
000011b5: SLOAD
000011b6: SWAP1
000011b7: SWAP2
000011b8: POP
000011b9: JUMPDEST
000011ba: DUP2
000011bb: DUP2
000011bc: GT
000011bd: PUSH2 0x12da
000011c0: JUMPI
000011c1: PUSH0
000011c2: PUSH2 0x11ca
000011c5: DUP3
000011c6: PUSH2 0x1401
000011c9: JUMP
000011ca: JUMPDEST
000011cb: SWAP1
000011cc: POP
000011cd: DUP7
000011ce: ISZERO
000011cf: DUP1
000011d0: ISZERO
000011d1: PUSH2 0x11da
000011d4: JUMPI
000011d5: POP
000011d6: DUP1
000011d7: TIMESTAMP
000011d8: LT
000011d9: ISZERO
000011da: JUMPDEST
000011db: ISZERO
000011dc: PUSH2 0x11e5
000011df: JUMPI
000011e0: POP
000011e1: PUSH2 0x12c8
000011e4: JUMP
000011e5: JUMPDEST
000011e6: DUP1
000011e7: DUP9
000011e8: PUSH1 0x03
000011ea: ADD
000011eb: SLOAD
000011ec: DUP10
000011ed: PUSH1 0x02
000011ef: ADD
000011f0: SLOAD
000011f1: PUSH2 0x11fa
000011f4: SWAP2
000011f5: SWAP1
000011f6: PUSH2 0x160d
000011f9: JUMP
000011fa: JUMPDEST
000011fb: GT
000011fc: ISZERO
000011fd: DUP1
000011fe: ISZERO
000011ff: PUSH2 0x1229
00001202: JUMPI
00001203: POP
00001204: DUP1
00001205: DUP9
00001206: PUSH1 0x03
00001208: ADD
00001209: SLOAD
0000120a: DUP10
0000120b: PUSH1 0x01
0000120d: ADD
0000120e: SLOAD
0000120f: DUP11
00001210: PUSH1 0x02
00001212: ADD
00001213: SLOAD
00001214: PUSH2 0x121d
00001217: SWAP2
00001218: SWAP1
00001219: PUSH2 0x160d
0000121c: JUMP
0000121d: JUMPDEST
0000121e: PUSH2 0x1227
00001221: SWAP2
00001222: SWAP1
00001223: PUSH2 0x160d
00001226: JUMP
00001227: JUMPDEST
00001228: GT
00001229: JUMPDEST
0000122a: ISZERO
0000122b: PUSH2 0x12c6
0000122e: JUMPI
0000122f: DUP7
00001230: ISZERO
00001231: PUSH2 0x125c
00001234: JUMPI
00001235: PUSH0
00001236: DUP3
00001237: DUP2
00001238: MSTORE
00001239: PUSH1 0x04
0000123b: PUSH1 0x20
0000123d: MSTORE
0000123e: PUSH1 0x40
00001240: DUP2
00001241: KECCAK256
00001242: DUP1
00001243: SLOAD
00001244: DUP8
00001245: SWAP3
00001246: SWAP1
00001247: PUSH2 0x1251
0000124a: SWAP1
0000124b: DUP5
0000124c: SWAP1
0000124d: PUSH2 0x160d
00001250: JUMP
00001251: JUMPDEST
00001252: SWAP1
00001253: SWAP2
00001254: SSTORE
00001255: POP
00001256: PUSH2 0x127f
00001259: SWAP1
0000125a: POP
0000125b: JUMP
0000125c: JUMPDEST
0000125d: PUSH0
0000125e: DUP3
0000125f: DUP2
00001260: MSTORE
00001261: PUSH1 0x04
00001263: PUSH1 0x20
00001265: MSTORE
00001266: PUSH1 0x40
00001268: DUP2
00001269: KECCAK256
0000126a: DUP1
0000126b: SLOAD
0000126c: DUP8
0000126d: SWAP3
0000126e: SWAP1
0000126f: PUSH2 0x1279
00001272: SWAP1
00001273: DUP5
00001274: SWAP1
00001275: PUSH2 0x165c
00001278: JUMP
00001279: JUMPDEST
0000127a: SWAP1
0000127b: SWAP2
0000127c: SSTORE
0000127d: POP
0000127e: POP
0000127f: JUMPDEST
00001280: PUSH0
00001281: DUP3
00001282: DUP2
00001283: MSTORE
00001284: PUSH1 0x04
00001286: PUSH1 0x20
00001288: SWAP1
00001289: DUP2
0000128a: MSTORE
0000128b: PUSH1 0x40
0000128d: SWAP2
0000128e: DUP3
0000128f: SWAP1
00001290: KECCAK256
00001291: SLOAD
00001292: DUP3
00001293: MLOAD
00001294: DUP6
00001295: DUP2
00001296: MSTORE
00001297: SWAP2
00001298: DUP3
00001299: ADD
0000129a: MSTORE
0000129b: PUSH32 0x86dcf86b12dfeedea74ae9300dbdaa193bcce5809369c8177ea2f4eaaa65729b
000012bc: SWAP2
000012bd: ADD
000012be: PUSH1 0x40
000012c0: MLOAD
000012c1: DUP1
000012c2: SWAP2
000012c3: SUB
000012c4: SWAP1
000012c5: LOG1
000012c6: JUMPDEST
000012c7: POP
000012c8: JUMPDEST
000012c9: DUP1
000012ca: PUSH2 0x12d2
000012cd: DUP2
000012ce: PUSH2 0x166f
000012d1: JUMP
000012d2: JUMPDEST
000012d3: SWAP2
000012d4: POP
000012d5: POP
000012d6: PUSH2 0x11b9
000012d9: JUMP
000012da: JUMPDEST
000012db: POP
000012dc: POP
000012dd: POP
000012de: POP
000012df: POP
000012e0: POP
000012e1: POP
000012e2: JUMP
000012e3: JUMPDEST
000012e4: PUSH1 0x40
000012e6: MLOAD
000012e7: PUSH1 0x01
000012e9: PUSH1 0x01
000012eb: PUSH1 0xa0
000012ed: SHL
000012ee: SUB
000012ef: DUP4
000012f0: DUP2
000012f1: AND
000012f2: PUSH1 0x24
000012f4: DUP4
000012f5: ADD
000012f6: MSTORE
000012f7: PUSH1 0x44
000012f9: DUP3
000012fa: ADD
000012fb: DUP4
000012fc: SWAP1
000012fd: MSTORE
000012fe: PUSH2 0x1342
00001301: SWAP2
00001302: DUP6
00001303: SWAP2
00001304: DUP3
00001305: AND
00001306: SWAP1
00001307: PUSH4 0xa9059cbb
0000130c: SWAP1
0000130d: PUSH1 0x64
0000130f: ADD
00001310: JUMPDEST
00001311: PUSH1 0x40
00001313: MLOAD
00001314: PUSH1 0x20
00001316: DUP2
00001317: DUP4
00001318: SUB
00001319: SUB
0000131a: DUP2
0000131b: MSTORE
0000131c: SWAP1
0000131d: PUSH1 0x40
0000131f: MSTORE
00001320: SWAP2
00001321: POP
00001322: PUSH1 0xe0
00001324: SHL
00001325: PUSH1 0x20
00001327: DUP3
00001328: ADD
00001329: DUP1
0000132a: MLOAD
0000132b: PUSH1 0x01
0000132d: PUSH1 0x01
0000132f: PUSH1 0xe0
00001331: SHL
00001332: SUB
00001333: DUP4
00001334: DUP2
00001335: DUP4
00001336: AND
00001337: OR
00001338: DUP4
00001339: MSTORE
0000133a: POP
0000133b: POP
0000133c: POP
0000133d: POP
0000133e: PUSH2 0x146d
00001341: JUMP
00001342: JUMPDEST
00001343: POP
00001344: POP
00001345: POP
00001346: JUMP
00001347: JUMPDEST
00001348: PUSH0
00001349: SLOAD
0000134a: PUSH1 0x01
0000134c: PUSH1 0x01
0000134e: PUSH1 0xa0
00001350: SHL
00001351: SUB
00001352: AND
00001353: CALLER
00001354: EQ
00001355: PUSH2 0x0b71
00001358: JUMPI
00001359: PUSH1 0x40
0000135b: MLOAD
0000135c: PUSH4 0x118cdaa7
00001361: PUSH1 0xe0
00001363: SHL
00001364: DUP2
00001365: MSTORE
00001366: CALLER
00001367: PUSH1 0x04
00001369: DUP3
0000136a: ADD
0000136b: MSTORE
0000136c: PUSH1 0x24
0000136e: ADD
0000136f: PUSH2 0x0414
00001372: JUMP
00001373: JUMPDEST
00001374: PUSH0
00001375: DUP1
00001376: SLOAD
00001377: PUSH1 0x01
00001379: PUSH1 0x01
0000137b: PUSH1 0xa0
0000137d: SHL
0000137e: SUB
0000137f: DUP4
00001380: DUP2
00001381: AND
00001382: PUSH1 0x01
00001384: PUSH1 0x01
00001386: PUSH1 0xa0
00001388: SHL
00001389: SUB
0000138a: NOT
0000138b: DUP4
0000138c: AND
0000138d: DUP2
0000138e: OR
0000138f: DUP5
00001390: SSTORE
00001391: PUSH1 0x40
00001393: MLOAD
00001394: SWAP2
00001395: SWAP1
00001396: SWAP3
00001397: AND
00001398: SWAP3
00001399: DUP4
0000139a: SWAP2
0000139b: PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0
000013bc: SWAP2
000013bd: SWAP1
000013be: LOG3
000013bf: POP
000013c0: POP
000013c1: JUMP
000013c2: JUMPDEST
000013c3: PUSH1 0x40
000013c5: MLOAD
000013c6: PUSH1 0x01
000013c8: PUSH1 0x01
000013ca: PUSH1 0xa0
000013cc: SHL
000013cd: SUB
000013ce: DUP5
000013cf: DUP2
000013d0: AND
000013d1: PUSH1 0x24
000013d3: DUP4
000013d4: ADD
000013d5: MSTORE
000013d6: DUP4
000013d7: DUP2
000013d8: AND
000013d9: PUSH1 0x44
000013db: DUP4
000013dc: ADD
000013dd: MSTORE
000013de: PUSH1 0x64
000013e0: DUP3
000013e1: ADD
000013e2: DUP4
000013e3: SWAP1
000013e4: MSTORE
000013e5: PUSH2 0x13fb
000013e8: SWAP2
000013e9: DUP7
000013ea: SWAP2
000013eb: DUP3
000013ec: AND
000013ed: SWAP1
000013ee: PUSH4 0x23b872dd
000013f3: SWAP1
000013f4: PUSH1 0x84
000013f6: ADD
000013f7: PUSH2 0x1310
000013fa: JUMP
000013fb: JUMPDEST
000013fc: POP
000013fd: POP
000013fe: POP
000013ff: POP
00001400: JUMP
00001401: JUMPDEST
00001402: PUSH0
00001403: PUSH1 0x06
00001405: SLOAD
00001406: DUP3
00001407: GT
00001408: PUSH2 0x1420
0000140b: JUMPI
0000140c: POP
0000140d: PUSH0
0000140e: SWAP1
0000140f: DUP2
00001410: MSTORE
00001411: PUSH1 0x03
00001413: PUSH1 0x20
00001415: MSTORE
00001416: PUSH1 0x40
00001418: SWAP1
00001419: KECCAK256
0000141a: PUSH1 0x02
0000141c: ADD
0000141d: SLOAD
0000141e: SWAP1
0000141f: JUMP
00001420: JUMPDEST
00001421: PUSH0
00001422: DUP1
00001423: MSTORE
00001424: PUSH1 0x03
00001426: PUSH1 0x20
00001428: MSTORE
00001429: PUSH32 0x3617319a054d772f909f7c479a2cebe5066e836a939412e32403c99029b92f01
0000144a: SLOAD
0000144b: PUSH2 0x1457
0000144e: PUSH3 0x278d00
00001452: DUP5
00001453: PUSH2 0x1626
00001456: JUMP
00001457: JUMPDEST
00001458: PUSH2 0x1461
0000145b: SWAP1
0000145c: DUP3
0000145d: PUSH2 0x160d
00001460: JUMP
00001461: JUMPDEST
00001462: SWAP4
00001463: SWAP3
00001464: POP
00001465: POP
00001466: POP
00001467: JUMP
00001468: JUMPDEST
00001469: SWAP2
0000146a: SWAP1
0000146b: POP
0000146c: JUMP
0000146d: JUMPDEST
0000146e: PUSH0
0000146f: PUSH0
00001470: PUSH1 0x20
00001472: PUSH0
00001473: DUP5
00001474: MLOAD
00001475: PUSH1 0x20
00001477: DUP7
00001478: ADD
00001479: PUSH0
0000147a: DUP9
0000147b: GAS
0000147c: CALL
0000147d: DUP1
0000147e: PUSH2 0x148c
00001481: JUMPI
00001482: PUSH1 0x40
00001484: MLOAD
00001485: RETURNDATASIZE
00001486: PUSH0
00001487: DUP3
00001488: RETURNDATACOPY
00001489: RETURNDATASIZE
0000148a: DUP2
0000148b: REVERT
0000148c: JUMPDEST
0000148d: POP
0000148e: POP
0000148f: PUSH0
00001490: MLOAD
00001491: RETURNDATASIZE
00001492: SWAP2
00001493: POP
00001494: DUP2
00001495: ISZERO
00001496: PUSH2 0x14a3
00001499: JUMPI
0000149a: DUP1
0000149b: PUSH1 0x01
0000149d: EQ
0000149e: ISZERO
0000149f: PUSH2 0x14b0
000014a2: JUMP
000014a3: JUMPDEST
000014a4: PUSH1 0x01
000014a6: PUSH1 0x01
000014a8: PUSH1 0xa0
000014aa: SHL
000014ab: SUB
000014ac: DUP5
000014ad: AND
000014ae: EXTCODESIZE
000014af: ISZERO
000014b0: JUMPDEST
000014b1: ISZERO
000014b2: PUSH2 0x13fb
000014b5: JUMPI
000014b6: PUSH1 0x40
000014b8: MLOAD
000014b9: PUSH4 0x5274afe7
000014be: PUSH1 0xe0
000014c0: SHL
000014c1: DUP2
000014c2: MSTORE
000014c3: PUSH1 0x01
000014c5: PUSH1 0x01
000014c7: PUSH1 0xa0
000014c9: SHL
000014ca: SUB
000014cb: DUP6
000014cc: AND
000014cd: PUSH1 0x04
000014cf: DUP3
000014d0: ADD
000014d1: MSTORE
000014d2: PUSH1 0x24
000014d4: ADD
000014d5: PUSH2 0x0414
000014d8: JUMP
000014d9: JUMPDEST
000014da: PUSH0
000014db: PUSH1 0x20
000014dd: DUP3
000014de: DUP5
000014df: SUB
000014e0: SLT
000014e1: ISZERO
000014e2: PUSH2 0x14e9
000014e5: JUMPI
000014e6: PUSH0
000014e7: PUSH0
000014e8: REVERT
000014e9: JUMPDEST
000014ea: POP
000014eb: CALLDATALOAD
000014ec: SWAP2
000014ed: SWAP1
000014ee: POP
000014ef: JUMP
000014f0: JUMPDEST
000014f1: PUSH0
000014f2: PUSH0
000014f3: PUSH1 0x40
000014f5: DUP4
000014f6: DUP6
000014f7: SUB
000014f8: SLT
000014f9: ISZERO
000014fa: PUSH2 0x1501
000014fd: JUMPI
000014fe: PUSH0
000014ff: PUSH0
00001500: REVERT
00001501: JUMPDEST
00001502: POP
00001503: POP
00001504: DUP1
00001505: CALLDATALOAD
00001506: SWAP3
00001507: PUSH1 0x20
00001509: SWAP1
0000150a: SWAP2
0000150b: ADD
0000150c: CALLDATALOAD
0000150d: SWAP2
0000150e: POP
0000150f: JUMP
00001510: JUMPDEST
00001511: DUP1
00001512: CALLDATALOAD
00001513: PUSH1 0x01
00001515: PUSH1 0x01
00001517: PUSH1 0xa0
00001519: SHL
0000151a: SUB
0000151b: DUP2
0000151c: AND
0000151d: DUP2
0000151e: EQ
0000151f: PUSH2 0x1468
00001522: JUMPI
00001523: PUSH0
00001524: PUSH0
00001525: REVERT
00001526: JUMPDEST
00001527: PUSH0
00001528: PUSH1 0x20
0000152a: DUP3
0000152b: DUP5
0000152c: SUB
0000152d: SLT
0000152e: ISZERO
0000152f: PUSH2 0x1536
00001532: JUMPI
00001533: PUSH0
00001534: PUSH0
00001535: REVERT
00001536: JUMPDEST
00001537: PUSH2 0x1461
0000153a: DUP3
0000153b: PUSH2 0x1510
0000153e: JUMP
0000153f: JUMPDEST
00001540: PUSH1 0x20
00001542: DUP1
00001543: DUP3
00001544: MSTORE
00001545: DUP3
00001546: MLOAD
00001547: DUP3
00001548: DUP3
00001549: ADD
0000154a: DUP2
0000154b: SWAP1
0000154c: MSTORE
0000154d: PUSH0
0000154e: SWAP2
0000154f: DUP5
00001550: ADD
00001551: SWAP1
00001552: PUSH1 0x40
00001554: DUP5
00001555: ADD
00001556: SWAP1
00001557: DUP4
00001558: JUMPDEST
00001559: DUP2
0000155a: DUP2
0000155b: LT
0000155c: ISZERO
0000155d: PUSH2 0x15b2
00001560: JUMPI
00001561: DUP4
00001562: MLOAD
00001563: DUP1
00001564: MLOAD
00001565: DUP5
00001566: MSTORE
00001567: PUSH1 0x20
00001569: DUP2
0000156a: ADD
0000156b: MLOAD
0000156c: PUSH1 0x20
0000156e: DUP6
0000156f: ADD
00001570: MSTORE
00001571: PUSH1 0x40
00001573: DUP2
00001574: ADD
00001575: MLOAD
00001576: PUSH1 0x40
00001578: DUP6
00001579: ADD
0000157a: MSTORE
0000157b: PUSH1 0x60
0000157d: DUP2
0000157e: ADD
0000157f: MLOAD
00001580: PUSH1 0x60
00001582: DUP6
00001583: ADD
00001584: MSTORE
00001585: PUSH1 0x80
00001587: DUP2
00001588: ADD
00001589: MLOAD
0000158a: ISZERO
0000158b: ISZERO
0000158c: PUSH1 0x80
0000158e: DUP6
0000158f: ADD
00001590: MSTORE
00001591: PUSH1 0xa0
00001593: DUP2
00001594: ADD
00001595: MLOAD
00001596: PUSH1 0xa0
00001598: DUP6
00001599: ADD
0000159a: MSTORE
0000159b: POP
0000159c: PUSH1 0xc0
0000159e: DUP4
0000159f: ADD
000015a0: SWAP3
000015a1: POP
000015a2: PUSH1 0x20
000015a4: DUP5
000015a5: ADD
000015a6: SWAP4
000015a7: POP
000015a8: PUSH1 0x01
000015aa: DUP2
000015ab: ADD
000015ac: SWAP1
000015ad: POP
000015ae: PUSH2 0x1558
000015b1: JUMP
000015b2: JUMPDEST
000015b3: POP
000015b4: SWAP1
000015b5: SWAP6
000015b6: SWAP5
000015b7: POP
000015b8: POP
000015b9: POP
000015ba: POP
000015bb: POP
000015bc: JUMP
000015bd: JUMPDEST
000015be: PUSH0
000015bf: PUSH0
000015c0: PUSH1 0x40
000015c2: DUP4
000015c3: DUP6
000015c4: SUB
000015c5: SLT
000015c6: ISZERO
000015c7: PUSH2 0x15ce
000015ca: JUMPI
000015cb: PUSH0
000015cc: PUSH0
000015cd: REVERT
000015ce: JUMPDEST
000015cf: PUSH2 0x15d7
000015d2: DUP4
000015d3: PUSH2 0x1510
000015d6: JUMP
000015d7: JUMPDEST
000015d8: SWAP5
000015d9: PUSH1 0x20
000015db: SWAP4
000015dc: SWAP1
000015dd: SWAP4
000015de: ADD
000015df: CALLDATALOAD
000015e0: SWAP4
000015e1: POP
000015e2: POP
000015e3: POP
000015e4: JUMP
000015e5: JUMPDEST
000015e6: PUSH4 0x4e487b71
000015eb: PUSH1 0xe0
000015ed: SHL
000015ee: PUSH0
000015ef: MSTORE
000015f0: PUSH1 0x32
000015f2: PUSH1 0x04
000015f4: MSTORE
000015f5: PUSH1 0x24
000015f7: PUSH0
000015f8: REVERT
000015f9: JUMPDEST
000015fa: PUSH4 0x4e487b71
000015ff: PUSH1 0xe0
00001601: SHL
00001602: PUSH0
00001603: MSTORE
00001604: PUSH1 0x11
00001606: PUSH1 0x04
00001608: MSTORE
00001609: PUSH1 0x24
0000160b: PUSH0
0000160c: REVERT
0000160d: JUMPDEST
0000160e: DUP1
0000160f: DUP3
00001610: ADD
00001611: DUP1
00001612: DUP3
00001613: GT
00001614: ISZERO
00001615: PUSH2 0x1620
00001618: JUMPI
00001619: PUSH2 0x1620
0000161c: PUSH2 0x15f9
0000161f: JUMP
00001620: JUMPDEST
00001621: SWAP3
00001622: SWAP2
00001623: POP
00001624: POP
00001625: JUMP
00001626: JUMPDEST
00001627: DUP1
00001628: DUP3
00001629: MUL
0000162a: DUP2
0000162b: ISZERO
0000162c: DUP3
0000162d: DUP3
0000162e: DIV
0000162f: DUP5
00001630: EQ
00001631: OR
00001632: PUSH2 0x1620
00001635: JUMPI
00001636: PUSH2 0x1620
00001639: PUSH2 0x15f9
0000163c: JUMP
0000163d: JUMPDEST
0000163e: PUSH0
0000163f: DUP3
00001640: PUSH2 0x1657
00001643: JUMPI
00001644: PUSH4 0x4e487b71
00001649: PUSH1 0xe0
0000164b: SHL
0000164c: PUSH0
0000164d: MSTORE
0000164e: PUSH1 0x12
00001650: PUSH1 0x04
00001652: MSTORE
00001653: PUSH1 0x24
00001655: PUSH0
00001656: REVERT
00001657: JUMPDEST
00001658: POP
00001659: DIV
0000165a: SWAP1
0000165b: JUMP
0000165c: JUMPDEST
0000165d: DUP2
0000165e: DUP2
0000165f: SUB
00001660: DUP2
00001661: DUP2
00001662: GT
00001663: ISZERO
00001664: PUSH2 0x1620
00001667: JUMPI
00001668: PUSH2 0x1620
0000166b: PUSH2 0x15f9
0000166e: JUMP
0000166f: JUMPDEST
00001670: PUSH0
00001671: PUSH1 0x01
00001673: DUP3
00001674: ADD
00001675: PUSH2 0x1680
00001678: JUMPI
00001679: PUSH2 0x1680
0000167c: PUSH2 0x15f9
0000167f: JUMP
00001680: JUMPDEST
00001681: POP
00001682: PUSH1 0x01
00001684: ADD
00001685: SWAP1
00001686: JUMP
00001687: INVALID
00001688: LOG2
00001689: PUSH5 0x6970667358
0000168f: UNKNOWN(0x22)
00001690: SLT
00001691: KECCAK256
00001692: DUP6
00001693: JUMPI
00001694: UNKNOWN(0xC5)
00001695: SWAP5
00001696: UNKNOWN(0x27)
00001697: UNKNOWN(0x29)
00001698: DUP14
00001699: UNKNOWN(0xD0)
0000169a: CALLDATASIZE
0000169b: PUSH14 0x43c7b670b8ba75c1ef4f64e06f78
000016aa: SWAP14
000016ab: UNKNOWN(0x1F)
000016ac: ADD
000016ad: UNKNOWN(0xB6)
000016ae: PUSH7 0x1ba40b64736f6c
000016b6: PUSH4 0x4300081c
000016bb: STOP
000016bc: CALLER