Analysis Run

[codex:821729] OpenAI Codex v0.77.0 (research preview)
[codex:821729] --------
[codex:821729] workdir: /tmp/codex-multi-t27exkc3
[codex:821729] model: gpt-5.2-codex
[codex:821729] provider: openai
[codex:821729] approval: never
[codex:821729] sandbox: read-only
[codex:821729] reasoning effort: xhigh
[codex:821729] reasoning summaries: auto
[codex:821729] session id: 019b8176-431c-7713-8dd6-a4f36118236e
[codex:821729] --------
[codex:821729] user
[codex:821729] You are a profit-focused exploit hunter analyzing EVM bytecode. Your ONLY goal is finding ways to extract value (ETH, tokens, NFTs) from this contract.
[codex:821729] 
[codex:821729] Read `BYTECODE_BUNDLE.txt` completely before concluding.
[codex:821729] 
[codex:821729] ONLY REPORT if you find a CONCRETE, EXPLOITABLE path to profit. We do NOT care about:
[codex:821729] - Gas inefficiency, code quality, or best practices
[codex:821729] - Theoretical vulnerabilities without a clear extraction path
[codex:821729] - Generic footguns (unchecked return values, etc.) unless they enable theft
[codex:821729] - Issues requiring social engineering or off-chain coordination
[codex:821729] 
[codex:821729] PATTERNS WORTH INVESTIGATING in bytecode:
[codex:821729] - CALL/DELEGATECALL with controllable destination or calldata
[codex:821729] - Value transfers (CALL with non-zero value) without prior CALLER/ORIGIN checks
[codex:821729] - SSTORE to low slots (0-10) that might be owner/admin storage
[codex:821729] - ecrecover (signature validation) - look for missing nonce/replay protection
[codex:821729] - External calls before state updates (reentrancy)
[codex:821729] - SELFDESTRUCT with controllable beneficiary
[codex:821729] - Proxy patterns (DELEGATECALL to storage slot) with unprotected upgrade paths
[codex:821729] 
[codex:821729] For each finding, you MUST explain:
[codex:821729] 1. The specific bytecode pattern/offsets that indicate the vulnerability
[codex:821729] 2. The concrete sequence of transactions to extract value
[codex:821729] 3. Why you believe this is exploitable (not just suspicious)
[codex:821729] 
[codex:821729] If you cannot identify a concrete profit path from bytecode alone: set no_findings=true.
[codex:821729] Do NOT hallucinate. Bytecode-only analysis is limited - be honest about uncertainty.
[codex:821729] 
[codex:821729] Output MUST be valid JSON matching the provided schema.
[codex:821729] - severity: info, low, medium, high, critical (use high/critical ONLY for clear extraction paths)
[codex:821729] - category: access_control, reentrancy, math, oracle, upgradeability, auth, other
[codex:821729] mcp startup: no servers
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Reading BYTECODE_BUNDLE file**
[codex:821729] exec
[codex:821729] /bin/bash -lc ls in /tmp/codex-multi-t27exkc3 succeeded in 6ms:
[codex:821729] BYTECODE_BUNDLE.txt
[codex:821729] codex-output-schema.json
[codex:821729] exec
[codex:821729] /bin/bash -lc 'cat BYTECODE_BUNDLE.txt' in /tmp/codex-multi-t27exkc3 succeeded in 5ms:
[codex:821729] Runtime bytecode bundle for best-effort auditing.
[codex:821729] Note: without verified source, conclusions are low-confidence unless a concrete pattern is visible.
[codex:821729] 
[codex:821729] FILE: runtime_bytecode.hex
[codex:821729] 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
[codex:821729] 
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Analyzing wallet bytecode and authorization logic**
[codex:821729] 
[codex:821729] I'm carefully decoding the bytecode of a module-based wallet contract, likely a BaseWallet variant with functions for module management and ownership. I’m examining how fallback and function dispatch handle calls, checking if module calls are properly authorized, and reviewing revert messages indicating access controls; this should reveal if there are exploitable unprotected entry points or if module authorization is correctly enforced.
[codex:821729] thinking
[codex:821729] **Inspecting module authorization and initialization**
[codex:821729] 
[codex:821729] I’m digging into the module authorization function that adds or removes modules while calling their `init` method, confirming it requires module-only access. I also examined the initialization function that sets owner and modules if uninitialized—potentially exploitable only if not initialized yet—and a fallback internal call verifying authorized modules, investigating how external calls to the module wallet are controlled.
[codex:821729] exec
[codex:821729] /bin/bash -lc "python3 - <<'PY'
[codex:821729] import sha3
[codex:821729] import binascii
[codex:821729] 
[codex:821729] sigs=[
[codex:821729] \"canImplementInterfaceForAddress(bytes32,address)\",
[codex:821729] \"isValidSignature(bytes32,bytes)\",
[codex:821729] \"isValidSignature(bytes,bytes)\",
[codex:821729] \"isValidSignature(bytes32,bytes32)\",
[codex:821729] \"isValidSignature(bytes32,bytes32,bytes32)\",
[codex:821729] \"isValidSignature(bytes32,bytes)\",
[codex:821729] \"isValidSignature(bytes32,bytes)\"
[codex:821729] ]
[codex:821729] for sig in sigs:
[codex:821729]     k=sha3.keccak_256(sig.encode()).hexdigest()
[codex:821729]     print(sig, k[:8])
[codex:821729] PY" in /tmp/codex-multi-t27exkc3 exited 1 in 45ms:
[codex:821729] Traceback (most recent call last):
[codex:821729]   File "<stdin>", line 1, in <module>
[codex:821729] ModuleNotFoundError: No module named 'sha3'
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Checking keccak256 availability in Python**
[codex:821729] exec
[codex:821729] /bin/bash -lc "python3 - <<'PY'
[codex:821729] import hashlib
[codex:821729] for alg in ['keccak256','sha3_256']:
[codex:821729]     try:
[codex:821729]         h=hashlib.new(alg)
[codex:821729]         print(alg,'ok')
[codex:821729]     except Exception as e:
[codex:821729]         print(alg,'err',e)
[codex:821729] PY" in /tmp/codex-multi-t27exkc3 succeeded in 21ms:
[codex:821729] keccak256 err unsupported hash type keccak256
[codex:821729] sha3_256 ok
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Reasoning about module calls and fallback logic**
[codex:821729] 
[codex:821729] I'm analyzing how the wallet's module system works, especially the invoke function and fallback that delegate calls to authorized modules. I'm investigating function selectors and registry calls to understand how modules are identified and authorized, and considering writing a simple Python disassembler to dig into the bytecode around key functions to clarify the control flow.
[codex:821729] exec
[codex:821729] /bin/bash -lc "python3 - <<'PY'
[codex:821729] import binascii
[codex:821729] from textwrap import wrap
[codex:821729] 
[codex:821729] hexdata=open('/tmp/codex-multi-t27exkc3/BYTECODE_BUNDLE.txt').read().split('FILE: runtime_bytecode.hex')[1]
[codex:821729] # extract hex string after newline
[codex:821729] import re
[codex:821729] m=re.search(r'0x([0-9a-fA-F]+)', hexdata)
[codex:821729] code=bytes.fromhex(m.group(1))
[codex:821729] 
[codex:821729] opcodes={
[codex:821729] 0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
[codex:821729] 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',
[codex:821729] 0x20:'SHA3',
[codex:821729] 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',
[codex:821729] 0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
[codex:821729] 0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
[codex:821729] 0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',
[codex:821729] 0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
[codex:821729] 0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
[codex:821729] 0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
[codex:821729] 0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
[codex:821729] 0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
[codex:821729] }
[codex:821729] 
[codex:821729] # disassemble into list of (pc, op, arg)
[codex:821729] ops=[]
[codex:821729] pc=0
[codex:821729] while pc<len(code):
[codex:821729]     op=code[pc]
[codex:821729]     name=opcodes.get(op, 'OP%02x'%op)
[codex:821729]     arg=None
[codex:821729]     pc0=pc
[codex:821729]     pc+=1
[codex:821729]     if 0x60<=op<=0x7f:
[codex:821729]         n=op-0x5f
[codex:821729]         arg=code[pc:pc+n]
[codex:821729]         pc+=n
[codex:821729]     ops.append((pc0,name,arg))
[codex:821729] 
[codex:821729] # helper to print range
[codex:821729] 
[codex:821729] def dump(start,end):
[codex:821729]     for pc,name,arg in ops:
[codex:821729]         if pc<start: continue
[codex:821729]         if pc>end: break
[codex:821729]         if arg is None:
[codex:821729]             print(f\"{pc:04x}: {name}\")
[codex:821729]         else:
[codex:821729]             print(f\"{pc:04x}: {name} 0x{arg.hex()}\")
[codex:821729] 
[codex:821729] # dump around 0x300-0x3d0
[codex:821729] print('--- 0x300-0x3d0 ---')
[codex:821729] dump(0x300,0x3d0)
[codex:821729] print('--- 0x80-0x120 ---')
[codex:821729] dump(0x80,0x120)
[codex:821729] print('--- 0x720-0x820 ---')
[codex:821729] dump(0x720,0x820)
[codex:821729] print('--- 0xa60-0xb40 ---')
[codex:821729] dump(0xa60,0xb40)
[codex:821729] PY" in /tmp/codex-multi-t27exkc3 succeeded in 29ms:
[codex:821729] --- 0x300-0x3d0 ---
[codex:821729] 0301: PUSH1 0x03
[codex:821729] 0303: SLOAD
[codex:821729] 0304: DUP2
[codex:821729] 0305: JUMP
[codex:821729] 0306: JUMPDEST
[codex:821729] 0307: PUSH1 0x40
[codex:821729] 0309: MLOAD
[codex:821729] 030a: SWAP1
[codex:821729] 030b: DUP2
[codex:821729] 030c: MSTORE
[codex:821729] 030d: PUSH1 0x20
[codex:821729] 030f: ADD
[codex:821729] 0310: PUSH2 0x023a
[codex:821729] 0313: JUMP
[codex:821729] 0314: JUMPDEST
[codex:821729] 0315: PUSH1 0x02
[codex:821729] 0317: SLOAD
[codex:821729] 0318: PUSH1 0x00
[codex:821729] 031a: SWAP1
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Analyzing fallback and registry call logic**
[codex:821729] exec
[codex:821729] /bin/bash -lc "python3 - <<'PY'
[codex:821729] import re
[codex:821729] code=open('/tmp/codex-multi-t27exkc3/BYTECODE_BUNDLE.txt').read()
[codex:821729] hexdata=re.search(r'0x([0-9a-fA-F]+)', code).group(1)
[codex:821729] code=bytes.fromhex(hexdata)
[codex:821729] # disassemble quickly to get around 0x170-0x1a0
[codex:821729] opcodes={i:('PUSH'+str(i-0x5f) if 0x60<=i<=0x7f else None) for i in range(256)}
[codex:821729] # map minimal for readability
[codex:821729] names={0x56:'JUMP',0x57:'JUMPI',0x5b:'JUMPDEST',0x00:'STOP',0xf3:'RETURN',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT',0xa3:'LOG3'}
[codex:821729] # We'll simple decode using previous script? quick
[codex:821729] from textwrap import wrap
[codex:821729] 
[codex:821729] # load opcodes table
[codex:821729] opcodes_full={}
[codex:821729] # from earlier script maybe but reimplement quickly
[codex:821729] import sys
[codex:821729] 
[codex:821729] opcodes_full.update({
[codex:821729] 0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
[codex:821729] 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',
[codex:821729] 0x20:'SHA3',
[codex:821729] 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',
[codex:821729] 0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
[codex:821729] 0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
[codex:821729] 0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',
[codex:821729] 0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
[codex:821729] 0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
[codex:821729] 0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
[codex:821729] 0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
[codex:821729] 0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
[codex:821729] })
[codex:821729] 
[codex:821729] ops=[]
[codex:821729] pc=0
[codex:821729] while pc<len(code):
[codex:821729]     op=code[pc]
[codex:821729]     name=opcodes_full.get(op,'OP%02x'%op)
[codex:821729]     arg=None
[codex:821729]     pc0=pc; pc+=1
[codex:821729]     if 0x60<=op<=0x7f:
[codex:821729]         n=op-0x5f
[codex:821729]         arg=code[pc:pc+n]; pc+=n
[codex:821729]     ops.append((pc0,name,arg))
[codex:821729] 
[codex:821729] # print range 0x170-0x1a0
[codex:821729] for pc,name,arg in ops:
[codex:821729]     if pc<0x170: continue
[codex:821729]     if pc>0x1a0: break
[codex:821729]     if arg is None:
[codex:821729]         print(f\"{pc:04x}: {name}\")
[codex:821729]     else:
[codex:821729]         print(f\"{pc:04x}: {name} 0x{arg.hex()}\")
[codex:821729] PY" in /tmp/codex-multi-t27exkc3 succeeded in 28ms:
[codex:821729] 0170: DUP5
[codex:821729] 0171: GAS
[codex:821729] 0172: STATICCALL
[codex:821729] 0173: RETURNDATASIZE
[codex:821729] 0174: PUSH1 0x00
[codex:821729] 0176: DUP1
[codex:821729] 0177: RETURNDATACOPY
[codex:821729] 0178: DUP1
[codex:821729] 0179: DUP1
[codex:821729] 017a: ISZERO
[codex:821729] 017b: PUSH2 0x0183
[codex:821729] 017e: JUMPI
[codex:821729] 017f: RETURNDATASIZE
[codex:821729] 0180: PUSH1 0x00
[codex:821729] 0182: RETURN
[codex:821729] 0183: JUMPDEST
[codex:821729] 0184: RETURNDATASIZE
[codex:821729] 0185: PUSH1 0x00
[codex:821729] 0187: REVERT
[codex:821729] 0188: JUMPDEST
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Analyzing fallback and module registry calls**
[codex:821729] exec
[codex:821729] /bin/bash -lc "python3 - <<'PY'
[codex:821729] import re
[codex:821729] code=open('/tmp/codex-multi-t27exkc3/BYTECODE_BUNDLE.txt').read()
[codex:821729] hexdata=re.search(r'0x([0-9a-fA-F]+)', code).group(1)
[codex:821729] code=bytes.fromhex(hexdata)
[codex:821729] # disassemble around 0x480-0x540
[codex:821729] from collections import defaultdict
[codex:821729] 
[codex:821729] opcodes={
[codex:821729] 0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
[codex:821729] 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',
[codex:821729] 0x20:'SHA3',
[codex:821729] 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',
[codex:821729] 0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
[codex:821729] 0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
[codex:821729] 0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',
[codex:821729] 0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
[codex:821729] 0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
[codex:821729] 0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
[codex:821729] 0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
[codex:821729] 0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
[codex:821729] }
[codex:821729] 
[codex:821729] ops=[]
[codex:821729] pc=0
[codex:821729] while pc<len(code):
[codex:821729]     op=code[pc]; name=opcodes.get(op,f'OP{op:02x}'); arg=None
[codex:821729]     pc0=pc; pc+=1
[codex:821729]     if 0x60<=op<=0x7f:
[codex:821729]         n=op-0x5f; arg=code[pc:pc+n]; pc+=n
[codex:821729]     ops.append((pc0,name,arg))
[codex:821729] 
[codex:821729] for pc,name,arg in ops:
[codex:821729]     if pc<0x480: continue
[codex:821729]     if pc>0x540: break
[codex:821729]     if arg is None:
[codex:821729]         print(f\"{pc:04x}: {name}\")
[codex:821729]     else:
[codex:821729]         print(f\"{pc:04x}: {name} 0x{arg.hex()}\")
[codex:821729] PY" in /tmp/codex-multi-t27exkc3 succeeded in 26ms:
[codex:821729] 0487: SWAP1
[codex:821729] 0488: PUSH2 0x0492
[codex:821729] 048b: SWAP1
[codex:821729] 048c: DUP4
[codex:821729] 048d: SWAP1
[codex:821729] 048e: PUSH2 0x0d6f
[codex:821729] 0491: JUMP
[codex:821729] 0492: JUMPDEST
[codex:821729] 0493: PUSH1 0x40
[codex:821729] 0495: MLOAD
[codex:821729] 0496: DUP1
[codex:821729] 0497: SWAP2
[codex:821729] 0498: SUB
[codex:821729] 0499: SWAP1
[codex:821729] 049a: LOG1
[codex:821729] 049b: POP
[codex:821729] 049c: JUMP
[codex:821729] 049d: JUMPDEST
[codex:821729] 049e: CALLER
[codex:821729] 049f: PUSH1 0x00
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Analyzing complex EVM stack operations**
[codex:821729] 
[codex:821729] I'm carefully tracking stack changes and opcode effects at function 0x49d to understand parameter layout and address comparisons. I want to fully grasp how the registry address and module address are handled and cross-checked through bitwise operations and conditional jumps, so I'm considering writing a symbolic stack simulator in Python to map it precisely.
[codex:821729] exec
[codex:821729] /bin/bash -lc "python3 - <<'PY'
[codex:821729] import re
[codex:821729] code=open('/tmp/codex-multi-t27exkc3/BYTECODE_BUNDLE.txt').read()
[codex:821729] hexdata=re.search(r'0x([0-9a-fA-F]+)', code).group(1)
[codex:821729] code=bytes.fromhex(hexdata)
[codex:821729] 
[codex:821729] # disassemble into list
[codex:821729] opcodes={
[codex:821729] 0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
[codex:821729] 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',
[codex:821729] 0x20:'SHA3',
[codex:821729] 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',
[codex:821729] 0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
[codex:821729] 0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
[codex:821729] 0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',
[codex:821729] 0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
[codex:821729] 0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
[codex:821729] 0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
[codex:821729] 0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
[codex:821729] 0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
[codex:821729] }
[codex:821729] 
[codex:821729] # build op list
[codex:821729] ops=[]
[codex:821729] pc=0
[codex:821729] while pc<len(code):
[codex:821729]     op=code[pc]; name=opcodes.get(op,f'OP{op:02x}'); arg=None
[codex:821729]     pc0=pc; pc+=1
[codex:821729]     if 0x60<=op<=0x7f:
[codex:821729]         n=op-0x5f; arg=code[pc:pc+n]; pc+=n
[codex:821729]     ops.append((pc0,name,arg))
[codex:821729] 
[codex:821729] # select ops from 0x49d to 0x561
[codex:821729] ops_sel=[o for o in ops if 0x49d<=o[0]<=0x561]
[codex:821729] 
[codex:821729] # simple symbolic stack tracer
[codex:821729] stack=['ret','arg0','arg1']  # assume ret bottom, arg0, arg1 top (arg1 is last)
[codex:821729] # Actually in internal call, stack order: ret, arg0, arg1. top is arg1. We'll adopt.
[codex:821729] 
[codex:821729] 
[codex:821729] def pop(n=1):
[codex:821729]     global stack
[codex:821729]     if n==1:
[codex:821729]         return stack.pop() if stack else 'EMPTY'
[codex:821729]     out=[]
[codex:821729]     for _ in range(n):
[codex:821729]         out.append(stack.pop() if stack else 'EMPTY')
[codex:821729]     return out
[codex:821729] 
[codex:821729] 
[codex:821729] def push(val):
[codex:821729]     stack.append(val)
[codex:821729] 
[codex:821729] # We'll ignore jumps; just linear trace with limited operations for understanding
[codex:821729] 
[codex:821729] for pc,name,arg in ops_sel:
[codex:821729]     if name.startswith('PUSH'):
[codex:821729]         push(f\"{name}({arg.hex()})\")
[codex:821729]     elif name.startswith('DUP'):
[codex:821729]         n=int(name[3:])
[codex:821729]         if len(stack)>=n:
[codex:821729]             push(stack[-n])
[codex:821729]         else:
[codex:821729]             push('EMPTY')
[codex:821729]     elif name.startswith('SWAP'):
[codex:821729]         n=int(name[4:])
[codex:821729]         if len(stack)>n:
[codex:821729]             stack[-1],stack[-1-n]=stack[-1-n],stack[-1]
[codex:821729]     elif name in ('POP',):
[codex:821729]         pop()
[codex:821729]     elif name in ('SLOAD','MLOAD','CALLER','CALLVALUE','SHA3'):
[codex:821729]         # pop needed args? (SLOAD pops 1)
[codex:821729]         if name in ('SLOAD','MLOAD','SHA3'):
[codex:821729]             pop()
[codex:821729]         elif name in ('CALLER','CALLVALUE'):
[codex:821729]             pass
[codex:821729]         push(name)
[codex:821729]     elif name in ('AND','OR','EQ','SUB','ADD','SHL','SHR','ISZERO'):
[codex:821729]         # pop 2 for binary ops, 1 for ISZERO
[codex:821729]         if name=='ISZERO':
[codex:821729]             a=pop(); push(f\"{name}({a})\")
[codex:821729]         else:
[codex:821729]             b=pop(); a=pop(); push(f\"{name}({a},{b})\")
[codex:821729]     elif name=='JUMPI':
[codex:821729]         # pop dest and cond
[codex:821729]         dest=pop(); cond=pop();
[codex:821729]         # keep stack for fallthrough
[codex:821729]         push(f\"JUMPI_dest({dest})_cond({cond})\")
[codex:821729]     else:
[codex:821729]         # ignore other ops (CALL, etc.) and clear stack maybe
[codex:821729]         pass
[codex:821729]     # Print snapshot at key points
[codex:821729]     if pc in (0x04cd,0x04dd,0x04e2,0x04fe,0x0545,0x0561):
[codex:821729]         print(f\"pc {pc:04x} {name} stack: {stack}\")
[codex:821729] 
[codex:821729] # final stack
[codex:821729] print('final stack',stack)
[codex:821729] PY" in /tmp/codex-multi-t27exkc3 succeeded in 32ms:
[codex:821729] pc 04cd PUSH1 stack: ['ret', 'arg0', 'arg1', 'PUSH1(00)', 'CALLER', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(04cc))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'PUSH2(015b)', 'ADD(MLOAD,PUSH1(04))', 'PUSH2(0e05)', 'PUSH1(02)']
[codex:821729] pc 04dd EQ stack: ['ret', 'arg0', 'arg1', 'PUSH1(00)', 'CALLER', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(04cc))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'PUSH2(015b)', 'ADD(MLOAD,PUSH1(04))', 'PUSH2(0e05)', 'EQ(AND(ADD(MLOAD,PUSH1(04)),SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0)))),AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),SLOAD))']
[codex:821729] pc 04e2 PUSH1 stack: ['ret', 'arg0', 'arg1', 'PUSH1(00)', 'CALLER', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(04cc))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'PUSH2(015b)', 'ADD(MLOAD,PUSH1(04))', 'PUSH2(0e05)', 'JUMPI_dest(PUSH2(0561))_cond(EQ(AND(ADD(MLOAD,PUSH1(04)),SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0)))),AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),SLOAD)))', 'PUSH1(01)']
[codex:821729] pc 04fe PUSH2 stack: ['ret', 'arg0', 'arg1', 'PUSH1(00)', 'CALLER', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(04cc))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'PUSH2(015b)', 'ADD(MLOAD,PUSH1(04))', 'PUSH2(0e05)', 'JUMPI_dest(PUSH2(0561))_cond(EQ(AND(ADD(MLOAD,PUSH1(04)),SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0)))),AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),SLOAD)))', 'PUSH1(00)', 'AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),PUSH2(0e05))', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'AND(SLOAD,PUSH1(ff))', 'PUSH2(0545)']
[codex:821729] pc 0545 JUMPDEST stack: ['ret', 'arg0', 'arg1', 'PUSH1(00)', 'CALLER', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(04cc))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'PUSH2(015b)', 'ADD(MLOAD,PUSH1(04))', 'PUSH2(0e05)', 'JUMPI_dest(PUSH2(0561))_cond(EQ(AND(ADD(MLOAD,PUSH1(04)),SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0)))),AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),SLOAD)))', 'PUSH1(00)', 'AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),PUSH2(0e05))', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(0545))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'MLOAD', 'PUSH1(20)', 'ADD(PUSH1(04),MLOAD)', 'PUSH1(19)', 'ADD(PUSH1(24),ADD(PUSH1(04),MLOAD))', 'SHL(PUSH25(212b9d103ab730baba3437b934bd32b21032bc32b1baba37b9),PUSH1(39))', 'ADD(ADD(PUSH1(44),ADD(PUSH1(24),ADD(PUSH1(04),MLOAD))),PUSH1(64))', 'PUSH2(015b)']
[codex:821729] pc 0561 JUMPDEST stack: ['ret', 'arg0', 'arg1', 'PUSH1(00)', 'CALLER', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(04cc))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'PUSH2(015b)', 'ADD(MLOAD,PUSH1(04))', 'PUSH2(0e05)', 'JUMPI_dest(PUSH2(0561))_cond(EQ(AND(ADD(MLOAD,PUSH1(04)),SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0)))),AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),SLOAD)))', 'PUSH1(00)', 'AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),PUSH2(0e05))', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(0545))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'MLOAD', 'PUSH1(20)', 'ADD(PUSH1(04),MLOAD)', 'PUSH1(19)', 'ADD(PUSH1(24),ADD(PUSH1(04),MLOAD))', 'SHL(PUSH25(212b9d103ab730baba3437b934bd32b21032bc32b1baba37b9),PUSH1(39))', 'ADD(ADD(PUSH1(44),ADD(PUSH1(24),ADD(PUSH1(04),MLOAD))),PUSH1(64))', 'PUSH2(015b)', 'OR(AND(SLOAD,SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0)))),AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),ADD(ADD(PUSH1(44),ADD(PUSH1(24),ADD(PUSH1(04),MLOAD))),PUSH1(64))))', 'PUSH1(02)']
[codex:821729] final stack ['ret', 'arg0', 'arg1', 'PUSH1(00)', 'CALLER', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(04cc))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'PUSH2(015b)', 'ADD(MLOAD,PUSH1(04))', 'PUSH2(0e05)', 'JUMPI_dest(PUSH2(0561))_cond(EQ(AND(ADD(MLOAD,PUSH1(04)),SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0)))),AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),SLOAD)))', 'PUSH1(00)', 'AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),PUSH2(0e05))', 'PUSH1(00)', 'PUSH1(01)', 'PUSH1(40)', 'JUMPI_dest(PUSH2(0545))_cond(AND(SLOAD,PUSH1(ff)))', 'MLOAD', 'SHL(PUSH3(461bcd),PUSH1(e5))', 'MLOAD', 'PUSH1(20)', 'ADD(PUSH1(04),MLOAD)', 'PUSH1(19)', 'ADD(PUSH1(24),ADD(PUSH1(04),MLOAD))', 'SHL(PUSH25(212b9d103ab730baba3437b934bd32b21032bc32b1baba37b9),PUSH1(39))', 'ADD(ADD(PUSH1(44),ADD(PUSH1(24),ADD(PUSH1(04),MLOAD))),PUSH1(64))', 'PUSH2(015b)', 'OR(AND(SLOAD,SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0)))),AND(SUB(PUSH1(01),SHL(PUSH1(01),PUSH1(a0))),ADD(ADD(PUSH1(44),ADD(PUSH1(24),ADD(PUSH1(04),MLOAD))),PUSH1(64))))', 'PUSH1(02)']
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Analyzing BaseWallet bytecode and functions**
[codex:821729] 
[codex:821729] I'm carefully examining the BaseWallet contract's functions and their selectors to understand access control and upgrade mechanisms, testing hypotheses about potential vulnerabilities, especially around module registry setting and fallback behavior, while considering symbolic simulation to clarify complex call arguments.
[codex:821729] exec
[codex:821729] /bin/bash -lc "python3 - <<'PY'
[codex:821729] import re
[codex:821729] code=open('/tmp/codex-multi-t27exkc3/BYTECODE_BUNDLE.txt').read();
[codex:821729] hexdata=re.search(r'0x([0-9a-fA-F]+)', code).group(1)
[codex:821729] code=bytes.fromhex(hexdata)
[codex:821729] 
[codex:821729] # opcode table
[codex:821729] opcodes={
[codex:821729] 0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
[codex:821729] 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',
[codex:821729] 0x20:'SHA3',
[codex:821729] 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',
[codex:821729] 0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
[codex:821729] 0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
[codex:821729] 0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',
[codex:821729] 0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
[codex:821729] 0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
[codex:821729] 0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
[codex:821729] 0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
[codex:821729] 0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
[codex:821729] }
[codex:821729] 
[codex:821729] # disassemble
[codex:821729] ops=[]
[codex:821729] pc=0
[codex:821729] while pc<len(code):
[codex:821729]     op=code[pc]; name=opcodes.get(op,f'OP{op:02x}'); arg=None
[codex:821729]     pc0=pc; pc+=1
[codex:821729]     if 0x60<=op<=0x7f:
[codex:821729]         n=op-0x5f; arg=int.from_bytes(code[pc:pc+n],'big'); pc+=n
[codex:821729]     ops.append((pc0,name,arg))
[codex:821729] 
[codex:821729] # Build map for quick lookup
[codex:821729] opmap={pc:(name,arg) for pc,name,arg in ops}
[codex:821729] 
[codex:821729] # simulate from 0x314 to 0x379 (before STATICCALL)
[codex:821729] start=0x314; end=0x379
[codex:821729] # initial stack for 0x314: [ret, zero, sig]
[codex:821729] stack=['ret','zero','sig']
[codex:821729] mem={}
[codex:821729] 
[codex:821729] def eval_expr(op, *args):
[codex:821729]     return f\"{op}({', '.join(map(str,args))})\"
[codex:821729] 
[codex:821729] pc=start
[codex:821729] while pc<=end:
[codex:821729]     name,arg=opmap[pc]
[codex:821729]     # print(pc,name,arg, stack)
[codex:821729]     if name.startswith('PUSH'):
[codex:821729]         stack.append(arg)
[codex:821729]     elif name.startswith('DUP'):
[codex:821729]         n=int(name[3:]); stack.append(stack[-n])
[codex:821729]     elif name.startswith('SWAP'):
[codex:821729]         n=int(name[4:]); stack[-1],stack[-1-n]=stack[-1-n],stack[-1]
[codex:821729]     elif name=='POP':
[codex:821729]         stack.pop()
[codex:821729]     elif name=='SLOAD':
[codex:821729]         stack.pop(); stack.append('slot2')
[codex:821729]     elif name=='MLOAD':
[codex:821729]         stack.pop(); stack.append('m')
[codex:821729]     elif name=='MSTORE':
[codex:821729]         val=stack.pop(); addr=stack.pop(); mem[str(addr)]=val
[codex:821729]     elif name=='SHL':
[codex:821729]         b=stack.pop(); a=stack.pop(); stack.append(eval_expr('shl',a,b))
[codex:821729]     elif name=='SUB':
[codex:821729]         b=stack.pop(); a=stack.pop(); stack.append(eval_expr('sub',a,b))
[codex:821729]     elif name=='AND':
[codex:821729]         b=stack.pop(); a=stack.pop(); stack.append(eval_expr('and',a,b))
[codex:821729]     elif name=='NOT':
[codex:821729]         a=stack.pop(); stack.append(eval_expr('not',a))
[codex:821729]     elif name=='ADD':
[codex:821729]         b=stack.pop(); a=stack.pop(); stack.append(eval_expr('add',a,b))
[codex:821729]     elif name=='ISZERO':
[codex:821729]         a=stack.pop(); stack.append(eval_expr('iszero',a))
[codex:821729]     elif name=='EXTCODESIZE':
[codex:821729]         stack.pop(); stack.append('extcodesize')
[codex:821729]     elif name=='JUMPI':
[codex:821729]         # ignore control; just pop dest+cond
[codex:821729]         dest=stack.pop(); cond=stack.pop();
[codex:821729]         # keep note
[codex:821729]         stack.append(f\"jump_if({cond}->{dest})\")
[codex:821729]     elif name=='SHA3':
[codex:821729]         # pops 2
[codex:821729]         b=stack.pop(); a=stack.pop(); stack.append(eval_expr('sha3',a,b))
[codex:821729]     elif name in ('STATICCALL','GAS'):
[codex:821729]         # skip
[codex:821729]         if name=='STATICCALL':
[codex:821729]             # pops 6? but we stop before
[codex:821729]             pass
[codex:821729]     # increment pc
[codex:821729]     # compute next pc
[codex:821729]     # find next op in ops list
[codex:821729]     idx=next(i for i,(p,_,__) in enumerate(ops) if p==pc)
[codex:821729]     if idx+1>=len(ops): break
[codex:821729]     pc=ops[idx+1][0]
[codex:821729] 
[codex:821729] print('mem stores:')
[codex:821729] for k,v in mem.items():
[codex:821729]     print(k,'=',v)
[codex:821729] print('stack end',stack[-5:])
[codex:821729] PY" in /tmp/codex-multi-t27exkc3 succeeded in 30ms:
[codex:821729] mem stores:
[codex:821729] shl(158155341, 226) = m
[codex:821729] and(not(sub(1, shl(1, 224))), 0) = add(4, m)
[codex:821729] stack end ['m', 'and(sub(1, shl(1, 160)), iszero(iszero(and(slot2, sub(1, shl(1, 160))))))', 'iszero(extcodesize)', 'jump_if(iszero(iszero(extcodesize))->886)', 0]
[codex:821729] 
[codex:821729] thinking
[codex:821729] **Analyzing bytecode for exploitability**
[codex:821729] 
[codex:821729] I'm carefully checking the bytecode for any concrete, state-independent exploit paths—especially around module authorization, initialization safeguards, and calls like delegatecall or external value transfers. It looks like the contract enforces strong access controls, and no obvious code-only vulnerability stands out. I'll prepare a JSON report reflecting no findings while explaining the reasoning.
[codex:821729] codex
[codex:821729] {"no_findings":true,"summary":"No concrete, state-independent profit extraction path is evident from the runtime bytecode. Value-transfer and delegatecall paths are gated behind the module authorization mapping, and the one-time initializer is state-gated (owner/modules must be unset).","findings":[]}
[codex:821729] tokens used
[codex:821729] 91,187
[codex:821729] {"no_findings":true,"summary":"No concrete, state-independent profit extraction path is evident from the runtime bytecode. Value-transfer and delegatecall paths are gated behind the module authorization mapping, and the one-time initializer is state-gated (owner/modules must be unset).","findings":[]}

{
    "codex": {
        "ran_at": "2026-01-03T01:34:37.654386+00:00",
        "returncode": 0
    },
    "summary": "No concrete, state-independent profit extraction path is evident from the runtime bytecode. Value-transfer and delegatecall paths are gated behind the module authorization mapping, and the one-time initializer is state-gated (owner/modules must be unset).",
    "raw_final": {
        "summary": "No concrete, state-independent profit extraction path is evident from the runtime bytecode. Value-transfer and delegatecall paths are gated behind the module authorization mapping, and the one-time initializer is state-gated (owner/modules must be unset).",
        "findings": [],
        "no_findings": true
    },
    "no_findings": true,
    "schema_version": 1
}

00000000: PUSH1 0x80
00000002: PUSH1 0x40
00000004: MSTORE
00000005: PUSH1 0x04
00000007: CALLDATASIZE
00000008: LT
00000009: PUSH2 0x0085
0000000c: JUMPI
0000000d: PUSH1 0x00
0000000f: CALLDATALOAD
00000010: PUSH1 0xe0
00000012: SHR
00000013: DUP1
00000014: PUSH4 0x13af4035
00000019: EQ
0000001a: PUSH2 0x018b
0000001d: JUMPI
0000001e: DUP1
0000001f: PUSH4 0x13da30b2
00000024: EQ
00000025: PUSH2 0x01ad
00000028: JUMPI
00000029: DUP1
0000002a: PUSH4 0x1f17732d
0000002f: EQ
00000030: PUSH2 0x01cd
00000033: JUMPI
00000034: DUP1
00000035: PUSH4 0x3c5a3cea
0000003a: EQ
0000003b: PUSH2 0x01ed
0000003e: JUMPI
0000003f: DUP1
00000040: PUSH4 0x5f54892b
00000045: EQ
00000046: PUSH2 0x020d
00000049: JUMPI
0000004a: DUP1
0000004b: PUSH4 0x6e474be7
00000050: EQ
00000051: PUSH2 0x0243
00000054: JUMPI
00000055: DUP1
00000056: PUSH4 0x8da5cb5b
0000005b: EQ
0000005c: PUSH2 0x0263
0000005f: JUMPI
00000060: DUP1
00000061: PUSH4 0x8f6f0332
00000066: EQ
00000067: PUSH2 0x0283
0000006a: JUMPI
0000006b: DUP1
0000006c: PUSH4 0xd6eb1bbf
00000071: EQ
00000072: PUSH2 0x02b0
00000075: JUMPI
00000076: DUP1
00000077: PUSH4 0xf7e80e98
0000007c: EQ
0000007d: PUSH2 0x02f0
00000080: JUMPI
00000081: PUSH2 0x008c
00000084: JUMP
00000085: JUMPDEST
00000086: CALLDATASIZE
00000087: PUSH2 0x008c
0000008a: JUMPI
0000008b: STOP
0000008c: JUMPDEST
0000008d: PUSH1 0x00
0000008f: PUSH2 0x00a3
00000092: PUSH1 0x00
00000094: CALLDATALOAD
00000095: PUSH1 0x01
00000097: PUSH1 0x01
00000099: PUSH1 0xe0
0000009b: SHL
0000009c: SUB
0000009d: NOT
0000009e: AND
0000009f: PUSH2 0x0314
000000a2: JUMP
000000a3: JUMPDEST
000000a4: SWAP1
000000a5: POP
000000a6: PUSH1 0x01
000000a8: PUSH1 0x01
000000aa: PUSH1 0xa0
000000ac: SHL
000000ad: SUB
000000ae: DUP2
000000af: AND
000000b0: PUSH2 0x00fd
000000b3: JUMPI
000000b4: CALLER
000000b5: PUSH1 0x01
000000b7: PUSH1 0x01
000000b9: PUSH1 0xa0
000000bb: SHL
000000bc: SUB
000000bd: AND
000000be: CALLVALUE
000000bf: PUSH32 0x606834f57405380c4fb88d1f4850326ad3885f014bab3b568dfbf7a041eef738
000000e0: PUSH1 0x00
000000e2: CALLDATASIZE
000000e3: PUSH1 0x40
000000e5: MLOAD
000000e6: PUSH2 0x00f0
000000e9: SWAP3
000000ea: SWAP2
000000eb: SWAP1
000000ec: PUSH2 0x0d83
000000ef: JUMP
000000f0: JUMPDEST
000000f1: PUSH1 0x40
000000f3: MLOAD
000000f4: DUP1
000000f5: SWAP2
000000f6: SUB
000000f7: SWAP1
000000f8: LOG3
000000f9: PUSH2 0x0188
000000fc: JUMP
000000fd: JUMPDEST
000000fe: PUSH1 0x01
00000100: PUSH1 0x01
00000102: PUSH1 0xa0
00000104: SHL
00000105: SUB
00000106: DUP2
00000107: AND
00000108: PUSH1 0x00
0000010a: SWAP1
0000010b: DUP2
0000010c: MSTORE
0000010d: PUSH1 0x01
0000010f: PUSH1 0x20
00000111: MSTORE
00000112: PUSH1 0x40
00000114: SWAP1
00000115: KECCAK256
00000116: SLOAD
00000117: PUSH1 0xff
00000119: AND
0000011a: PUSH2 0x0164
0000011d: JUMPI
0000011e: PUSH1 0x40
00000120: MLOAD
00000121: PUSH3 0x461bcd
00000125: PUSH1 0xe5
00000127: SHL
00000128: DUP2
00000129: MSTORE
0000012a: PUSH1 0x20
0000012c: PUSH1 0x04
0000012e: DUP3
0000012f: ADD
00000130: MSTORE
00000131: PUSH1 0x17
00000133: PUSH1 0x24
00000135: DUP3
00000136: ADD
00000137: MSTORE
00000138: PUSH23 0x42573a20756e617574686f7269736564206d6f64756c65
00000150: PUSH1 0x48
00000152: SHL
00000153: PUSH1 0x44
00000155: DUP3
00000156: ADD
00000157: MSTORE
00000158: PUSH1 0x64
0000015a: ADD
0000015b: JUMPDEST
0000015c: PUSH1 0x40
0000015e: MLOAD
0000015f: DUP1
00000160: SWAP2
00000161: SUB
00000162: SWAP1
00000163: REVERT
00000164: JUMPDEST
00000165: CALLDATASIZE
00000166: PUSH1 0x00
00000168: DUP1
00000169: CALLDATACOPY
0000016a: PUSH1 0x00
0000016c: DUP1
0000016d: CALLDATASIZE
0000016e: PUSH1 0x00
00000170: DUP5
00000171: GAS
00000172: STATICCALL
00000173: RETURNDATASIZE
00000174: PUSH1 0x00
00000176: DUP1
00000177: RETURNDATACOPY
00000178: DUP1
00000179: DUP1
0000017a: ISZERO
0000017b: PUSH2 0x0183
0000017e: JUMPI
0000017f: RETURNDATASIZE
00000180: PUSH1 0x00
00000182: RETURN
00000183: JUMPDEST
00000184: RETURNDATASIZE
00000185: PUSH1 0x00
00000187: REVERT
00000188: JUMPDEST
00000189: POP
0000018a: STOP
0000018b: JUMPDEST
0000018c: CALLVALUE
0000018d: DUP1
0000018e: ISZERO
0000018f: PUSH2 0x0197
00000192: JUMPI
00000193: PUSH1 0x00
00000195: DUP1
00000196: REVERT
00000197: JUMPDEST
00000198: POP
00000199: PUSH2 0x01ab
0000019c: PUSH2 0x01a6
0000019f: CALLDATASIZE
000001a0: PUSH1 0x04
000001a2: PUSH2 0x0b9d
000001a5: JUMP
000001a6: JUMPDEST
000001a7: PUSH2 0x03c5
000001aa: JUMP
000001ab: JUMPDEST
000001ac: STOP
000001ad: JUMPDEST
000001ae: CALLVALUE
000001af: DUP1
000001b0: ISZERO
000001b1: PUSH2 0x01b9
000001b4: JUMPI
000001b5: PUSH1 0x00
000001b7: DUP1
000001b8: REVERT
000001b9: JUMPDEST
000001ba: POP
000001bb: PUSH2 0x01ab
000001be: PUSH2 0x01c8
000001c1: CALLDATASIZE
000001c2: PUSH1 0x04
000001c4: PUSH2 0x0c75
000001c7: JUMP
000001c8: JUMPDEST
000001c9: PUSH2 0x049d
000001cc: JUMP
000001cd: JUMPDEST
000001ce: CALLVALUE
000001cf: DUP1
000001d0: ISZERO
000001d1: PUSH2 0x01d9
000001d4: JUMPI
000001d5: PUSH1 0x00
000001d7: DUP1
000001d8: REVERT
000001d9: JUMPDEST
000001da: POP
000001db: PUSH2 0x01ab
000001de: PUSH2 0x01e8
000001e1: CALLDATASIZE
000001e2: PUSH1 0x04
000001e4: PUSH2 0x0c3f
000001e7: JUMP
000001e8: JUMPDEST
000001e9: PUSH2 0x0565
000001ec: JUMP
000001ed: JUMPDEST
000001ee: CALLVALUE
000001ef: DUP1
000001f0: ISZERO
000001f1: PUSH2 0x01f9
000001f4: JUMPI
000001f5: PUSH1 0x00
000001f7: DUP1
000001f8: REVERT
000001f9: JUMPDEST
000001fa: POP
000001fb: PUSH2 0x01ab
000001fe: PUSH2 0x0208
00000201: CALLDATASIZE
00000202: PUSH1 0x04
00000204: PUSH2 0x0bbe
00000207: JUMP
00000208: JUMPDEST
00000209: PUSH2 0x0728
0000020c: JUMP
0000020d: JUMPDEST
0000020e: CALLVALUE
0000020f: DUP1
00000210: ISZERO
00000211: PUSH2 0x0219
00000214: JUMPI
00000215: PUSH1 0x00
00000217: DUP1
00000218: REVERT
00000219: JUMPDEST
0000021a: POP
0000021b: PUSH2 0x022d
0000021e: PUSH2 0x0228
00000221: CALLDATASIZE
00000222: PUSH1 0x04
00000224: PUSH2 0x0d45
00000227: JUMP
00000228: JUMPDEST
00000229: PUSH2 0x0314
0000022c: JUMP
0000022d: JUMPDEST
0000022e: PUSH1 0x40
00000230: MLOAD
00000231: PUSH2 0x023a
00000234: SWAP2
00000235: SWAP1
00000236: PUSH2 0x0d6f
00000239: JUMP
0000023a: JUMPDEST
0000023b: PUSH1 0x40
0000023d: MLOAD
0000023e: DUP1
0000023f: SWAP2
00000240: SUB
00000241: SWAP1
00000242: RETURN
00000243: JUMPDEST
00000244: CALLVALUE
00000245: DUP1
00000246: ISZERO
00000247: PUSH2 0x024f
0000024a: JUMPI
0000024b: PUSH1 0x00
0000024d: DUP1
0000024e: REVERT
0000024f: JUMPDEST
00000250: POP
00000251: PUSH1 0x02
00000253: SLOAD
00000254: PUSH2 0x022d
00000257: SWAP1
00000258: PUSH1 0x01
0000025a: PUSH1 0x01
0000025c: PUSH1 0xa0
0000025e: SHL
0000025f: SUB
00000260: AND
00000261: DUP2
00000262: JUMP
00000263: JUMPDEST
00000264: CALLVALUE
00000265: DUP1
00000266: ISZERO
00000267: PUSH2 0x026f
0000026a: JUMPI
0000026b: PUSH1 0x00
0000026d: DUP1
0000026e: REVERT
0000026f: JUMPDEST
00000270: POP
00000271: PUSH1 0x00
00000273: SLOAD
00000274: PUSH2 0x022d
00000277: SWAP1
00000278: PUSH1 0x01
0000027a: PUSH1 0x01
0000027c: PUSH1 0xa0
0000027e: SHL
0000027f: SUB
00000280: AND
00000281: DUP2
00000282: JUMP
00000283: JUMPDEST
00000284: CALLVALUE
00000285: DUP1
00000286: ISZERO
00000287: PUSH2 0x028f
0000028a: JUMPI
0000028b: PUSH1 0x00
0000028d: DUP1
0000028e: REVERT
0000028f: JUMPDEST
00000290: POP
00000291: PUSH2 0x02a3
00000294: PUSH2 0x029e
00000297: CALLDATASIZE
00000298: PUSH1 0x04
0000029a: PUSH2 0x0ca7
0000029d: JUMP
0000029e: JUMPDEST
0000029f: PUSH2 0x0a72
000002a2: JUMP
000002a3: JUMPDEST
000002a4: PUSH1 0x40
000002a6: MLOAD
000002a7: PUSH2 0x023a
000002aa: SWAP2
000002ab: SWAP1
000002ac: PUSH2 0x0db2
000002af: JUMP
000002b0: JUMPDEST
000002b1: CALLVALUE
000002b2: DUP1
000002b3: ISZERO
000002b4: PUSH2 0x02bc
000002b7: JUMPI
000002b8: PUSH1 0x00
000002ba: DUP1
000002bb: REVERT
000002bc: JUMPDEST
000002bd: POP
000002be: PUSH2 0x02e0
000002c1: PUSH2 0x02cb
000002c4: CALLDATASIZE
000002c5: PUSH1 0x04
000002c7: PUSH2 0x0b9d
000002ca: JUMP
000002cb: JUMPDEST
000002cc: PUSH1 0x01
000002ce: PUSH1 0x20
000002d0: MSTORE
000002d1: PUSH1 0x00
000002d3: SWAP1
000002d4: DUP2
000002d5: MSTORE
000002d6: PUSH1 0x40
000002d8: SWAP1
000002d9: KECCAK256
000002da: SLOAD
000002db: PUSH1 0xff
000002dd: AND
000002de: DUP2
000002df: JUMP
000002e0: JUMPDEST
000002e1: PUSH1 0x40
000002e3: MLOAD
000002e4: SWAP1
000002e5: ISZERO
000002e6: ISZERO
000002e7: DUP2
000002e8: MSTORE
000002e9: PUSH1 0x20
000002eb: ADD
000002ec: PUSH2 0x023a
000002ef: JUMP
000002f0: JUMPDEST
000002f1: CALLVALUE
000002f2: DUP1
000002f3: ISZERO
000002f4: PUSH2 0x02fc
000002f7: JUMPI
000002f8: PUSH1 0x00
000002fa: DUP1
000002fb: REVERT
000002fc: JUMPDEST
000002fd: POP
000002fe: PUSH2 0x0306
00000301: PUSH1 0x03
00000303: SLOAD
00000304: DUP2
00000305: JUMP
00000306: JUMPDEST
00000307: PUSH1 0x40
00000309: MLOAD
0000030a: SWAP1
0000030b: DUP2
0000030c: MSTORE
0000030d: PUSH1 0x20
0000030f: ADD
00000310: PUSH2 0x023a
00000313: JUMP
00000314: JUMPDEST
00000315: PUSH1 0x02
00000317: SLOAD
00000318: PUSH1 0x00
0000031a: SWAP1
0000031b: PUSH1 0x01
0000031d: PUSH1 0x01
0000031f: PUSH1 0xa0
00000321: SHL
00000322: SUB
00000323: AND
00000324: DUP1
00000325: ISZERO
00000326: DUP1
00000327: ISZERO
00000328: SWAP1
00000329: PUSH2 0x03ae
0000032c: JUMPI
0000032d: POP
0000032e: PUSH1 0x40
00000330: MLOAD
00000331: PUSH4 0x096d424d
00000336: PUSH1 0xe2
00000338: SHL
00000339: DUP2
0000033a: MSTORE
0000033b: PUSH1 0x01
0000033d: PUSH1 0x01
0000033f: PUSH1 0xe0
00000341: SHL
00000342: SUB
00000343: NOT
00000344: DUP5
00000345: AND
00000346: PUSH1 0x04
00000348: DUP3
00000349: ADD
0000034a: MSTORE
0000034b: PUSH1 0x01
0000034d: PUSH1 0x01
0000034f: PUSH1 0xa0
00000351: SHL
00000352: SUB
00000353: DUP3
00000354: AND
00000355: SWAP1
00000356: PUSH4 0x25b50934
0000035b: SWAP1
0000035c: PUSH1 0x24
0000035e: ADD
0000035f: PUSH1 0x20
00000361: PUSH1 0x40
00000363: MLOAD
00000364: DUP1
00000365: DUP4
00000366: SUB
00000367: DUP2
00000368: DUP7
00000369: DUP1
0000036a: EXTCODESIZE
0000036b: ISZERO
0000036c: DUP1
0000036d: ISZERO
0000036e: PUSH2 0x0376
00000371: JUMPI
00000372: PUSH1 0x00
00000374: DUP1
00000375: REVERT
00000376: JUMPDEST
00000377: POP
00000378: GAS
00000379: STATICCALL
0000037a: ISZERO
0000037b: DUP1
0000037c: ISZERO
0000037d: PUSH2 0x038a
00000380: JUMPI
00000381: RETURNDATASIZE
00000382: PUSH1 0x00
00000384: DUP1
00000385: RETURNDATACOPY
00000386: RETURNDATASIZE
00000387: PUSH1 0x00
00000389: REVERT
0000038a: JUMPDEST
0000038b: POP
0000038c: POP
0000038d: POP
0000038e: POP
0000038f: PUSH1 0x40
00000391: MLOAD
00000392: RETURNDATASIZE
00000393: PUSH1 0x1f
00000395: NOT
00000396: PUSH1 0x1f
00000398: DUP3
00000399: ADD
0000039a: AND
0000039b: DUP3
0000039c: ADD
0000039d: DUP1
0000039e: PUSH1 0x40
000003a0: MSTORE
000003a1: POP
000003a2: DUP2
000003a3: ADD
000003a4: SWAP1
000003a5: PUSH2 0x03ae
000003a8: SWAP2
000003a9: SWAP1
000003aa: PUSH2 0x0d29
000003ad: JUMP
000003ae: JUMPDEST
000003af: ISZERO
000003b0: PUSH2 0x03ba
000003b3: JUMPI
000003b4: SWAP1
000003b5: POP
000003b6: PUSH2 0x03c0
000003b9: JUMP
000003ba: JUMPDEST
000003bb: PUSH1 0x00
000003bd: SWAP2
000003be: POP
000003bf: POP
000003c0: JUMPDEST
000003c1: SWAP2
000003c2: SWAP1
000003c3: POP
000003c4: JUMP
000003c5: JUMPDEST
000003c6: CALLER
000003c7: PUSH1 0x00
000003c9: SWAP1
000003ca: DUP2
000003cb: MSTORE
000003cc: PUSH1 0x01
000003ce: PUSH1 0x20
000003d0: MSTORE
000003d1: PUSH1 0x40
000003d3: SWAP1
000003d4: KECCAK256
000003d5: SLOAD
000003d6: PUSH1 0xff
000003d8: AND
000003d9: PUSH2 0x03f4
000003dc: JUMPI
000003dd: PUSH1 0x40
000003df: MLOAD
000003e0: PUSH3 0x461bcd
000003e4: PUSH1 0xe5
000003e6: SHL
000003e7: DUP2
000003e8: MSTORE
000003e9: PUSH1 0x04
000003eb: ADD
000003ec: PUSH2 0x015b
000003ef: SWAP1
000003f0: PUSH2 0x0e05
000003f3: JUMP
000003f4: JUMPDEST
000003f5: PUSH1 0x01
000003f7: PUSH1 0x01
000003f9: PUSH1 0xa0
000003fb: SHL
000003fc: SUB
000003fd: DUP2
000003fe: AND
000003ff: PUSH2 0x0447
00000402: JUMPI
00000403: PUSH1 0x40
00000405: MLOAD
00000406: PUSH3 0x461bcd
0000040a: PUSH1 0xe5
0000040c: SHL
0000040d: DUP2
0000040e: MSTORE
0000040f: PUSH1 0x20
00000411: PUSH1 0x04
00000413: DUP3
00000414: ADD
00000415: MSTORE
00000416: PUSH1 0x1a
00000418: PUSH1 0x24
0000041a: DUP3
0000041b: ADD
0000041c: MSTORE
0000041d: PUSH26 0x1095ce881859191c995cdcc818d85b9b9bdd081899481b9d5b1b
00000438: PUSH1 0x32
0000043a: SHL
0000043b: PUSH1 0x44
0000043d: DUP3
0000043e: ADD
0000043f: MSTORE
00000440: PUSH1 0x64
00000442: ADD
00000443: PUSH2 0x015b
00000446: JUMP
00000447: JUMPDEST
00000448: PUSH1 0x00
0000044a: DUP1
0000044b: SLOAD
0000044c: PUSH1 0x01
0000044e: PUSH1 0x01
00000450: PUSH1 0xa0
00000452: SHL
00000453: SUB
00000454: NOT
00000455: AND
00000456: PUSH1 0x01
00000458: PUSH1 0x01
0000045a: PUSH1 0xa0
0000045c: SHL
0000045d: SUB
0000045e: DUP4
0000045f: AND
00000460: OR
00000461: SWAP1
00000462: SSTORE
00000463: PUSH1 0x40
00000465: MLOAD
00000466: PUSH32 0xa2ea9883a321a3e97b8266c2b078bfeec6d50c711ed71f874a90d500ae2eaf36
00000487: SWAP1
00000488: PUSH2 0x0492
0000048b: SWAP1
0000048c: DUP4
0000048d: SWAP1
0000048e: PUSH2 0x0d6f
00000491: JUMP
00000492: JUMPDEST
00000493: PUSH1 0x40
00000495: MLOAD
00000496: DUP1
00000497: SWAP2
00000498: SUB
00000499: SWAP1
0000049a: LOG1
0000049b: POP
0000049c: JUMP
0000049d: JUMPDEST
0000049e: CALLER
0000049f: PUSH1 0x00
000004a1: SWAP1
000004a2: DUP2
000004a3: MSTORE
000004a4: PUSH1 0x01
000004a6: PUSH1 0x20
000004a8: MSTORE
000004a9: PUSH1 0x40
000004ab: SWAP1
000004ac: KECCAK256
000004ad: SLOAD
000004ae: PUSH1 0xff
000004b0: AND
000004b1: PUSH2 0x04cc
000004b4: JUMPI
000004b5: PUSH1 0x40
000004b7: MLOAD
000004b8: PUSH3 0x461bcd
000004bc: PUSH1 0xe5
000004be: SHL
000004bf: DUP2
000004c0: MSTORE
000004c1: PUSH1 0x04
000004c3: ADD
000004c4: PUSH2 0x015b
000004c7: SWAP1
000004c8: PUSH2 0x0e05
000004cb: JUMP
000004cc: JUMPDEST
000004cd: PUSH1 0x02
000004cf: SLOAD
000004d0: PUSH1 0x01
000004d2: PUSH1 0x01
000004d4: PUSH1 0xa0
000004d6: SHL
000004d7: SUB
000004d8: DUP4
000004d9: DUP2
000004da: AND
000004db: SWAP2
000004dc: AND
000004dd: EQ
000004de: PUSH2 0x0561
000004e1: JUMPI
000004e2: PUSH1 0x01
000004e4: PUSH1 0x01
000004e6: PUSH1 0xa0
000004e8: SHL
000004e9: SUB
000004ea: DUP3
000004eb: AND
000004ec: PUSH1 0x00
000004ee: SWAP1
000004ef: DUP2
000004f0: MSTORE
000004f1: PUSH1 0x01
000004f3: PUSH1 0x20
000004f5: MSTORE
000004f6: PUSH1 0x40
000004f8: SWAP1
000004f9: KECCAK256
000004fa: SLOAD
000004fb: PUSH1 0xff
000004fd: AND
000004fe: PUSH2 0x0545
00000501: JUMPI
00000502: PUSH1 0x40
00000504: MLOAD
00000505: PUSH3 0x461bcd
00000509: PUSH1 0xe5
0000050b: SHL
0000050c: DUP2
0000050d: MSTORE
0000050e: PUSH1 0x20
00000510: PUSH1 0x04
00000512: DUP3
00000513: ADD
00000514: MSTORE
00000515: PUSH1 0x19
00000517: PUSH1 0x24
00000519: DUP3
0000051a: ADD
0000051b: MSTORE
0000051c: PUSH25 0x212b9d103ab730baba3437b934bd32b21032bc32b1baba37b9
00000536: PUSH1 0x39
00000538: SHL
00000539: PUSH1 0x44
0000053b: DUP3
0000053c: ADD
0000053d: MSTORE
0000053e: PUSH1 0x64
00000540: ADD
00000541: PUSH2 0x015b
00000544: JUMP
00000545: JUMPDEST
00000546: PUSH1 0x02
00000548: DUP1
00000549: SLOAD
0000054a: PUSH1 0x01
0000054c: PUSH1 0x01
0000054e: PUSH1 0xa0
00000550: SHL
00000551: SUB
00000552: NOT
00000553: AND
00000554: PUSH1 0x01
00000556: PUSH1 0x01
00000558: PUSH1 0xa0
0000055a: SHL
0000055b: SUB
0000055c: DUP5
0000055d: AND
0000055e: OR
0000055f: SWAP1
00000560: SSTORE
00000561: JUMPDEST
00000562: POP
00000563: POP
00000564: JUMP
00000565: JUMPDEST
00000566: CALLER
00000567: PUSH1 0x00
00000569: SWAP1
0000056a: DUP2
0000056b: MSTORE
0000056c: PUSH1 0x01
0000056e: PUSH1 0x20
00000570: MSTORE
00000571: PUSH1 0x40
00000573: SWAP1
00000574: KECCAK256
00000575: SLOAD
00000576: PUSH1 0xff
00000578: AND
00000579: PUSH2 0x0594
0000057c: JUMPI
0000057d: PUSH1 0x40
0000057f: MLOAD
00000580: PUSH3 0x461bcd
00000584: PUSH1 0xe5
00000586: SHL
00000587: DUP2
00000588: MSTORE
00000589: PUSH1 0x04
0000058b: ADD
0000058c: PUSH2 0x015b
0000058f: SWAP1
00000590: PUSH2 0x0e05
00000593: JUMP
00000594: JUMPDEST
00000595: PUSH1 0x01
00000597: PUSH1 0x01
00000599: PUSH1 0xa0
0000059b: SHL
0000059c: SUB
0000059d: DUP3
0000059e: AND
0000059f: PUSH1 0x00
000005a1: SWAP1
000005a2: DUP2
000005a3: MSTORE
000005a4: PUSH1 0x01
000005a6: PUSH1 0x20
000005a8: MSTORE
000005a9: PUSH1 0x40
000005ab: SWAP1
000005ac: KECCAK256
000005ad: SLOAD
000005ae: PUSH1 0xff
000005b0: AND
000005b1: ISZERO
000005b2: ISZERO
000005b3: DUP2
000005b4: ISZERO
000005b5: ISZERO
000005b6: EQ
000005b7: PUSH2 0x0561
000005ba: JUMPI
000005bb: DUP2
000005bc: PUSH1 0x01
000005be: PUSH1 0x01
000005c0: PUSH1 0xa0
000005c2: SHL
000005c3: SUB
000005c4: AND
000005c5: PUSH32 0x8da3ff870ae294081392139550e167f1f31f277f22015ee22fbffdbd7758f4e1
000005e6: DUP3
000005e7: PUSH1 0x40
000005e9: MLOAD
000005ea: PUSH2 0x05f7
000005ed: SWAP2
000005ee: ISZERO
000005ef: ISZERO
000005f0: DUP2
000005f1: MSTORE
000005f2: PUSH1 0x20
000005f4: ADD
000005f5: SWAP1
000005f6: JUMP
000005f7: JUMPDEST
000005f8: PUSH1 0x40
000005fa: MLOAD
000005fb: DUP1
000005fc: SWAP2
000005fd: SUB
000005fe: SWAP1
000005ff: LOG2
00000600: PUSH1 0x01
00000602: DUP2
00000603: ISZERO
00000604: ISZERO
00000605: EQ
00000606: ISZERO
00000607: PUSH2 0x069f
0000060a: JUMPI
0000060b: PUSH1 0x01
0000060d: PUSH1 0x03
0000060f: PUSH1 0x00
00000611: DUP3
00000612: DUP3
00000613: SLOAD
00000614: PUSH2 0x061d
00000617: SWAP2
00000618: SWAP1
00000619: PUSH2 0x0e38
0000061c: JUMP
0000061d: JUMPDEST
0000061e: SWAP1
0000061f: SWAP2
00000620: SSTORE
00000621: POP
00000622: POP
00000623: PUSH1 0x01
00000625: PUSH1 0x01
00000627: PUSH1 0xa0
00000629: SHL
0000062a: SUB
0000062b: DUP3
0000062c: AND
0000062d: PUSH1 0x00
0000062f: DUP2
00000630: DUP2
00000631: MSTORE
00000632: PUSH1 0x01
00000634: PUSH1 0x20
00000636: DUP2
00000637: SWAP1
00000638: MSTORE
00000639: PUSH1 0x40
0000063b: SWAP2
0000063c: DUP3
0000063d: SWAP1
0000063e: KECCAK256
0000063f: DUP1
00000640: SLOAD
00000641: PUSH1 0xff
00000643: NOT
00000644: AND
00000645: SWAP1
00000646: SWAP2
00000647: OR
00000648: SWAP1
00000649: SSTORE
0000064a: MLOAD
0000064b: PUSH4 0x066ad14f
00000650: PUSH1 0xe2
00000652: SHL
00000653: DUP2
00000654: MSTORE
00000655: PUSH4 0x19ab453c
0000065a: SWAP1
0000065b: PUSH2 0x0668
0000065e: SWAP1
0000065f: ADDRESS
00000660: SWAP1
00000661: PUSH1 0x04
00000663: ADD
00000664: PUSH2 0x0d6f
00000667: JUMP
00000668: JUMPDEST
00000669: PUSH1 0x00
0000066b: PUSH1 0x40
0000066d: MLOAD
0000066e: DUP1
0000066f: DUP4
00000670: SUB
00000671: DUP2
00000672: PUSH1 0x00
00000674: DUP8
00000675: DUP1
00000676: EXTCODESIZE
00000677: ISZERO
00000678: DUP1
00000679: ISZERO
0000067a: PUSH2 0x0682
0000067d: JUMPI
0000067e: PUSH1 0x00
00000680: DUP1
00000681: REVERT
00000682: JUMPDEST
00000683: POP
00000684: GAS
00000685: CALL
00000686: ISZERO
00000687: DUP1
00000688: ISZERO
00000689: PUSH2 0x0696
0000068c: JUMPI
0000068d: RETURNDATASIZE
0000068e: PUSH1 0x00
00000690: DUP1
00000691: RETURNDATACOPY
00000692: RETURNDATASIZE
00000693: PUSH1 0x00
00000695: REVERT
00000696: JUMPDEST
00000697: POP
00000698: POP
00000699: POP
0000069a: POP
0000069b: PUSH2 0x0561
0000069e: JUMP
0000069f: JUMPDEST
000006a0: PUSH1 0x01
000006a2: PUSH1 0x03
000006a4: PUSH1 0x00
000006a6: DUP3
000006a7: DUP3
000006a8: SLOAD
000006a9: PUSH2 0x06b2
000006ac: SWAP2
000006ad: SWAP1
000006ae: PUSH2 0x0e50
000006b1: JUMP
000006b2: JUMPDEST
000006b3: SWAP1
000006b4: SWAP2
000006b5: SSTORE
000006b6: POP
000006b7: POP
000006b8: PUSH1 0x03
000006ba: SLOAD
000006bb: PUSH2 0x0706
000006be: JUMPI
000006bf: PUSH1 0x40
000006c1: MLOAD
000006c2: PUSH3 0x461bcd
000006c6: PUSH1 0xe5
000006c8: SHL
000006c9: DUP2
000006ca: MSTORE
000006cb: PUSH1 0x20
000006cd: PUSH1 0x04
000006cf: DUP3
000006d0: ADD
000006d1: MSTORE
000006d2: PUSH1 0x1d
000006d4: PUSH1 0x24
000006d6: DUP3
000006d7: ADD
000006d8: MSTORE
000006d9: PUSH32 0x42573a2063616e6e6f742072656d6f7665206c617374206d6f64756c65000000
000006fa: PUSH1 0x44
000006fc: DUP3
000006fd: ADD
000006fe: MSTORE
000006ff: PUSH1 0x64
00000701: ADD
00000702: PUSH2 0x015b
00000705: JUMP
00000706: JUMPDEST
00000707: POP
00000708: PUSH1 0x01
0000070a: PUSH1 0x01
0000070c: PUSH1 0xa0
0000070e: SHL
0000070f: SUB
00000710: AND
00000711: PUSH1 0x00
00000713: SWAP1
00000714: DUP2
00000715: MSTORE
00000716: PUSH1 0x01
00000718: PUSH1 0x20
0000071a: MSTORE
0000071b: PUSH1 0x40
0000071d: SWAP1
0000071e: KECCAK256
0000071f: DUP1
00000720: SLOAD
00000721: PUSH1 0xff
00000723: NOT
00000724: AND
00000725: SWAP1
00000726: SSTORE
00000727: JUMP
00000728: JUMPDEST
00000729: PUSH1 0x00
0000072b: SLOAD
0000072c: PUSH1 0x01
0000072e: PUSH1 0x01
00000730: PUSH1 0xa0
00000732: SHL
00000733: SUB
00000734: AND
00000735: ISZERO
00000736: DUP1
00000737: ISZERO
00000738: PUSH2 0x0741
0000073b: JUMPI
0000073c: POP
0000073d: PUSH1 0x03
0000073f: SLOAD
00000740: ISZERO
00000741: JUMPDEST
00000742: PUSH2 0x078d
00000745: JUMPI
00000746: PUSH1 0x40
00000748: MLOAD
00000749: PUSH3 0x461bcd
0000074d: PUSH1 0xe5
0000074f: SHL
00000750: DUP2
00000751: MSTORE
00000752: PUSH1 0x20
00000754: PUSH1 0x04
00000756: DUP3
00000757: ADD
00000758: MSTORE
00000759: PUSH1 0x1e
0000075b: PUSH1 0x24
0000075d: DUP3
0000075e: ADD
0000075f: MSTORE
00000760: PUSH32 0x42573a2077616c6c657420616c726561647920696e697469616c697365640000
00000781: PUSH1 0x44
00000783: DUP3
00000784: ADD
00000785: MSTORE
00000786: PUSH1 0x64
00000788: ADD
00000789: PUSH2 0x015b
0000078c: JUMP
0000078d: JUMPDEST
0000078e: DUP1
0000078f: PUSH2 0x07ce
00000792: JUMPI
00000793: PUSH1 0x40
00000795: MLOAD
00000796: PUSH3 0x461bcd
0000079a: PUSH1 0xe5
0000079c: SHL
0000079d: DUP2
0000079e: MSTORE
0000079f: PUSH1 0x20
000007a1: PUSH1 0x04
000007a3: DUP3
000007a4: ADD
000007a5: MSTORE
000007a6: PUSH1 0x11
000007a8: PUSH1 0x24
000007aa: DUP3
000007ab: ADD
000007ac: MSTORE
000007ad: PUSH17 0x42573a20656d707479206d6f64756c6573
000007bf: PUSH1 0x78
000007c1: SHL
000007c2: PUSH1 0x44
000007c4: DUP3
000007c5: ADD
000007c6: MSTORE
000007c7: PUSH1 0x64
000007c9: ADD
000007ca: PUSH2 0x015b
000007cd: JUMP
000007ce: JUMPDEST
000007cf: PUSH1 0x00
000007d1: DUP1
000007d2: SLOAD
000007d3: PUSH1 0x01
000007d5: PUSH1 0x01
000007d7: PUSH1 0xa0
000007d9: SHL
000007da: SUB
000007db: NOT
000007dc: AND
000007dd: PUSH1 0x01
000007df: PUSH1 0x01
000007e1: PUSH1 0xa0
000007e3: SHL
000007e4: SUB
000007e5: DUP6
000007e6: AND
000007e7: OR
000007e8: DUP2
000007e9: SSTORE
000007ea: PUSH1 0x03
000007ec: DUP3
000007ed: SWAP1
000007ee: SSTORE
000007ef: JUMPDEST
000007f0: DUP2
000007f1: DUP2
000007f2: LT
000007f3: ISZERO
000007f4: PUSH2 0x0a18
000007f7: JUMPI
000007f8: PUSH1 0x01
000007fa: PUSH1 0x00
000007fc: DUP5
000007fd: DUP5
000007fe: DUP5
000007ff: DUP2
00000800: DUP2
00000801: LT
00000802: PUSH2 0x081b
00000805: JUMPI
00000806: PUSH4 0x4e487b71
0000080b: PUSH1 0xe0
0000080d: SHL
0000080e: PUSH1 0x00
00000810: MSTORE
00000811: PUSH1 0x32
00000813: PUSH1 0x04
00000815: MSTORE
00000816: PUSH1 0x24
00000818: PUSH1 0x00
0000081a: REVERT
0000081b: JUMPDEST
0000081c: SWAP1
0000081d: POP
0000081e: PUSH1 0x20
00000820: MUL
00000821: ADD
00000822: PUSH1 0x20
00000824: DUP2
00000825: ADD
00000826: SWAP1
00000827: PUSH2 0x0830
0000082a: SWAP2
0000082b: SWAP1
0000082c: PUSH2 0x0b9d
0000082f: JUMP
00000830: JUMPDEST
00000831: PUSH1 0x01
00000833: PUSH1 0x01
00000835: PUSH1 0xa0
00000837: SHL
00000838: SUB
00000839: AND
0000083a: DUP2
0000083b: MSTORE
0000083c: PUSH1 0x20
0000083e: DUP2
0000083f: ADD
00000840: SWAP2
00000841: SWAP1
00000842: SWAP2
00000843: MSTORE
00000844: PUSH1 0x40
00000846: ADD
00000847: PUSH1 0x00
00000849: KECCAK256
0000084a: SLOAD
0000084b: PUSH1 0xff
0000084d: AND
0000084e: ISZERO
0000084f: PUSH2 0x0898
00000852: JUMPI
00000853: PUSH1 0x40
00000855: MLOAD
00000856: PUSH3 0x461bcd
0000085a: PUSH1 0xe5
0000085c: SHL
0000085d: DUP2
0000085e: MSTORE
0000085f: PUSH1 0x20
00000861: PUSH1 0x04
00000863: DUP3
00000864: ADD
00000865: MSTORE
00000866: PUSH1 0x1b
00000868: PUSH1 0x24
0000086a: DUP3
0000086b: ADD
0000086c: MSTORE
0000086d: PUSH27 0x1095ce881b5bd91d5b19481a5cc8185b1c9958591e481859191959
00000889: PUSH1 0x2a
0000088b: SHL
0000088c: PUSH1 0x44
0000088e: DUP3
0000088f: ADD
00000890: MSTORE
00000891: PUSH1 0x64
00000893: ADD
00000894: PUSH2 0x015b
00000897: JUMP
00000898: JUMPDEST
00000899: PUSH1 0x01
0000089b: DUP1
0000089c: PUSH1 0x00
0000089e: DUP6
0000089f: DUP6
000008a0: DUP6
000008a1: DUP2
000008a2: DUP2
000008a3: LT
000008a4: PUSH2 0x08bd
000008a7: JUMPI
000008a8: PUSH4 0x4e487b71
000008ad: PUSH1 0xe0
000008af: SHL
000008b0: PUSH1 0x00
000008b2: MSTORE
000008b3: PUSH1 0x32
000008b5: PUSH1 0x04
000008b7: MSTORE
000008b8: PUSH1 0x24
000008ba: PUSH1 0x00
000008bc: REVERT
000008bd: JUMPDEST
000008be: SWAP1
000008bf: POP
000008c0: PUSH1 0x20
000008c2: MUL
000008c3: ADD
000008c4: PUSH1 0x20
000008c6: DUP2
000008c7: ADD
000008c8: SWAP1
000008c9: PUSH2 0x08d2
000008cc: SWAP2
000008cd: SWAP1
000008ce: PUSH2 0x0b9d
000008d1: JUMP
000008d2: JUMPDEST
000008d3: PUSH1 0x01
000008d5: PUSH1 0x01
000008d7: PUSH1 0xa0
000008d9: SHL
000008da: SUB
000008db: AND
000008dc: DUP2
000008dd: MSTORE
000008de: PUSH1 0x20
000008e0: DUP2
000008e1: ADD
000008e2: SWAP2
000008e3: SWAP1
000008e4: SWAP2
000008e5: MSTORE
000008e6: PUSH1 0x40
000008e8: ADD
000008e9: PUSH1 0x00
000008eb: KECCAK256
000008ec: DUP1
000008ed: SLOAD
000008ee: PUSH1 0xff
000008f0: NOT
000008f1: AND
000008f2: SWAP2
000008f3: ISZERO
000008f4: ISZERO
000008f5: SWAP2
000008f6: SWAP1
000008f7: SWAP2
000008f8: OR
000008f9: SWAP1
000008fa: SSTORE
000008fb: DUP3
000008fc: DUP3
000008fd: DUP3
000008fe: DUP2
000008ff: DUP2
00000900: LT
00000901: PUSH2 0x091a
00000904: JUMPI
00000905: PUSH4 0x4e487b71
0000090a: PUSH1 0xe0
0000090c: SHL
0000090d: PUSH1 0x00
0000090f: MSTORE
00000910: PUSH1 0x32
00000912: PUSH1 0x04
00000914: MSTORE
00000915: PUSH1 0x24
00000917: PUSH1 0x00
00000919: REVERT
0000091a: JUMPDEST
0000091b: SWAP1
0000091c: POP
0000091d: PUSH1 0x20
0000091f: MUL
00000920: ADD
00000921: PUSH1 0x20
00000923: DUP2
00000924: ADD
00000925: SWAP1
00000926: PUSH2 0x092f
00000929: SWAP2
0000092a: SWAP1
0000092b: PUSH2 0x0b9d
0000092e: JUMP
0000092f: JUMPDEST
00000930: PUSH1 0x01
00000932: PUSH1 0x01
00000934: PUSH1 0xa0
00000936: SHL
00000937: SUB
00000938: AND
00000939: PUSH4 0x19ab453c
0000093e: ADDRESS
0000093f: PUSH1 0x40
00000941: MLOAD
00000942: DUP3
00000943: PUSH4 0xffffffff
00000948: AND
00000949: PUSH1 0xe0
0000094b: SHL
0000094c: DUP2
0000094d: MSTORE
0000094e: PUSH1 0x04
00000950: ADD
00000951: PUSH2 0x095a
00000954: SWAP2
00000955: SWAP1
00000956: PUSH2 0x0d6f
00000959: JUMP
0000095a: JUMPDEST
0000095b: PUSH1 0x00
0000095d: PUSH1 0x40
0000095f: MLOAD
00000960: DUP1
00000961: DUP4
00000962: SUB
00000963: DUP2
00000964: PUSH1 0x00
00000966: DUP8
00000967: DUP1
00000968: EXTCODESIZE
00000969: ISZERO
0000096a: DUP1
0000096b: ISZERO
0000096c: PUSH2 0x0974
0000096f: JUMPI
00000970: PUSH1 0x00
00000972: DUP1
00000973: REVERT
00000974: JUMPDEST
00000975: POP
00000976: GAS
00000977: CALL
00000978: ISZERO
00000979: DUP1
0000097a: ISZERO
0000097b: PUSH2 0x0988
0000097e: JUMPI
0000097f: RETURNDATASIZE
00000980: PUSH1 0x00
00000982: DUP1
00000983: RETURNDATACOPY
00000984: RETURNDATASIZE
00000985: PUSH1 0x00
00000987: REVERT
00000988: JUMPDEST
00000989: POP
0000098a: POP
0000098b: POP
0000098c: POP
0000098d: DUP3
0000098e: DUP3
0000098f: DUP3
00000990: DUP2
00000991: DUP2
00000992: LT
00000993: PUSH2 0x09ac
00000996: JUMPI
00000997: PUSH4 0x4e487b71
0000099c: PUSH1 0xe0
0000099e: SHL
0000099f: PUSH1 0x00
000009a1: MSTORE
000009a2: PUSH1 0x32
000009a4: PUSH1 0x04
000009a6: MSTORE
000009a7: PUSH1 0x24
000009a9: PUSH1 0x00
000009ab: REVERT
000009ac: JUMPDEST
000009ad: SWAP1
000009ae: POP
000009af: PUSH1 0x20
000009b1: MUL
000009b2: ADD
000009b3: PUSH1 0x20
000009b5: DUP2
000009b6: ADD
000009b7: SWAP1
000009b8: PUSH2 0x09c1
000009bb: SWAP2
000009bc: SWAP1
000009bd: PUSH2 0x0b9d
000009c0: JUMP
000009c1: JUMPDEST
000009c2: PUSH1 0x01
000009c4: PUSH1 0x01
000009c6: PUSH1 0xa0
000009c8: SHL
000009c9: SUB
000009ca: AND
000009cb: PUSH32 0x8da3ff870ae294081392139550e167f1f31f277f22015ee22fbffdbd7758f4e1
000009ec: PUSH1 0x01
000009ee: PUSH1 0x40
000009f0: MLOAD
000009f1: PUSH2 0x09fe
000009f4: SWAP2
000009f5: ISZERO
000009f6: ISZERO
000009f7: DUP2
000009f8: MSTORE
000009f9: PUSH1 0x20
000009fb: ADD
000009fc: SWAP1
000009fd: JUMP
000009fe: JUMPDEST
000009ff: PUSH1 0x40
00000a01: MLOAD
00000a02: DUP1
00000a03: SWAP2
00000a04: SUB
00000a05: SWAP1
00000a06: LOG2
00000a07: DUP1
00000a08: PUSH2 0x0a10
00000a0b: DUP2
00000a0c: PUSH2 0x0e67
00000a0f: JUMP
00000a10: JUMPDEST
00000a11: SWAP2
00000a12: POP
00000a13: POP
00000a14: PUSH2 0x07ef
00000a17: JUMP
00000a18: JUMPDEST
00000a19: POP
00000a1a: SELFBALANCE
00000a1b: ISZERO
00000a1c: PUSH2 0x0a6d
00000a1f: JUMPI
00000a20: PUSH1 0x00
00000a22: PUSH1 0x01
00000a24: PUSH1 0x01
00000a26: PUSH1 0xa0
00000a28: SHL
00000a29: SUB
00000a2a: AND
00000a2b: SELFBALANCE
00000a2c: PUSH32 0x606834f57405380c4fb88d1f4850326ad3885f014bab3b568dfbf7a041eef738
00000a4d: PUSH1 0x40
00000a4f: MLOAD
00000a50: PUSH2 0x0a64
00000a53: SWAP1
00000a54: PUSH1 0x20
00000a56: DUP1
00000a57: DUP3
00000a58: MSTORE
00000a59: PUSH1 0x00
00000a5b: SWAP1
00000a5c: DUP3
00000a5d: ADD
00000a5e: MSTORE
00000a5f: PUSH1 0x40
00000a61: ADD
00000a62: SWAP1
00000a63: JUMP
00000a64: JUMPDEST
00000a65: PUSH1 0x40
00000a67: MLOAD
00000a68: DUP1
00000a69: SWAP2
00000a6a: SUB
00000a6b: SWAP1
00000a6c: LOG3
00000a6d: JUMPDEST
00000a6e: POP
00000a6f: POP
00000a70: POP
00000a71: JUMP
00000a72: JUMPDEST
00000a73: CALLER
00000a74: PUSH1 0x00
00000a76: SWAP1
00000a77: DUP2
00000a78: MSTORE
00000a79: PUSH1 0x01
00000a7b: PUSH1 0x20
00000a7d: MSTORE
00000a7e: PUSH1 0x40
00000a80: SWAP1
00000a81: KECCAK256
00000a82: SLOAD
00000a83: PUSH1 0x60
00000a85: SWAP1
00000a86: PUSH1 0xff
00000a88: AND
00000a89: PUSH2 0x0aa4
00000a8c: JUMPI
00000a8d: PUSH1 0x40
00000a8f: MLOAD
00000a90: PUSH3 0x461bcd
00000a94: PUSH1 0xe5
00000a96: SHL
00000a97: DUP2
00000a98: MSTORE
00000a99: PUSH1 0x04
00000a9b: ADD
00000a9c: PUSH2 0x015b
00000a9f: SWAP1
00000aa0: PUSH2 0x0e05
00000aa3: JUMP
00000aa4: JUMPDEST
00000aa5: PUSH1 0x00
00000aa7: DUP6
00000aa8: PUSH1 0x01
00000aaa: PUSH1 0x01
00000aac: PUSH1 0xa0
00000aae: SHL
00000aaf: SUB
00000ab0: AND
00000ab1: DUP6
00000ab2: DUP6
00000ab3: DUP6
00000ab4: PUSH1 0x40
00000ab6: MLOAD
00000ab7: PUSH2 0x0ac1
00000aba: SWAP3
00000abb: SWAP2
00000abc: SWAP1
00000abd: PUSH2 0x0d5f
00000ac0: JUMP
00000ac1: JUMPDEST
00000ac2: PUSH1 0x00
00000ac4: PUSH1 0x40
00000ac6: MLOAD
00000ac7: DUP1
00000ac8: DUP4
00000ac9: SUB
00000aca: DUP2
00000acb: DUP6
00000acc: DUP8
00000acd: GAS
00000ace: CALL
00000acf: SWAP3
00000ad0: POP
00000ad1: POP
00000ad2: POP
00000ad3: RETURNDATASIZE
00000ad4: DUP1
00000ad5: PUSH1 0x00
00000ad7: DUP2
00000ad8: EQ
00000ad9: PUSH2 0x0afe
00000adc: JUMPI
00000add: PUSH1 0x40
00000adf: MLOAD
00000ae0: SWAP2
00000ae1: POP
00000ae2: PUSH1 0x1f
00000ae4: NOT
00000ae5: PUSH1 0x3f
00000ae7: RETURNDATASIZE
00000ae8: ADD
00000ae9: AND
00000aea: DUP3
00000aeb: ADD
00000aec: PUSH1 0x40
00000aee: MSTORE
00000aef: RETURNDATASIZE
00000af0: DUP3
00000af1: MSTORE
00000af2: RETURNDATASIZE
00000af3: PUSH1 0x00
00000af5: PUSH1 0x20
00000af7: DUP5
00000af8: ADD
00000af9: RETURNDATACOPY
00000afa: PUSH2 0x0b03
00000afd: JUMP
00000afe: JUMPDEST
00000aff: PUSH1 0x60
00000b01: SWAP2
00000b02: POP
00000b03: JUMPDEST
00000b04: POP
00000b05: SWAP3
00000b06: POP
00000b07: SWAP1
00000b08: POP
00000b09: DUP1
00000b0a: PUSH2 0x0b17
00000b0d: JUMPI
00000b0e: RETURNDATASIZE
00000b0f: PUSH1 0x00
00000b11: DUP1
00000b12: RETURNDATACOPY
00000b13: RETURNDATASIZE
00000b14: PUSH1 0x00
00000b16: REVERT
00000b17: JUMPDEST
00000b18: DUP5
00000b19: DUP7
00000b1a: PUSH1 0x01
00000b1c: PUSH1 0x01
00000b1e: PUSH1 0xa0
00000b20: SHL
00000b21: SUB
00000b22: AND
00000b23: CALLER
00000b24: PUSH1 0x01
00000b26: PUSH1 0x01
00000b28: PUSH1 0xa0
00000b2a: SHL
00000b2b: SUB
00000b2c: AND
00000b2d: PUSH32 0x7d2476ab50663f025cff0be85655bcf355f62768615c0c478f3cd5293f807365
00000b4e: DUP8
00000b4f: DUP8
00000b50: PUSH1 0x40
00000b52: MLOAD
00000b53: PUSH2 0x0b5d
00000b56: SWAP3
00000b57: SWAP2
00000b58: SWAP1
00000b59: PUSH2 0x0d83
00000b5c: JUMP
00000b5d: JUMPDEST
00000b5e: PUSH1 0x40
00000b60: MLOAD
00000b61: DUP1
00000b62: SWAP2
00000b63: SUB
00000b64: SWAP1
00000b65: LOG4
00000b66: POP
00000b67: SWAP5
00000b68: SWAP4
00000b69: POP
00000b6a: POP
00000b6b: POP
00000b6c: POP
00000b6d: JUMP
00000b6e: JUMPDEST
00000b6f: DUP1
00000b70: CALLDATALOAD
00000b71: PUSH1 0x01
00000b73: PUSH1 0x01
00000b75: PUSH1 0xa0
00000b77: SHL
00000b78: SUB
00000b79: DUP2
00000b7a: AND
00000b7b: DUP2
00000b7c: EQ
00000b7d: PUSH2 0x03c0
00000b80: JUMPI
00000b81: PUSH1 0x00
00000b83: DUP1
00000b84: REVERT
00000b85: JUMPDEST
00000b86: DUP1
00000b87: CALLDATALOAD
00000b88: PUSH1 0x01
00000b8a: PUSH1 0x01
00000b8c: PUSH1 0xe0
00000b8e: SHL
00000b8f: SUB
00000b90: NOT
00000b91: DUP2
00000b92: AND
00000b93: DUP2
00000b94: EQ
00000b95: PUSH2 0x03c0
00000b98: JUMPI
00000b99: PUSH1 0x00
00000b9b: DUP1
00000b9c: REVERT
00000b9d: JUMPDEST
00000b9e: PUSH1 0x00
00000ba0: PUSH1 0x20
00000ba2: DUP3
00000ba3: DUP5
00000ba4: SUB
00000ba5: SLT
00000ba6: ISZERO
00000ba7: PUSH2 0x0bae
00000baa: JUMPI
00000bab: DUP1
00000bac: DUP2
00000bad: REVERT
00000bae: JUMPDEST
00000baf: PUSH2 0x0bb7
00000bb2: DUP3
00000bb3: PUSH2 0x0b6e
00000bb6: JUMP
00000bb7: JUMPDEST
00000bb8: SWAP4
00000bb9: SWAP3
00000bba: POP
00000bbb: POP
00000bbc: POP
00000bbd: JUMP
00000bbe: JUMPDEST
00000bbf: PUSH1 0x00
00000bc1: DUP1
00000bc2: PUSH1 0x00
00000bc4: PUSH1 0x40
00000bc6: DUP5
00000bc7: DUP7
00000bc8: SUB
00000bc9: SLT
00000bca: ISZERO
00000bcb: PUSH2 0x0bd2
00000bce: JUMPI
00000bcf: DUP2
00000bd0: DUP3
00000bd1: REVERT
00000bd2: JUMPDEST
00000bd3: PUSH2 0x0bdb
00000bd6: DUP5
00000bd7: PUSH2 0x0b6e
00000bda: JUMP
00000bdb: JUMPDEST
00000bdc: SWAP3
00000bdd: POP
00000bde: PUSH1 0x20
00000be0: DUP5
00000be1: ADD
00000be2: CALLDATALOAD
00000be3: PUSH8 0xffffffffffffffff
00000bec: DUP1
00000bed: DUP3
00000bee: GT
00000bef: ISZERO
00000bf0: PUSH2 0x0bf7
00000bf3: JUMPI
00000bf4: DUP4
00000bf5: DUP5
00000bf6: REVERT
00000bf7: JUMPDEST
00000bf8: DUP2
00000bf9: DUP7
00000bfa: ADD
00000bfb: SWAP2
00000bfc: POP
00000bfd: DUP7
00000bfe: PUSH1 0x1f
00000c00: DUP4
00000c01: ADD
00000c02: SLT
00000c03: PUSH2 0x0c0a
00000c06: JUMPI
00000c07: DUP4
00000c08: DUP5
00000c09: REVERT
00000c0a: JUMPDEST
00000c0b: DUP2
00000c0c: CALLDATALOAD
00000c0d: DUP2
00000c0e: DUP2
00000c0f: GT
00000c10: ISZERO
00000c11: PUSH2 0x0c18
00000c14: JUMPI
00000c15: DUP5
00000c16: DUP6
00000c17: REVERT
00000c18: JUMPDEST
00000c19: DUP8
00000c1a: PUSH1 0x20
00000c1c: DUP3
00000c1d: PUSH1 0x05
00000c1f: SHL
00000c20: DUP6
00000c21: ADD
00000c22: ADD
00000c23: GT
00000c24: ISZERO
00000c25: PUSH2 0x0c2c
00000c28: JUMPI
00000c29: DUP5
00000c2a: DUP6
00000c2b: REVERT
00000c2c: JUMPDEST
00000c2d: PUSH1 0x20
00000c2f: DUP4
00000c30: ADD
00000c31: SWAP5
00000c32: POP
00000c33: DUP1
00000c34: SWAP4
00000c35: POP
00000c36: POP
00000c37: POP
00000c38: POP
00000c39: SWAP3
00000c3a: POP
00000c3b: SWAP3
00000c3c: POP
00000c3d: SWAP3
00000c3e: JUMP
00000c3f: JUMPDEST
00000c40: PUSH1 0x00
00000c42: DUP1
00000c43: PUSH1 0x40
00000c45: DUP4
00000c46: DUP6
00000c47: SUB
00000c48: SLT
00000c49: ISZERO
00000c4a: PUSH2 0x0c51
00000c4d: JUMPI
00000c4e: DUP2
00000c4f: DUP3
00000c50: REVERT
00000c51: JUMPDEST
00000c52: PUSH2 0x0c5a
00000c55: DUP4
00000c56: PUSH2 0x0b6e
00000c59: JUMP
00000c5a: JUMPDEST
00000c5b: SWAP2
00000c5c: POP
00000c5d: PUSH1 0x20
00000c5f: DUP4
00000c60: ADD
00000c61: CALLDATALOAD
00000c62: PUSH2 0x0c6a
00000c65: DUP2
00000c66: PUSH2 0x0e98
00000c69: JUMP
00000c6a: JUMPDEST
00000c6b: DUP1
00000c6c: SWAP2
00000c6d: POP
00000c6e: POP
00000c6f: SWAP3
00000c70: POP
00000c71: SWAP3
00000c72: SWAP1
00000c73: POP
00000c74: JUMP
00000c75: JUMPDEST
00000c76: PUSH1 0x00
00000c78: DUP1
00000c79: PUSH1 0x40
00000c7b: DUP4
00000c7c: DUP6
00000c7d: SUB
00000c7e: SLT
00000c7f: ISZERO
00000c80: PUSH2 0x0c87
00000c83: JUMPI
00000c84: DUP2
00000c85: DUP3
00000c86: REVERT
00000c87: JUMPDEST
00000c88: PUSH2 0x0c90
00000c8b: DUP4
00000c8c: PUSH2 0x0b6e
00000c8f: JUMP
00000c90: JUMPDEST
00000c91: SWAP2
00000c92: POP
00000c93: PUSH2 0x0c9e
00000c96: PUSH1 0x20
00000c98: DUP5
00000c99: ADD
00000c9a: PUSH2 0x0b85
00000c9d: JUMP
00000c9e: JUMPDEST
00000c9f: SWAP1
00000ca0: POP
00000ca1: SWAP3
00000ca2: POP
00000ca3: SWAP3
00000ca4: SWAP1
00000ca5: POP
00000ca6: JUMP
00000ca7: JUMPDEST
00000ca8: PUSH1 0x00
00000caa: DUP1
00000cab: PUSH1 0x00
00000cad: DUP1
00000cae: PUSH1 0x60
00000cb0: DUP6
00000cb1: DUP8
00000cb2: SUB
00000cb3: SLT
00000cb4: ISZERO
00000cb5: PUSH2 0x0cbc
00000cb8: JUMPI
00000cb9: DUP1
00000cba: DUP2
00000cbb: REVERT
00000cbc: JUMPDEST
00000cbd: PUSH2 0x0cc5
00000cc0: DUP6
00000cc1: PUSH2 0x0b6e
00000cc4: JUMP
00000cc5: JUMPDEST
00000cc6: SWAP4
00000cc7: POP
00000cc8: PUSH1 0x20
00000cca: DUP6
00000ccb: ADD
00000ccc: CALLDATALOAD
00000ccd: SWAP3
00000cce: POP
00000ccf: PUSH1 0x40
00000cd1: DUP6
00000cd2: ADD
00000cd3: CALLDATALOAD
00000cd4: PUSH8 0xffffffffffffffff
00000cdd: DUP1
00000cde: DUP3
00000cdf: GT
00000ce0: ISZERO
00000ce1: PUSH2 0x0ce8
00000ce4: JUMPI
00000ce5: DUP3
00000ce6: DUP4
00000ce7: REVERT
00000ce8: JUMPDEST
00000ce9: DUP2
00000cea: DUP8
00000ceb: ADD
00000cec: SWAP2
00000ced: POP
00000cee: DUP8
00000cef: PUSH1 0x1f
00000cf1: DUP4
00000cf2: ADD
00000cf3: SLT
00000cf4: PUSH2 0x0cfb
00000cf7: JUMPI
00000cf8: DUP3
00000cf9: DUP4
00000cfa: REVERT
00000cfb: JUMPDEST
00000cfc: DUP2
00000cfd: CALLDATALOAD
00000cfe: DUP2
00000cff: DUP2
00000d00: GT
00000d01: ISZERO
00000d02: PUSH2 0x0d09
00000d05: JUMPI
00000d06: DUP4
00000d07: DUP5
00000d08: REVERT
00000d09: JUMPDEST
00000d0a: DUP9
00000d0b: PUSH1 0x20
00000d0d: DUP3
00000d0e: DUP6
00000d0f: ADD
00000d10: ADD
00000d11: GT
00000d12: ISZERO
00000d13: PUSH2 0x0d1a
00000d16: JUMPI
00000d17: DUP4
00000d18: DUP5
00000d19: REVERT
00000d1a: JUMPDEST
00000d1b: SWAP6
00000d1c: SWAP9
00000d1d: SWAP5
00000d1e: SWAP8
00000d1f: POP
00000d20: POP
00000d21: PUSH1 0x20
00000d23: ADD
00000d24: SWAP5
00000d25: POP
00000d26: POP
00000d27: POP
00000d28: JUMP
00000d29: JUMPDEST
00000d2a: PUSH1 0x00
00000d2c: PUSH1 0x20
00000d2e: DUP3
00000d2f: DUP5
00000d30: SUB
00000d31: SLT
00000d32: ISZERO
00000d33: PUSH2 0x0d3a
00000d36: JUMPI
00000d37: DUP1
00000d38: DUP2
00000d39: REVERT
00000d3a: JUMPDEST
00000d3b: DUP2
00000d3c: MLOAD
00000d3d: PUSH2 0x0bb7
00000d40: DUP2
00000d41: PUSH2 0x0e98
00000d44: JUMP
00000d45: JUMPDEST
00000d46: PUSH1 0x00
00000d48: PUSH1 0x20
00000d4a: DUP3
00000d4b: DUP5
00000d4c: SUB
00000d4d: SLT
00000d4e: ISZERO
00000d4f: PUSH2 0x0d56
00000d52: JUMPI
00000d53: DUP1
00000d54: DUP2
00000d55: REVERT
00000d56: JUMPDEST
00000d57: PUSH2 0x0bb7
00000d5a: DUP3
00000d5b: PUSH2 0x0b85
00000d5e: JUMP
00000d5f: JUMPDEST
00000d60: PUSH1 0x00
00000d62: DUP3
00000d63: DUP5
00000d64: DUP4
00000d65: CALLDATACOPY
00000d66: SWAP2
00000d67: ADD
00000d68: SWAP1
00000d69: DUP2
00000d6a: MSTORE
00000d6b: SWAP2
00000d6c: SWAP1
00000d6d: POP
00000d6e: JUMP
00000d6f: JUMPDEST
00000d70: PUSH1 0x01
00000d72: PUSH1 0x01
00000d74: PUSH1 0xa0
00000d76: SHL
00000d77: SUB
00000d78: SWAP2
00000d79: SWAP1
00000d7a: SWAP2
00000d7b: AND
00000d7c: DUP2
00000d7d: MSTORE
00000d7e: PUSH1 0x20
00000d80: ADD
00000d81: SWAP1
00000d82: JUMP
00000d83: JUMPDEST
00000d84: PUSH1 0x00
00000d86: PUSH1 0x20
00000d88: DUP3
00000d89: MSTORE
00000d8a: DUP3
00000d8b: PUSH1 0x20
00000d8d: DUP4
00000d8e: ADD
00000d8f: MSTORE
00000d90: DUP3
00000d91: DUP5
00000d92: PUSH1 0x40
00000d94: DUP5
00000d95: ADD
00000d96: CALLDATACOPY
00000d97: DUP2
00000d98: DUP4
00000d99: ADD
00000d9a: PUSH1 0x40
00000d9c: SWAP1
00000d9d: DUP2
00000d9e: ADD
00000d9f: SWAP2
00000da0: SWAP1
00000da1: SWAP2
00000da2: MSTORE
00000da3: PUSH1 0x1f
00000da5: SWAP1
00000da6: SWAP3
00000da7: ADD
00000da8: PUSH1 0x1f
00000daa: NOT
00000dab: AND
00000dac: ADD
00000dad: ADD
00000dae: SWAP2
00000daf: SWAP1
00000db0: POP
00000db1: JUMP
00000db2: JUMPDEST
00000db3: PUSH1 0x00
00000db5: PUSH1 0x20
00000db7: DUP1
00000db8: DUP4
00000db9: MSTORE
00000dba: DUP4
00000dbb: MLOAD
00000dbc: DUP1
00000dbd: DUP3
00000dbe: DUP6
00000dbf: ADD
00000dc0: MSTORE
00000dc1: DUP3
00000dc2: JUMPDEST
00000dc3: DUP2
00000dc4: DUP2
00000dc5: LT
00000dc6: ISZERO
00000dc7: PUSH2 0x0dde
00000dca: JUMPI
00000dcb: DUP6
00000dcc: DUP2
00000dcd: ADD
00000dce: DUP4
00000dcf: ADD
00000dd0: MLOAD
00000dd1: DUP6
00000dd2: DUP3
00000dd3: ADD
00000dd4: PUSH1 0x40
00000dd6: ADD
00000dd7: MSTORE
00000dd8: DUP3
00000dd9: ADD
00000dda: PUSH2 0x0dc2
00000ddd: JUMP
00000dde: JUMPDEST
00000ddf: DUP2
00000de0: DUP2
00000de1: GT
00000de2: ISZERO
00000de3: PUSH2 0x0def
00000de6: JUMPI
00000de7: DUP4
00000de8: PUSH1 0x40
00000dea: DUP4
00000deb: DUP8
00000dec: ADD
00000ded: ADD
00000dee: MSTORE
00000def: JUMPDEST
00000df0: POP
00000df1: PUSH1 0x1f
00000df3: ADD
00000df4: PUSH1 0x1f
00000df6: NOT
00000df7: AND
00000df8: SWAP3
00000df9: SWAP1
00000dfa: SWAP3
00000dfb: ADD
00000dfc: PUSH1 0x40
00000dfe: ADD
00000dff: SWAP4
00000e00: SWAP3
00000e01: POP
00000e02: POP
00000e03: POP
00000e04: JUMP
00000e05: JUMPDEST
00000e06: PUSH1 0x20
00000e08: DUP1
00000e09: DUP3
00000e0a: MSTORE
00000e0b: PUSH1 0x19
00000e0d: SWAP1
00000e0e: DUP3
00000e0f: ADD
00000e10: MSTORE
00000e11: PUSH25 0x1095ce881cd95b99195c881b9bdd08185d5d1a1bdc9a5e9959
00000e2b: PUSH1 0x3a
00000e2d: SHL
00000e2e: PUSH1 0x40
00000e30: DUP3
00000e31: ADD
00000e32: MSTORE
00000e33: PUSH1 0x60
00000e35: ADD
00000e36: SWAP1
00000e37: JUMP
00000e38: JUMPDEST
00000e39: PUSH1 0x00
00000e3b: DUP3
00000e3c: NOT
00000e3d: DUP3
00000e3e: GT
00000e3f: ISZERO
00000e40: PUSH2 0x0e4b
00000e43: JUMPI
00000e44: PUSH2 0x0e4b
00000e47: PUSH2 0x0e82
00000e4a: JUMP
00000e4b: JUMPDEST
00000e4c: POP
00000e4d: ADD
00000e4e: SWAP1
00000e4f: JUMP
00000e50: JUMPDEST
00000e51: PUSH1 0x00
00000e53: DUP3
00000e54: DUP3
00000e55: LT
00000e56: ISZERO
00000e57: PUSH2 0x0e62
00000e5a: JUMPI
00000e5b: PUSH2 0x0e62
00000e5e: PUSH2 0x0e82
00000e61: JUMP
00000e62: JUMPDEST
00000e63: POP
00000e64: SUB
00000e65: SWAP1
00000e66: JUMP
00000e67: JUMPDEST
00000e68: PUSH1 0x00
00000e6a: PUSH1 0x00
00000e6c: NOT
00000e6d: DUP3
00000e6e: EQ
00000e6f: ISZERO
00000e70: PUSH2 0x0e7b
00000e73: JUMPI
00000e74: PUSH2 0x0e7b
00000e77: PUSH2 0x0e82
00000e7a: JUMP
00000e7b: JUMPDEST
00000e7c: POP
00000e7d: PUSH1 0x01
00000e7f: ADD
00000e80: SWAP1
00000e81: JUMP
00000e82: JUMPDEST
00000e83: PUSH4 0x4e487b71
00000e88: PUSH1 0xe0
00000e8a: SHL
00000e8b: PUSH1 0x00
00000e8d: MSTORE
00000e8e: PUSH1 0x11
00000e90: PUSH1 0x04
00000e92: MSTORE
00000e93: PUSH1 0x24
00000e95: PUSH1 0x00
00000e97: REVERT
00000e98: JUMPDEST
00000e99: DUP1
00000e9a: ISZERO
00000e9b: ISZERO
00000e9c: DUP2
00000e9d: EQ
00000e9e: PUSH2 0x0ea6
00000ea1: JUMPI
00000ea2: PUSH1 0x00
00000ea4: DUP1
00000ea5: REVERT
00000ea6: JUMPDEST
00000ea7: POP
00000ea8: JUMP
00000ea9: INVALID
00000eaa: LOG2
00000eab: PUSH5 0x6970667358
00000eb1: UNKNOWN(0x22)
00000eb2: SLT
00000eb3: KECCAK256
00000eb4: INVALID
00000eb5: UNKNOWN(0xAF)
00000eb6: UNKNOWN(0xBC)
00000eb7: LOG2
00000eb8: UNKNOWN(0xCE)
00000eb9: MUL
00000eba: UNKNOWN(0xB0)
00000ebb: UNKNOWN(0xE4)
00000ebc: UNKNOWN(0x22)
00000ebd: UNKNOWN(0xE0)
00000ebe: UNKNOWN(0x26)
00000ebf: UNKNOWN(0xAA)
00000ec0: UNKNOWN(0xEB)
00000ec1: PUSH10 0x2be20c1cffe226aed2ca
00000ecc: SWAP6
00000ecd: UNKNOWN(0xE6)
00000ece: SWAP15
00000ecf: PUSH6 0x357296fb6473
00000ed6: PUSH16