Online Solidity Decompiler

« Decompile another contract

Address

0xf97e0a5b616dffc913e72455fde9ea8bbe946a2b [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x0d9f5aed mixGenes(uint256,uint256,uint256)
0x1597ee44 encode(uint8[])
0x54c15b82 isGeneScience()
0x61a76900 decode(uint256)
0x77a74a20 expressingTraits(uint256)

Internal Methods

mixGenes(arg0, arg1, arg2) returns (r0)
func_0468(arg0, arg1, arg4, arg8, arg10) returns (r0)
encode(arg0) returns (r0)
isGeneScience(arg0) returns (r0)
decode(arg0) returns (r0)
expressingTraits(arg0) returns (r0)
func_0668(arg0, arg1, arg2) returns (r0)
func_06F1(arg0, arg1) returns (r0)
func_0709() returns (r0)
func_071B() returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x60; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 == 0x0d9f5aed) { // Dispatch table entry for mixGenes(uint256,uint256,uint256) if (msg.value) { revert(memory[0x00:0x00]); } var var1 = 0x008d; var var2 = msg.data[0x04:0x24]; var var3 = msg.data[0x24:0x44]; var var4 = msg.data[0x44:0x64]; var1 = mixGenes(var2, var3, var4); label_008D: var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var1; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x1597ee44) { // Dispatch table entry for encode(uint8[]) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x008d; var temp2 = msg.data[0x04:0x24]; var temp3 = msg.data[temp2 + 0x04:temp2 + 0x04 + 0x20]; var temp4 = memory[0x40:0x60]; memory[0x40:0x60] = temp4 + temp3 * 0x20 + 0x20; memory[temp4:temp4 + 0x20] = temp3; var temp5 = temp3 * 0x20; memory[temp4 + 0x20:temp4 + 0x20 + temp5] = msg.data[temp2 + 0x24:temp2 + 0x24 + temp5]; var2 = temp4; var1 = encode(var2); goto label_008D; } else if (var0 == 0x54c15b82) { // Dispatch table entry for isGeneScience() if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0101; var2 = isGeneScience(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = !!var2; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var0 == 0x61a76900) { // Dispatch table entry for decode(uint256) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x012b; var2 = msg.data[0x04:0x24]; var1 = decode(var2); var temp8 = memory[0x40:0x60]; var2 = temp8; memory[var2:var2 + 0x20] = 0x20; var3 = var2; var temp9 = var3 + 0x20; var temp10 = var1; memory[temp9:temp9 + 0x20] = memory[temp10:temp10 + 0x20]; var4 = temp9 + 0x20; var var5 = temp10 + 0x20; var var6 = memory[temp10:temp10 + 0x20] * 0x20; var var7 = var6; var var8 = var4; var var9 = var5; var var10 = 0x00; if (var10 >= var7) { label_016A: var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + (var6 + var4) - temp11]; } else { label_015B: var temp12 = var10; memory[temp12 + var8:temp12 + var8 + 0x20] = memory[var9 + temp12:var9 + temp12 + 0x20]; var10 = temp12 + 0x20; if (var10 >= var7) { goto label_016A; } else { goto label_015B; } } } else if (var0 == 0x77a74a20) { // Dispatch table entry for expressingTraits(uint256) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0194; var2 = msg.data[0x04:0x24]; var1 = expressingTraits(var2); var2 = memory[0x40:0x60]; var3 = var2; var4 = var1; var5 = 0x0180; var6 = var5; var7 = var3; var8 = var4; var9 = 0x00; if (var9 >= var6) { label_01BA: var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + (var5 + var3) - temp13]; } else { label_01AB: var temp14 = var9; memory[temp14 + var7:temp14 + var7 + 0x20] = memory[var8 + temp14:var8 + temp14 + 0x20]; var9 = temp14 + 0x20; if (var9 >= var6) { goto label_01BA; } else { goto label_01AB; } } } else { revert(memory[0x00:0x00]); } } function mixGenes(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; var var3 = 0x01da; var3 = func_0709(); var var4 = 0x01e2; var4 = func_0709(); var var5 = 0x01ea; var5 = func_0709(); var var6 = 0x00; var var7 = var6; var var8 = var7; var var9 = var8; var var10 = var9; var var11 = var10; if (block.number <= arg2) { revert(memory[0x00:0x00]); } var1 = block.blockHash(arg2); if (var1) { label_022B: var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var1; var temp1 = temp0 + 0x20; memory[temp1:temp1 + 0x20] = arg0; var temp2 = temp1 + 0x20; memory[temp2:temp2 + 0x20] = arg1; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = arg2; var temp4 = memory[0x40:0x60]; var1 = keccak256(memory[temp4:temp4 + (temp3 + 0x20) - temp4]); var2 = 0x00; var var12 = 0x0269; var var13 = arg0; var12 = decode(var13); var3 = var12; var12 = 0x0274; var13 = arg1; var12 = decode(var13); var4 = var12; var12 = 0x30; var13 = memory[0x40:0x60]; if (MSIZE() < var13) { var temp5 = var13; var temp6 = var12; memory[temp5:temp5 + 0x20] = temp6; memory[0x40:0x60] = temp5 + temp6 * 0x20 + 0x20; var5 = temp5; var8 = 0x00; if (var8 >= 0x0c) { label_03EE: var6 = 0x00; if (var6 >= 0x30) { label_053E: var12 = 0x0547; var13 = var5; return encode(var13); } else { label_03FD: var11 = 0x00; var12 = !(var6 % 0x04); if (!var12) { label_0440: if (!var12) { label_0491: if (var11 & 0xff <= 0x00) { var12 = 0x04cc; var13 = var1; var var14 = 0x01; var var15 = var2; var12 = func_0668(var13, var14, var15); var10 = var12; var2 = var2 + 0x01; if (var10 != 0x00) { var12 = var4; var13 = var6; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20]; var13 = var5; var14 = var6; if (var14 >= memory[var13:var13 + 0x20]) { assert(); } memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff; label_0533: var11 = var11; var6 = var6 + 0x01; if (var6 >= 0x30) { goto label_053E; } else { goto label_03FD; } } else { var12 = var3; var13 = var6; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20]; var13 = var5; var14 = var6; if (var14 >= memory[var13:var13 + 0x20]) { assert(); } label_04AA: memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff; goto label_0533; } } else { var12 = var11; var13 = var5; var14 = var6; if (var14 < memory[var13:var13 + 0x20]) { goto label_04AA; } else { assert(); } } } else { var12 = 0x0451; var13 = var1; var14 = 0x03; var15 = var2; var12 = func_0668(var13, var14, var15); var10 = var12; var2 = var2 + 0x03; var12 = 0x048e; var13 = var3; var14 = var6; if (var14 >= memory[var13:var13 + 0x20]) { assert(); } var12 = func_0468(var4, var6, var10, var13, var14); var11 = var12; goto label_0491; } } else { var12 = var4; var13 = var6; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20] & 0x01; var13 = var3; var14 = var6; if (var14 >= memory[var13:var13 + 0x20]) { assert(); } var12 = memory[var14 * 0x20 + var13 + 0x20:var14 * 0x20 + var13 + 0x20 + 0x20] & 0x01 != var12; goto label_0440; } } } else { label_02A7: var9 = 0x03; if (var9 < 0x01) { label_03E3: var11 = var11; var8 = var8 + 0x01; if (var8 >= 0x0c) { goto label_03EE; } else { goto label_02A7; } } else { label_02B4: var6 = var8 * 0x04 + var9; var12 = 0x02c7; var13 = var1; var14 = 0x02; var15 = var2; var12 = func_0668(var13, var14, var15); var10 = var12; var2 = var2 + 0x02; if (var10 != 0x00) { label_0349: var12 = 0x0355; var13 = var1; var14 = 0x02; var15 = var2; var12 = func_0668(var13, var14, var15); var10 = var12; var2 = var2 + 0x02; if (var10 != 0x00) { label_03D7: var11 = var11; var9 = var9 + ~0x00; if (var9 < 0x01) { goto label_03E3; } else { goto label_02B4; } } else { var12 = var4; var13 = var6; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var7 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20]; var12 = var4; var13 = var6 - 0x01; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20]; var13 = var4; var14 = var6; if (var14 >= memory[var13:var13 + 0x20]) { assert(); } memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff; var12 = var7; var13 = var4; var14 = var6 + ~0x00; if (var14 >= memory[var13:var13 + 0x20]) { assert(); } memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff; goto label_03D7; } } else { var12 = var3; var13 = var6; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var7 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20]; var12 = var3; var13 = var6 - 0x01; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20]; var13 = var3; var14 = var6; if (var14 >= memory[var13:var13 + 0x20]) { assert(); } memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff; var12 = var7; var13 = var3; var14 = var6 + ~0x00; if (var14 >= memory[var13:var13 + 0x20]) { assert(); } memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff; goto label_0349; } } } } else { var temp7 = MSIZE(); var temp8 = var12; memory[temp7:temp7 + 0x20] = temp8; memory[0x40:0x60] = temp7 + temp8 * 0x20 + 0x20; var5 = temp7; var8 = 0x00; if (var8 >= 0x0c) { goto label_03EE; } else { goto label_02A7; } } } else { var temp9 = (block.number & ~0xff) + (arg2 & 0xff); arg2 = temp9; if (arg2 < block.number) { var1 = block.blockHash(arg2); goto label_022B; } else { var temp10 = arg2 - 0x0100; arg2 = temp10; var1 = block.blockHash(arg2); goto label_022B; } } } function func_0468(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0) { arg3 = memory[arg4 * 0x20 + arg3 + 0x20:arg4 * 0x20 + arg3 + 0x20 + 0x20]; arg4 = arg0; var var0 = arg1; if (var0 >= memory[arg4:arg4 + 0x20]) { assert(); } arg4 = memory[var0 * 0x20 + arg4 + 0x20:var0 * 0x20 + arg4 + 0x20 + 0x20]; var0 = arg2; var var1 = 0x00; var var2 = arg3; var var3 = arg4; var var4 = var1; if (var2 & 0xff <= var3 & 0xff) { var var5 = var3 - var2 & 0xff == 0x01; if (!var5) { label_06B6: if (!var5) { label_06E7: return var1; } else { label_06BC: if (var2 & 0xff >= 0x17) { var4 = 0x00; if (var0 > var4) { goto label_06E7; } label_06DB: var1 = (var2 & 0xff) / 0x02 + 0x10; goto label_06E7; } else { var4 = 0x01; if (var0 > var4) { goto label_06E7; } else { goto label_06DB; } } } } else { label_06A8: if ((var2 & 0xff) % 0x02 & 0xff != 0x00) { goto label_06E7; } else { goto label_06BC; } } } else { var3 = arg3; var2 = arg4; var5 = var3 - var2 & 0xff == 0x01; if (!var5) { goto label_06B6; } else { goto label_06A8; } } } function encode(var arg0) returns (var r0) { var var0 = 0x00; var var1 = var0; if (var1 >= 0x30) { label_0597: return var0; } else { label_0568: var temp0 = var1; var1 = temp0; var0 = var0 * 0x20; var var2 = arg0; var var3 = 0x2f - var1; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var0 = (memory[var3 * 0x20 + var2 + 0x20:var3 * 0x20 + var2 + 0x20 + 0x20] & 0xff) | var0; var1 = var1 + 0x01; if (var1 >= 0x30) { goto label_0597; } else { goto label_0568; } } } function isGeneScience() returns (var r0) { return storage[0x00] & 0xff; } function decode(var arg0) returns (var r0) { var var0 = 0x05ae; var0 = func_0709(); var var1 = 0x05b6; var1 = func_0709(); var var2 = 0x00; var var3 = 0x30; var var4 = memory[0x40:0x60]; if (MSIZE() < var4) { var temp0 = var4; var temp1 = var3; memory[temp0:temp0 + 0x20] = temp1; memory[0x40:0x60] = temp0 + temp1 * 0x20 + 0x20; var1 = temp0; var2 = 0x00; if (var2 >= 0x30) { label_0617: return var1; } else { label_05E9: var3 = 0x05f2; var4 = arg0; var var5 = var2; var3 = func_06F1(var4, var5); var4 = var1; var5 = var2; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } memory[var4 + var5 * 0x20 + 0x20:var4 + var5 * 0x20 + 0x20 + 0x20] = var3 & 0xff; var2 = var2 + 0x01; if (var2 >= 0x30) { goto label_0617; } else { goto label_05E9; } } } else { var temp2 = MSIZE(); var temp3 = var3; memory[temp2:temp2 + 0x20] = temp3; memory[0x40:0x60] = temp2 + temp3 * 0x20 + 0x20; var1 = temp2; var2 = 0x00; if (var2 >= 0x30) { goto label_0617; } else { goto label_05E9; } } } function expressingTraits(var arg0) returns (var r0) { var var0 = 0x0626; var0 = func_071B(); var var1 = 0x062e; var1 = func_071B(); var var2 = 0x00; if (var2 >= 0x0c) { label_0617: return var1; } else { label_063B: var var3 = 0x0647; var var4 = arg0; var var5 = var2 * 0x04; var3 = func_06F1(var4, var5); var4 = var1; var5 = var2; if (var5 >= 0x0c) { assert(); } memory[var5 * 0x20 + var4:var5 * 0x20 + var4 + 0x20] = var3 & 0xff; var2 = var2 + 0x01; if (var2 >= 0x0c) { goto label_0617; } else { goto label_063B; } } } function func_0668(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = 0x02 ** arg2; return (temp0 * (0x02 ** arg1 + ~0x00) & arg0) / temp0; } function func_06F1(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x0702; var var2 = arg0; var var3 = 0x05; var var4 = arg1 * 0x05; return func_0668(var2, var3, var4); } function func_0709() returns (var r0) { var temp0 = memory[0x40:0x60]; memory[0x40:0x60] = temp0 + 0x20; memory[temp0:temp0 + 0x20] = 0x00; return temp0; } function func_071B() returns (var r0) { var temp0 = memory[0x40:0x60]; var var0 = temp0; memory[0x40:0x60] = var0 + 0x0180; memory[var0:var0 + 0x20] = 0x00; var var1 = 0x0c + ~0x00; var var2 = var0 + 0x20; if (!var1) { goto label_073F; } label_072B: var temp1 = var2; memory[temp1:temp1 + 0x20] = 0x00; var1 = var1 + ~0x00; var2 = temp1 + 0x20; if (var1) { goto label_072B; } label_073F: return var0; } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x60 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x006c 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x60 } // Block ends with conditional jump to 0x006c, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @0032 msg.data[0x00:0x20] } 000D 63 PUSH4 0xffffffff 0012 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0030 60 PUSH1 0x00 0032 35 CALLDATALOAD 0033 04 DIV 0034 16 AND 0035 63 PUSH4 0x0d9f5aed 003A 81 DUP2 003B 14 EQ 003C 61 PUSH2 0x0071 003F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0034 stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff } // Block ends with conditional jump to 0x0071, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x0d9f5aed label_0040: // Incoming jump from 0x003F, if not msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x0d9f5aed // Inputs[1] { @0040 stack[-1] } 0040 80 DUP1 0041 63 PUSH4 0x1597ee44 0046 14 EQ 0047 61 PUSH2 0x009f 004A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x009f, if 0x1597ee44 == stack[-1] label_004B: // Incoming jump from 0x004A, if not 0x1597ee44 == stack[-1] // Inputs[1] { @004B stack[-1] } 004B 80 DUP1 004C 63 PUSH4 0x54c15b82 0051 14 EQ 0052 61 PUSH2 0x00ee 0055 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ee, if 0x54c15b82 == stack[-1] label_0056: // Incoming jump from 0x0055, if not 0x54c15b82 == stack[-1] // Inputs[1] { @0056 stack[-1] } 0056 80 DUP1 0057 63 PUSH4 0x61a76900 005C 14 EQ 005D 61 PUSH2 0x0115 0060 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0115, if 0x61a76900 == stack[-1] label_0061: // Incoming jump from 0x0060, if not 0x61a76900 == stack[-1] // Inputs[1] { @0061 stack[-1] } 0061 80 DUP1 0062 63 PUSH4 0x77a74a20 0067 14 EQ 0068 61 PUSH2 0x017e 006B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017e, if 0x77a74a20 == stack[-1] label_006C: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x006B, if not 0x77a74a20 == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006C 5B JUMPDEST 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x003F, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x0d9f5aed // Inputs[1] { @0072 msg.value } 0071 5B JUMPDEST 0072 34 CALLVALUE 0073 15 ISZERO 0074 61 PUSH2 0x007c 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if !msg.value label_0078: // Incoming jump from 0x0077, if not !msg.value // Inputs[1] { @007B memory[0x00:0x00] } 0078 60 PUSH1 0x00 007A 80 DUP1 007B FD *REVERT // Stack delta = +0 // Outputs[1] { @007B revert(memory[0x00:0x00]); } // Block terminates label_007C: // Incoming jump from 0x0077, if !msg.value // Inputs[3] // { // @0082 msg.data[0x04:0x24] // @0085 msg.data[0x24:0x44] // @0088 msg.data[0x44:0x64] // } 007C 5B JUMPDEST 007D 61 PUSH2 0x008d 0080 60 PUSH1 0x04 0082 35 CALLDATALOAD 0083 60 PUSH1 0x24 0085 35 CALLDATALOAD 0086 60 PUSH1 0x44 0088 35 CALLDATALOAD 0089 61 PUSH2 0x01cd 008C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @007D stack[0] = 0x008d // @0082 stack[1] = msg.data[0x04:0x24] // @0085 stack[2] = msg.data[0x24:0x44] // @0088 stack[3] = msg.data[0x44:0x64] // } // Block ends with call to 0x01cd, returns to 0x008D label_008D: // Incoming return from call to 0x055A at 0x00ED // Incoming return from call to 0x01CD at 0x008C // Inputs[4] // { // @0090 memory[0x40:0x60] // @0091 stack[-1] // @0099 memory[0x40:0x60] // @009E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 008D 5B JUMPDEST 008E 60 PUSH1 0x40 0090 51 MLOAD 0091 90 SWAP1 0092 81 DUP2 0093 52 MSTORE 0094 60 PUSH1 0x20 0096 01 ADD 0097 60 PUSH1 0x40 0099 51 MLOAD 009A 80 DUP1 009B 91 SWAP2 009C 03 SUB 009D 90 SWAP1 009E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0093 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @009E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_009F: // Incoming jump from 0x004A, if 0x1597ee44 == stack[-1] // Inputs[1] { @00A0 msg.value } 009F 5B JUMPDEST 00A0 34 CALLVALUE 00A1 15 ISZERO 00A2 61 PUSH2 0x00aa 00A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00aa, if !msg.value label_00A6: // Incoming jump from 0x00A5, if not !msg.value // Inputs[1] { @00A9 memory[0x00:0x00] } 00A6 60 PUSH1 0x00 00A8 80 DUP1 00A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A9 revert(memory[0x00:0x00]); } // Block terminates label_00AA: // Incoming jump from 0x00A5, if !msg.value // Inputs[4] // { // @00B3 msg.data[0x04:0x24] // @00BA msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @00C4 memory[0x40:0x60] // @00DE msg.data[msg.data[0x04:0x24] + 0x24:msg.data[0x04:0x24] + 0x24 + 0x20 * msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 00AA 5B JUMPDEST 00AB 61 PUSH2 0x008d 00AE 60 PUSH1 0x04 00B0 60 PUSH1 0x24 00B2 81 DUP2 00B3 35 CALLDATALOAD 00B4 81 DUP2 00B5 81 DUP2 00B6 01 ADD 00B7 90 SWAP1 00B8 83 DUP4 00B9 01 ADD 00BA 35 CALLDATALOAD 00BB 80 DUP1 00BC 60 PUSH1 0x20 00BE 81 DUP2 00BF 81 DUP2 00C0 02 MUL 00C1 01 ADD 00C2 60 PUSH1 0x40 00C4 51 MLOAD 00C5 90 SWAP1 00C6 81 DUP2 00C7 01 ADD 00C8 60 PUSH1 0x40 00CA 52 MSTORE 00CB 80 DUP1 00CC 93 SWAP4 00CD 92 SWAP3 00CE 91 SWAP2 00CF 90 SWAP1 00D0 81 DUP2 00D1 81 DUP2 00D2 52 MSTORE 00D3 60 PUSH1 0x20 00D5 01 ADD 00D6 83 DUP4 00D7 83 DUP4 00D8 60 PUSH1 0x20 00DA 02 MUL 00DB 80 DUP1 00DC 82 DUP3 00DD 84 DUP5 00DE 37 CALLDATACOPY 00DF 50 POP 00E0 94 SWAP5 00E1 96 SWAP7 00E2 50 POP 00E3 61 PUSH2 0x055a 00E6 95 SWAP6 00E7 50 POP 00E8 50 POP 00E9 50 POP 00EA 50 POP 00EB 50 POP 00EC 50 POP 00ED 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @00AB stack[0] = 0x008d // @00CA memory[0x40:0x60] = memory[0x40:0x60] + 0x20 * msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] + 0x20 // @00D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @00DE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[msg.data[0x04:0x24] + 0x24:msg.data[0x04:0x24] + 0x24 + 0x20 * msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @00E1 stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x055a, returns to 0x008D label_00EE: // Incoming jump from 0x0055, if 0x54c15b82 == stack[-1] // Inputs[1] { @00EF msg.value } 00EE 5B JUMPDEST 00EF 34 CALLVALUE 00F0 15 ISZERO 00F1 61 PUSH2 0x00f9 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f9, if !msg.value label_00F5: // Incoming jump from 0x00F4, if not !msg.value // Inputs[1] { @00F8 memory[0x00:0x00] } 00F5 60 PUSH1 0x00 00F7 80 DUP1 00F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F8 revert(memory[0x00:0x00]); } // Block terminates label_00F9: // Incoming jump from 0x00F4, if !msg.value 00F9 5B JUMPDEST 00FA 61 PUSH2 0x0101 00FD 61 PUSH2 0x059d 0100 56 *JUMP // Stack delta = +1 // Outputs[1] { @00FA stack[0] = 0x0101 } // Block ends with call to 0x059d, returns to 0x0101 label_0101: // Incoming return from call to 0x059D at 0x0100 // Inputs[4] // { // @0104 memory[0x40:0x60] // @0105 stack[-1] // @010F memory[0x40:0x60] // @0114 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0101 5B JUMPDEST 0102 60 PUSH1 0x40 0104 51 MLOAD 0105 90 SWAP1 0106 15 ISZERO 0107 15 ISZERO 0108 81 DUP2 0109 52 MSTORE 010A 60 PUSH1 0x20 010C 01 ADD 010D 60 PUSH1 0x40 010F 51 MLOAD 0110 80 DUP1 0111 91 SWAP2 0112 03 SUB 0113 90 SWAP1 0114 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0109 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0114 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0115: // Incoming jump from 0x0060, if 0x61a76900 == stack[-1] // Inputs[1] { @0116 msg.value } 0115 5B JUMPDEST 0116 34 CALLVALUE 0117 15 ISZERO 0118 61 PUSH2 0x0120 011B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0120, if !msg.value label_011C: // Incoming jump from 0x011B, if not !msg.value // Inputs[1] { @011F memory[0x00:0x00] } 011C 60 PUSH1 0x00 011E 80 DUP1 011F FD *REVERT // Stack delta = +0 // Outputs[1] { @011F revert(memory[0x00:0x00]); } // Block terminates label_0120: // Incoming jump from 0x011B, if !msg.value // Inputs[1] { @0126 msg.data[0x04:0x24] } 0120 5B JUMPDEST 0121 61 PUSH2 0x012b 0124 60 PUSH1 0x04 0126 35 CALLDATALOAD 0127 61 PUSH2 0x05a6 012A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0121 stack[0] = 0x012b // @0126 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x05a6, returns to 0x012B label_012B: // Incoming return from call to 0x05A6 at 0x012A // Inputs[4] // { // @012E memory[0x40:0x60] // @0138 stack[-1] // @013B memory[stack[-1]:stack[-1] + 0x20] // @0144 memory[stack[-1]:stack[-1] + 0x20] // } 012B 5B JUMPDEST 012C 60 PUSH1 0x40 012E 51 MLOAD 012F 60 PUSH1 0x20 0131 80 DUP1 0132 82 DUP3 0133 52 MSTORE 0134 81 DUP2 0135 90 SWAP1 0136 81 DUP2 0137 01 ADD 0138 83 DUP4 0139 81 DUP2 013A 81 DUP2 013B 51 MLOAD 013C 81 DUP2 013D 52 MSTORE 013E 60 PUSH1 0x20 0140 01 ADD 0141 91 SWAP2 0142 50 POP 0143 80 DUP1 0144 51 MLOAD 0145 90 SWAP1 0146 60 PUSH1 0x20 0148 01 ADD 0149 90 SWAP1 014A 60 PUSH1 0x20 014C 02 MUL 014D 80 DUP1 014E 83 DUP4 014F 83 DUP4 0150 60 PUSH1 0x00 0152 5B JUMPDEST 0153 83 DUP4 0154 81 DUP2 0155 10 LT 0156 15 ISZERO 0157 61 PUSH2 0x016a 015A 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @012E stack[0] = memory[0x40:0x60] // @0133 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @0135 stack[1] = memory[0x40:0x60] // @013D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0141 stack[2] = 0x20 + memory[0x40:0x60] + 0x20 // @0149 stack[3] = 0x20 + stack[-1] // @014C stack[4] = 0x20 * memory[stack[-1]:stack[-1] + 0x20] // @014D stack[5] = 0x20 * memory[stack[-1]:stack[-1] + 0x20] // @014E stack[6] = 0x20 + memory[0x40:0x60] + 0x20 // @014F stack[7] = 0x20 + stack[-1] // @0150 stack[8] = 0x00 // } // Block ends with conditional jump to 0x016a, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) label_015B: // Incoming jump from 0x015A, if not !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x015A, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @015B stack[-1] // @015C stack[-2] // @015E memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @015F stack[-3] // } 015B 80 DUP1 015C 82 DUP3 015D 01 ADD 015E 51 MLOAD 015F 83 DUP4 0160 82 DUP3 0161 01 ADD 0162 52 MSTORE 0163 60 PUSH1 0x20 0165 01 ADD 0166 61 PUSH2 0x0152 0169 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0162 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0165 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0152 label_016A: // Incoming jump from 0x015A, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x015A, if !(stack[-1] < stack[-4]) // Inputs[6] // { // @016F stack[-6] // @016F stack[-5] // @0171 stack[-7] // @0172 stack[-10] // @0178 memory[0x40:0x60] // @017D memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 016A 5B JUMPDEST 016B 50 POP 016C 50 POP 016D 50 POP 016E 50 POP 016F 90 SWAP1 0170 50 POP 0171 01 ADD 0172 92 SWAP3 0173 50 POP 0174 50 POP 0175 50 POP 0176 60 PUSH1 0x40 0178 51 MLOAD 0179 80 DUP1 017A 91 SWAP2 017B 03 SUB 017C 90 SWAP1 017D F3 *RETURN // Stack delta = -10 // Outputs[1] { @017D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_017E: // Incoming jump from 0x006B, if 0x77a74a20 == stack[-1] // Inputs[1] { @017F msg.value } 017E 5B JUMPDEST 017F 34 CALLVALUE 0180 15 ISZERO 0181 61 PUSH2 0x0189 0184 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0189, if !msg.value label_0185: // Incoming jump from 0x0184, if not !msg.value // Inputs[1] { @0188 memory[0x00:0x00] } 0185 60 PUSH1 0x00 0187 80 DUP1 0188 FD *REVERT // Stack delta = +0 // Outputs[1] { @0188 revert(memory[0x00:0x00]); } // Block terminates label_0189: // Incoming jump from 0x0184, if !msg.value // Inputs[1] { @018F msg.data[0x04:0x24] } 0189 5B JUMPDEST 018A 61 PUSH2 0x0194 018D 60 PUSH1 0x04 018F 35 CALLDATALOAD 0190 61 PUSH2 0x061e 0193 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @018A stack[0] = 0x0194 // @018F stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x061e, returns to 0x0194 label_0194: // Incoming return from call to 0x061E at 0x0193 // Inputs[2] // { // @0197 memory[0x40:0x60] // @0199 stack[-1] // } 0194 5B JUMPDEST 0195 60 PUSH1 0x40 0197 51 MLOAD 0198 80 DUP1 0199 82 DUP3 019A 61 PUSH2 0x0180 019D 80 DUP1 019E 83 DUP4 019F 83 DUP4 01A0 60 PUSH1 0x00 01A2 5B JUMPDEST 01A3 83 DUP4 01A4 81 DUP2 01A5 10 LT 01A6 15 ISZERO 01A7 61 PUSH2 0x01ba 01AA 57 *JUMPI // Stack delta = +8 // Outputs[8] // { // @0197 stack[0] = memory[0x40:0x60] // @0198 stack[1] = memory[0x40:0x60] // @0199 stack[2] = stack[-1] // @019A stack[3] = 0x0180 // @019D stack[4] = 0x0180 // @019E stack[5] = memory[0x40:0x60] // @019F stack[6] = stack[-1] // @01A0 stack[7] = 0x00 // } // Block ends with conditional jump to 0x01ba, if !(0x00 < 0x0180) label_01AB: // Incoming jump from 0x01AA, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x01AA, if not !(0x00 < 0x0180) // Inputs[4] // { // @01AB stack[-1] // @01AC stack[-2] // @01AE memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01AF stack[-3] // } 01AB 80 DUP1 01AC 82 DUP3 01AD 01 ADD 01AE 51 MLOAD 01AF 83 DUP4 01B0 82 DUP3 01B1 01 ADD 01B2 52 MSTORE 01B3 60 PUSH1 0x20 01B5 01 ADD 01B6 61 PUSH2 0x01a2 01B9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01B2 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01B5 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x01a2 label_01BA: // Incoming jump from 0x01AA, if !(stack[-1] < stack[-4]) // Incoming jump from 0x01AA, if !(0x00 < 0x0180) // Inputs[6] // { // @01BF stack[-5] // @01BF stack[-6] // @01C1 stack[-7] // @01C2 stack[-9] // @01C7 memory[0x40:0x60] // @01CC memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 01BA 5B JUMPDEST 01BB 50 POP 01BC 50 POP 01BD 50 POP 01BE 50 POP 01BF 90 SWAP1 01C0 50 POP 01C1 01 ADD 01C2 91 SWAP2 01C3 50 POP 01C4 50 POP 01C5 60 PUSH1 0x40 01C7 51 MLOAD 01C8 80 DUP1 01C9 91 SWAP2 01CA 03 SUB 01CB 90 SWAP1 01CC F3 *RETURN // Stack delta = -9 // Outputs[1] { @01CC return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_01CD: // Incoming call from 0x008C, returns to 0x008D 01CD 5B JUMPDEST 01CE 60 PUSH1 0x00 01D0 80 DUP1 01D1 60 PUSH1 0x00 01D3 61 PUSH2 0x01da 01D6 61 PUSH2 0x0709 01D9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01CE stack[0] = 0x00 // @01D0 stack[1] = 0x00 // @01D1 stack[2] = 0x00 // @01D3 stack[3] = 0x01da // } // Block ends with call to 0x0709, returns to 0x01DA label_01DA: // Incoming return from call to 0x0709 at 0x01D9 01DA 5B JUMPDEST 01DB 61 PUSH2 0x01e2 01DE 61 PUSH2 0x0709 01E1 56 *JUMP // Stack delta = +1 // Outputs[1] { @01DB stack[0] = 0x01e2 } // Block ends with call to 0x0709, returns to 0x01E2 label_01E2: // Incoming return from call to 0x0709 at 0x01E1 01E2 5B JUMPDEST 01E3 61 PUSH2 0x01ea 01E6 61 PUSH2 0x0709 01E9 56 *JUMP // Stack delta = +1 // Outputs[1] { @01E3 stack[0] = 0x01ea } // Block ends with call to 0x0709, returns to 0x01EA label_01EA: // Incoming return from call to 0x0709 at 0x01E9 // Inputs[2] // { // @01F2 block.number // @01F3 stack[-7] // } 01EA 5B JUMPDEST 01EB 60 PUSH1 0x00 01ED 80 DUP1 01EE 80 DUP1 01EF 80 DUP1 01F0 80 DUP1 01F1 80 DUP1 01F2 43 NUMBER 01F3 8D DUP14 01F4 90 SWAP1 01F5 11 GT 01F6 61 PUSH2 0x01fe 01F9 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @01EB stack[0] = 0x00 // @01ED stack[1] = 0x00 // @01EE stack[2] = 0x00 // @01EF stack[3] = 0x00 // @01F0 stack[4] = 0x00 // @01F1 stack[5] = 0x00 // } // Block ends with conditional jump to 0x01fe, if block.number > stack[-7] label_01FA: // Incoming jump from 0x01F9, if not block.number > stack[-7] // Inputs[1] { @01FD memory[0x00:0x00] } 01FA 60 PUSH1 0x00 01FC 80 DUP1 01FD FD *REVERT // Stack delta = +0 // Outputs[1] { @01FD revert(memory[0x00:0x00]); } // Block terminates label_01FE: // Incoming jump from 0x01F9, if block.number > stack[-7] // Inputs[3] // { // @01FF stack[-13] // @0200 block.blockHash(stack[-13]) // @0201 stack[-11] // } 01FE 5B JUMPDEST 01FF 8C DUP13 0200 40 BLOCKHASH 0201 9A SWAP11 0202 50 POP 0203 8A DUP11 0204 15 ISZERO 0205 15 ISZERO 0206 61 PUSH2 0x022b 0209 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0201 stack[-11] = block.blockHash(stack[-13]) } // Block ends with conditional jump to 0x022b, if !!block.blockHash(stack[-13]) label_020A: // Incoming jump from 0x0209, if not !!block.blockHash(stack[-13]) // Inputs[3] // { // @020C stack[-13] // @0211 block.number // @0216 block.number // } 020A 60 PUSH1 0xff 020C 8D DUP14 020D 16 AND 020E 60 PUSH1 0xff 0210 19 NOT 0211 43 NUMBER 0212 16 AND 0213 01 ADD 0214 9C SWAP13 0215 50 POP 0216 43 NUMBER 0217 8D DUP14 0218 10 LT 0219 15 ISZERO 021A 15 ISZERO 021B 61 PUSH2 0x0226 021E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0214 stack[-13] = (block.number & ~0xff) + (stack[-13] & 0xff) } // Block ends with conditional jump to 0x0226, if !!((block.number & ~0xff) + (stack[-13] & 0xff) < block.number) label_021F: // Incoming jump from 0x021E, if not !!((block.number & ~0xff) + (stack[-13] & 0xff) < block.number) // Inputs[3] // { // @0222 stack[-13] // @0228 block.blockHash(stack[-13] - 0x0100) // @0229 stack[-11] // } 021F 61 PUSH2 0x0100 0222 8D DUP14 0223 03 SUB 0224 9C SWAP13 0225 50 POP 0226 5B JUMPDEST 0227 8C DUP13 0228 40 BLOCKHASH 0229 9A SWAP11 022A 50 POP // Stack delta = +0 // Outputs[2] // { // @0224 stack[-13] = stack[-13] - 0x0100 // @0229 stack[-11] = block.blockHash(stack[-13] - 0x0100) // } // Block continues label_022B: // Incoming jump from 0x022A // Incoming jump from 0x022A // Incoming jump from 0x0209, if !!block.blockHash(stack[-13]) // Inputs[8] // { // @022C stack[-11] // @022D stack[-15] // @022E stack[-14] // @022F stack[-13] // @0232 memory[0x40:0x60] // @0254 memory[0x40:0x60] // @025A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @025F stack[-10] // } 022B 5B JUMPDEST 022C 8A DUP11 022D 8F DUP16 022E 8F DUP16 022F 8F DUP16 0230 60 PUSH1 0x40 0232 51 MLOAD 0233 80 DUP1 0234 85 DUP6 0235 81 DUP2 0236 52 MSTORE 0237 60 PUSH1 0x20 0239 01 ADD 023A 84 DUP5 023B 81 DUP2 023C 52 MSTORE 023D 60 PUSH1 0x20 023F 01 ADD 0240 83 DUP4 0241 81 DUP2 0242 52 MSTORE 0243 60 PUSH1 0x20 0245 01 ADD 0246 82 DUP3 0247 81 DUP2 0248 52 MSTORE 0249 60 PUSH1 0x20 024B 01 ADD 024C 94 SWAP5 024D 50 POP 024E 50 POP 024F 50 POP 0250 50 POP 0251 50 POP 0252 60 PUSH1 0x40 0254 51 MLOAD 0255 90 SWAP1 0256 81 DUP2 0257 90 SWAP1 0258 03 SUB 0259 90 SWAP1 025A 20 SHA3 025B 9A SWAP11 025C 50 POP 025D 60 PUSH1 0x00 025F 99 SWAP10 0260 50 POP 0261 61 PUSH2 0x0269 0264 8F DUP16 0265 61 PUSH2 0x05a6 0268 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @0236 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-11] // @023C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-15] // @0242 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-14] // @0248 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-13] // @025B stack[-11] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @025F stack[-10] = 0x00 // @0261 stack[0] = 0x0269 // @0264 stack[1] = stack[-15] // } // Block ends with call to 0x05a6, returns to 0x0269 label_0269: // Incoming return from call to 0x05A6 at 0x0268 // Inputs[3] // { // @026A stack[-10] // @026A stack[-1] // @026F stack[-15] // } 0269 5B JUMPDEST 026A 98 SWAP9 026B 50 POP 026C 61 PUSH2 0x0274 026F 8E DUP15 0270 61 PUSH2 0x05a6 0273 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @026A stack[-10] = stack[-1] // @026C stack[-1] = 0x0274 // @026F stack[0] = stack[-15] // } // Block ends with call to 0x05a6, returns to 0x0274 label_0274: // Incoming return from call to 0x05A6 at 0x0273 // Inputs[4] // { // @0275 stack[-1] // @0275 stack[-9] // @027B memory[0x40:0x60] // @027D MSIZE() // } 0274 5B JUMPDEST 0275 97 SWAP8 0276 50 POP 0277 60 PUSH1 0x30 0279 60 PUSH1 0x40 027B 51 MLOAD 027C 80 DUP1 027D 59 MSIZE 027E 10 LT 027F 61 PUSH2 0x0285 0282 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0275 stack[-9] = stack[-1] // @0277 stack[-1] = 0x30 // @027B stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0285, if MSIZE() < memory[0x40:0x60] label_0283: // Incoming jump from 0x0282, if not MSIZE() < memory[0x40:0x60] // Inputs[4] // { // @0284 MSIZE() // @0286 stack[-2] // @0297 stack[-9] // @029B stack[-6] // } 0283 50 POP 0284 59 MSIZE 0285 5B JUMPDEST 0286 90 SWAP1 0287 80 DUP1 0288 82 DUP3 0289 52 MSTORE 028A 80 DUP1 028B 60 PUSH1 0x20 028D 02 MUL 028E 60 PUSH1 0x20 0290 01 ADD 0291 82 DUP3 0292 01 ADD 0293 60 PUSH1 0x40 0295 52 MSTORE 0296 50 POP 0297 96 SWAP7 0298 50 POP 0299 60 PUSH1 0x00 029B 93 SWAP4 029C 50 POP 029D 5B JUMPDEST 029E 60 PUSH1 0x0c 02A0 84 DUP5 02A1 10 LT 02A2 15 ISZERO 02A3 61 PUSH2 0x03ee 02A6 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @0289 memory[MSIZE():MSIZE() + 0x20] = stack[-2] // @0295 memory[0x40:0x60] = MSIZE() + 0x20 + 0x20 * stack[-2] // @0297 stack[-9] = MSIZE() // @029B stack[-6] = 0x00 // } // Block ends with conditional jump to 0x03ee, if !(0x00 < 0x0c) label_02A7: // Incoming jump from 0x02A6, if not !(stack[-4] < 0x0c) // Incoming jump from 0x02A6, if not !(0x00 < 0x0c) // Incoming jump from 0x02A6, if not !(0x00 < 0x0c) // Inputs[1] { @02A9 stack[-3] } 02A7 60 PUSH1 0x03 02A9 92 SWAP3 02AA 50 POP 02AB 5B JUMPDEST 02AC 60 PUSH1 0x01 02AE 83 DUP4 02AF 10 LT 02B0 61 PUSH2 0x03e3 02B3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @02A9 stack[-3] = 0x03 } // Block ends with conditional jump to 0x03e3, if 0x03 < 0x01 label_02B4: // Incoming jump from 0x02B3, if not stack[-3] < 0x01 // Incoming jump from 0x02B3, if not 0x03 < 0x01 // Inputs[5] // { // @02B4 stack[-3] // @02B5 stack[-4] // @02BA stack[-6] // @02BF stack[-11] // @02C2 stack[-10] // } 02B4 82 DUP3 02B5 84 DUP5 02B6 60 PUSH1 0x04 02B8 02 MUL 02B9 01 ADD 02BA 95 SWAP6 02BB 50 POP 02BC 61 PUSH2 0x02c7 02BF 8B DUP12 02C0 60 PUSH1 0x02 02C2 8C DUP13 02C3 61 PUSH2 0x0668 02C6 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @02BA stack[-6] = 0x04 * stack[-4] + stack[-3] // @02BC stack[0] = 0x02c7 // @02BF stack[1] = stack[-11] // @02C0 stack[2] = 0x02 // @02C2 stack[3] = stack[-10] // } // Block ends with call to 0x0668, returns to 0x02C7 label_02C7: // Incoming return from call to 0x0668 at 0x02C6 // Inputs[3] // { // @02C8 stack[-1] // @02C8 stack[-3] // @02CC stack[-11] // } 02C7 5B JUMPDEST 02C8 91 SWAP2 02C9 50 POP 02CA 60 PUSH1 0x02 02CC 8A DUP11 02CD 01 ADD 02CE 99 SWAP10 02CF 50 POP 02D0 81 DUP2 02D1 60 PUSH1 0x00 02D3 14 EQ 02D4 15 ISZERO 02D5 61 PUSH2 0x0349 02D8 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @02C8 stack[-3] = stack[-1] // @02CE stack[-11] = stack[-11] + 0x02 // } // Block ends with conditional jump to 0x0349, if !(0x00 == stack[-1]) label_02D9: // Incoming jump from 0x02D8, if not !(0x00 == stack[-1]) // Inputs[3] // { // @02D9 stack[-9] // @02DA stack[-6] // @02DC memory[stack[-9]:stack[-9] + 0x20] // } 02D9 88 DUP9 02DA 86 DUP7 02DB 81 DUP2 02DC 51 MLOAD 02DD 81 DUP2 02DE 10 LT 02DF 61 PUSH2 0x02e4 02E2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @02D9 stack[0] = stack[-9] // @02DA stack[1] = stack[-6] // } // Block ends with conditional jump to 0x02e4, if stack[-6] < memory[stack[-9]:stack[-9] + 0x20] label_02E3: // Incoming jump from 0x02E2, if not stack[-6] < memory[stack[-9]:stack[-9] + 0x20] 02E3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @02E3 assert(); } // Block terminates label_02E4: // Incoming jump from 0x02E2, if stack[-6] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[7] // { // @02E5 stack[-1] // @02E5 stack[-2] // @02EE memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @02EF stack[-7] // @02F1 stack[-11] // @02F4 stack[-8] // @02F7 memory[stack[-11]:stack[-11] + 0x20] // } 02E4 5B JUMPDEST 02E5 90 SWAP1 02E6 60 PUSH1 0x20 02E8 01 ADD 02E9 90 SWAP1 02EA 60 PUSH1 0x20 02EC 02 MUL 02ED 01 ADD 02EE 51 MLOAD 02EF 94 SWAP5 02F0 50 POP 02F1 88 DUP9 02F2 60 PUSH1 0x01 02F4 87 DUP8 02F5 03 SUB 02F6 81 DUP2 02F7 51 MLOAD 02F8 81 DUP2 02F9 10 LT 02FA 61 PUSH2 0x02ff 02FD 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @02EF stack[-7] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @02F1 stack[-2] = stack[-11] // @02F5 stack[-1] = stack[-8] - 0x01 // } // Block ends with conditional jump to 0x02ff, if stack[-8] - 0x01 < memory[stack[-11]:stack[-11] + 0x20] label_02FE: // Incoming jump from 0x02FD, if not stack[-8] - 0x01 < memory[stack[-11]:stack[-11] + 0x20] 02FE FE *ASSERT // Stack delta = +0 // Outputs[1] { @02FE assert(); } // Block terminates label_02FF: // Incoming jump from 0x02FD, if stack[-8] - 0x01 < memory[stack[-11]:stack[-11] + 0x20] // Inputs[6] // { // @0300 stack[-2] // @0300 stack[-1] // @0309 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @030A stack[-11] // @030B stack[-8] // @030D memory[stack[-11]:stack[-11] + 0x20] // } 02FF 5B JUMPDEST 0300 90 SWAP1 0301 60 PUSH1 0x20 0303 01 ADD 0304 90 SWAP1 0305 60 PUSH1 0x20 0307 02 MUL 0308 01 ADD 0309 51 MLOAD 030A 89 DUP10 030B 87 DUP8 030C 81 DUP2 030D 51 MLOAD 030E 81 DUP2 030F 10 LT 0310 61 PUSH2 0x0315 0313 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0309 stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @030A stack[-1] = stack[-11] // @030B stack[0] = stack[-8] // } // Block ends with conditional jump to 0x0315, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20] label_0314: // Incoming jump from 0x0313, if not stack[-8] < memory[stack[-11]:stack[-11] + 0x20] 0314 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0314 assert(); } // Block terminates label_0315: // Incoming jump from 0x0313, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20] // Inputs[7] // { // @0318 stack[-1] // @0319 stack[-3] // @0321 stack[-2] // @0327 stack[-8] // @0328 stack[-12] // @032C stack[-9] // @032F memory[stack[-12]:stack[-12] + 0x20] // } 0315 5B JUMPDEST 0316 60 PUSH1 0xff 0318 90 SWAP1 0319 92 SWAP3 031A 16 AND 031B 60 PUSH1 0x20 031D 92 SWAP3 031E 83 DUP4 031F 02 MUL 0320 90 SWAP1 0321 91 SWAP2 0322 01 ADD 0323 90 SWAP1 0324 91 SWAP2 0325 01 ADD 0326 52 MSTORE 0327 84 DUP5 0328 89 DUP10 0329 60 PUSH1 0x00 032B 19 NOT 032C 88 DUP9 032D 01 ADD 032E 81 DUP2 032F 51 MLOAD 0330 81 DUP2 0331 10 LT 0332 61 PUSH2 0x0337 0335 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0326 memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff // @0327 stack[-3] = stack[-8] // @0328 stack[-2] = stack[-12] // @032D stack[-1] = stack[-9] + ~0x00 // } // Block ends with conditional jump to 0x0337, if stack[-9] + ~0x00 < memory[stack[-12]:stack[-12] + 0x20] label_0336: // Incoming jump from 0x0335, if not stack[-9] + ~0x00 < memory[stack[-12]:stack[-12] + 0x20] 0336 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0336 assert(); } // Block terminates label_0337: // Incoming jump from 0x0335, if stack[-9] + ~0x00 < memory[stack[-12]:stack[-12] + 0x20] // Inputs[3] // { // @033A stack[-1] // @033B stack[-3] // @0343 stack[-2] // } 0337 5B JUMPDEST 0338 60 PUSH1 0xff 033A 90 SWAP1 033B 92 SWAP3 033C 16 AND 033D 60 PUSH1 0x20 033F 92 SWAP3 0340 83 DUP4 0341 02 MUL 0342 90 SWAP1 0343 91 SWAP2 0344 01 ADD 0345 90 SWAP1 0346 91 SWAP2 0347 01 ADD 0348 52 MSTORE // Stack delta = -3 // Outputs[1] { @0348 memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff } // Block continues label_0349: // Incoming jump from 0x02D8, if !(0x00 == stack[-1]) // Incoming jump from 0x0348 // Inputs[2] // { // @034D stack[-11] // @0350 stack[-10] // } 0349 5B JUMPDEST 034A 61 PUSH2 0x0355 034D 8B DUP12 034E 60 PUSH1 0x02 0350 8C DUP13 0351 61 PUSH2 0x0668 0354 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @034A stack[0] = 0x0355 // @034D stack[1] = stack[-11] // @034E stack[2] = 0x02 // @0350 stack[3] = stack[-10] // } // Block ends with call to 0x0668, returns to 0x0355 label_0355: // Incoming return from call to 0x0668 at 0x0354 // Inputs[3] // { // @0356 stack[-1] // @0356 stack[-3] // @035A stack[-11] // } 0355 5B JUMPDEST 0356 91 SWAP2 0357 50 POP 0358 60 PUSH1 0x02 035A 8A DUP11 035B 01 ADD 035C 99 SWAP10 035D 50 POP 035E 81 DUP2 035F 60 PUSH1 0x00 0361 14 EQ 0362 15 ISZERO 0363 61 PUSH2 0x03d7 0366 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0356 stack[-3] = stack[-1] // @035C stack[-11] = stack[-11] + 0x02 // } // Block ends with conditional jump to 0x03d7, if !(0x00 == stack[-1]) label_0367: // Incoming jump from 0x0366, if not !(0x00 == stack[-1]) // Inputs[3] // { // @0367 stack[-8] // @0368 stack[-6] // @036A memory[stack[-8]:stack[-8] + 0x20] // } 0367 87 DUP8 0368 86 DUP7 0369 81 DUP2 036A 51 MLOAD 036B 81 DUP2 036C 10 LT 036D 61 PUSH2 0x0372 0370 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0367 stack[0] = stack[-8] // @0368 stack[1] = stack[-6] // } // Block ends with conditional jump to 0x0372, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20] label_0371: // Incoming jump from 0x0370, if not stack[-6] < memory[stack[-8]:stack[-8] + 0x20] 0371 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0371 assert(); } // Block terminates label_0372: // Incoming jump from 0x0370, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20] // Inputs[7] // { // @0373 stack[-2] // @0373 stack[-1] // @037C memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @037D stack[-7] // @037F stack[-10] // @0382 stack[-8] // @0385 memory[stack[-10]:stack[-10] + 0x20] // } 0372 5B JUMPDEST 0373 90 SWAP1 0374 60 PUSH1 0x20 0376 01 ADD 0377 90 SWAP1 0378 60 PUSH1 0x20 037A 02 MUL 037B 01 ADD 037C 51 MLOAD 037D 94 SWAP5 037E 50 POP 037F 87 DUP8 0380 60 PUSH1 0x01 0382 87 DUP8 0383 03 SUB 0384 81 DUP2 0385 51 MLOAD 0386 81 DUP2 0387 10 LT 0388 61 PUSH2 0x038d 038B 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @037D stack[-7] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @037F stack[-2] = stack[-10] // @0383 stack[-1] = stack[-8] - 0x01 // } // Block ends with conditional jump to 0x038d, if stack[-8] - 0x01 < memory[stack[-10]:stack[-10] + 0x20] label_038C: // Incoming jump from 0x038B, if not stack[-8] - 0x01 < memory[stack[-10]:stack[-10] + 0x20] 038C FE *ASSERT // Stack delta = +0 // Outputs[1] { @038C assert(); } // Block terminates label_038D: // Incoming jump from 0x038B, if stack[-8] - 0x01 < memory[stack[-10]:stack[-10] + 0x20] // Inputs[6] // { // @038E stack[-1] // @038E stack[-2] // @0397 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0398 stack[-10] // @0399 stack[-8] // @039B memory[stack[-10]:stack[-10] + 0x20] // } 038D 5B JUMPDEST 038E 90 SWAP1 038F 60 PUSH1 0x20 0391 01 ADD 0392 90 SWAP1 0393 60 PUSH1 0x20 0395 02 MUL 0396 01 ADD 0397 51 MLOAD 0398 88 DUP9 0399 87 DUP8 039A 81 DUP2 039B 51 MLOAD 039C 81 DUP2 039D 10 LT 039E 61 PUSH2 0x03a3 03A1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0397 stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0398 stack[-1] = stack[-10] // @0399 stack[0] = stack[-8] // } // Block ends with conditional jump to 0x03a3, if stack[-8] < memory[stack[-10]:stack[-10] + 0x20] label_03A2: // Incoming jump from 0x03A1, if not stack[-8] < memory[stack[-10]:stack[-10] + 0x20] 03A2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @03A2 assert(); } // Block terminates label_03A3: // Incoming jump from 0x03A1, if stack[-8] < memory[stack[-10]:stack[-10] + 0x20] // Inputs[7] // { // @03A6 stack[-1] // @03A7 stack[-3] // @03AF stack[-2] // @03B5 stack[-8] // @03B6 stack[-11] // @03BA stack[-9] // @03BD memory[stack[-11]:stack[-11] + 0x20] // } 03A3 5B JUMPDEST 03A4 60 PUSH1 0xff 03A6 90 SWAP1 03A7 92 SWAP3 03A8 16 AND 03A9 60 PUSH1 0x20 03AB 92 SWAP3 03AC 83 DUP4 03AD 02 MUL 03AE 90 SWAP1 03AF 91 SWAP2 03B0 01 ADD 03B1 90 SWAP1 03B2 91 SWAP2 03B3 01 ADD 03B4 52 MSTORE 03B5 84 DUP5 03B6 88 DUP9 03B7 60 PUSH1 0x00 03B9 19 NOT 03BA 88 DUP9 03BB 01 ADD 03BC 81 DUP2 03BD 51 MLOAD 03BE 81 DUP2 03BF 10 LT 03C0 61 PUSH2 0x03c5 03C3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @03B4 memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff // @03B5 stack[-3] = stack[-8] // @03B6 stack[-2] = stack[-11] // @03BB stack[-1] = stack[-9] + ~0x00 // } // Block ends with conditional jump to 0x03c5, if stack[-9] + ~0x00 < memory[stack[-11]:stack[-11] + 0x20] label_03C4: // Incoming jump from 0x03C3, if not stack[-9] + ~0x00 < memory[stack[-11]:stack[-11] + 0x20] 03C4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @03C4 assert(); } // Block terminates label_03C5: // Incoming jump from 0x03C3, if stack[-9] + ~0x00 < memory[stack[-11]:stack[-11] + 0x20] // Inputs[3] // { // @03C8 stack[-1] // @03C9 stack[-3] // @03D1 stack[-2] // } 03C5 5B JUMPDEST 03C6 60 PUSH1 0xff 03C8 90 SWAP1 03C9 92 SWAP3 03CA 16 AND 03CB 60 PUSH1 0x20 03CD 92 SWAP3 03CE 83 DUP4 03CF 02 MUL 03D0 90 SWAP1 03D1 91 SWAP2 03D2 01 ADD 03D3 90 SWAP1 03D4 91 SWAP2 03D5 01 ADD 03D6 52 MSTORE // Stack delta = -3 // Outputs[1] { @03D6 memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff } // Block continues label_03D7: // Incoming jump from 0x03D6 // Incoming jump from 0x0366, if !(0x00 == stack[-1]) // Inputs[2] // { // @03DB stack[-1] // @03DC stack[-3] // } 03D7 5B JUMPDEST 03D8 60 PUSH1 0x00 03DA 19 NOT 03DB 90 SWAP1 03DC 92 SWAP3 03DD 01 ADD 03DE 91 SWAP2 03DF 61 PUSH2 0x02ab 03E2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03DE stack[-3] = stack[-3] + ~0x00 // @03DE stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x02ab label_03E3: // Incoming jump from 0x02B3, if stack[-3] < 0x01 // Incoming jump from 0x02B3, if 0x03 < 0x01 // Inputs[2] // { // @03E6 stack[-1] // @03E7 stack[-4] // } 03E3 5B JUMPDEST 03E4 60 PUSH1 0x01 03E6 90 SWAP1 03E7 93 SWAP4 03E8 01 ADD 03E9 92 SWAP3 03EA 61 PUSH2 0x029d 03ED 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03E9 stack[-4] = stack[-4] + 0x01 // @03E9 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x029d label_03EE: // Incoming jump from 0x02A6, if !(stack[-4] < 0x0c) // Incoming jump from 0x02A6, if !(0x00 < 0x0c) // Incoming jump from 0x02A6, if !(0x00 < 0x0c) // Inputs[1] { @03F1 stack[-6] } 03EE 5B JUMPDEST 03EF 60 PUSH1 0x00 03F1 95 SWAP6 03F2 50 POP 03F3 5B JUMPDEST 03F4 60 PUSH1 0x30 03F6 86 DUP7 03F7 10 LT 03F8 15 ISZERO 03F9 61 PUSH2 0x053e 03FC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03F1 stack[-6] = 0x00 } // Block ends with conditional jump to 0x053e, if !(0x00 < 0x30) label_03FD: // Incoming jump from 0x03FC, if not !(stack[-6] < 0x30) // Incoming jump from 0x03FC, if not !(0x00 < 0x30) // Inputs[1] { @0402 stack[-6] } 03FD 50 POP 03FE 60 PUSH1 0x00 0400 60 PUSH1 0x04 0402 86 DUP7 0403 06 MOD 0404 15 ISZERO 0405 80 DUP1 0406 15 ISZERO 0407 61 PUSH2 0x0440 040A 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @03FE stack[-1] = 0x00 // @0404 stack[0] = !(stack[-6] % 0x04) // } // Block ends with conditional jump to 0x0440, if !!(stack[-6] % 0x04) label_040B: // Incoming jump from 0x040A, if not !!(stack[-6] % 0x04) // Inputs[3] // { // @040C stack[-9] // @040D stack[-7] // @040F memory[stack[-9]:stack[-9] + 0x20] // } 040B 50 POP 040C 87 DUP8 040D 86 DUP7 040E 81 DUP2 040F 51 MLOAD 0410 81 DUP2 0411 10 LT 0412 61 PUSH2 0x0417 0415 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @040C stack[-1] = stack[-9] // @040D stack[0] = stack[-7] // } // Block ends with conditional jump to 0x0417, if stack[-7] < memory[stack[-9]:stack[-9] + 0x20] label_0416: // Incoming jump from 0x0415, if not stack[-7] < memory[stack[-9]:stack[-9] + 0x20] 0416 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0416 assert(); } // Block terminates label_0417: // Incoming jump from 0x0415, if stack[-7] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[6] // { // @0418 stack[-1] // @0418 stack[-2] // @0421 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0425 stack[-11] // @0426 stack[-8] // @0428 memory[stack[-11]:stack[-11] + 0x20] // } 0417 5B JUMPDEST 0418 90 SWAP1 0419 60 PUSH1 0x20 041B 01 ADD 041C 90 SWAP1 041D 60 PUSH1 0x20 041F 02 MUL 0420 01 ADD 0421 51 MLOAD 0422 60 PUSH1 0x01 0424 16 AND 0425 89 DUP10 0426 87 DUP8 0427 81 DUP2 0428 51 MLOAD 0429 81 DUP2 042A 10 LT 042B 61 PUSH2 0x0430 042E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0424 stack[-2] = 0x01 & memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0425 stack[-1] = stack[-11] // @0426 stack[0] = stack[-8] // } // Block ends with conditional jump to 0x0430, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20] label_042F: // Incoming jump from 0x042E, if not stack[-8] < memory[stack[-11]:stack[-11] + 0x20] 042F FE *ASSERT // Stack delta = +0 // Outputs[1] { @042F assert(); } // Block terminates label_0430: // Incoming jump from 0x042E, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20] // Inputs[4] // { // @0431 stack[-2] // @0431 stack[-1] // @043A memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @043E stack[-3] // } 0430 5B JUMPDEST 0431 90 SWAP1 0432 60 PUSH1 0x20 0434 01 ADD 0435 90 SWAP1 0436 60 PUSH1 0x20 0438 02 MUL 0439 01 ADD 043A 51 MLOAD 043B 60 PUSH1 0x01 043D 16 AND 043E 14 EQ 043F 15 ISZERO // Stack delta = -2 // Outputs[1] { @043F stack[-3] = !(0x01 & memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] == stack[-3]) } // Block continues label_0440: // Incoming jump from 0x043F // Incoming jump from 0x040A, if !!(stack[-6] % 0x04) // Inputs[1] { @0441 stack[-1] } 0440 5B JUMPDEST 0441 15 ISZERO 0442 61 PUSH2 0x0491 0445 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0491, if !stack[-1] label_0446: // Incoming jump from 0x0445, if not !stack[-1] // Inputs[2] // { // @0449 stack[-11] // @044C stack[-10] // } 0446 61 PUSH2 0x0451 0449 8B DUP12 044A 60 PUSH1 0x03 044C 8C DUP13 044D 61 PUSH2 0x0668 0450 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0446 stack[0] = 0x0451 // @0449 stack[1] = stack[-11] // @044A stack[2] = 0x03 // @044C stack[3] = stack[-10] // } // Block ends with call to 0x0668, returns to 0x0451 label_0451: // Incoming return from call to 0x0668 at 0x0450 // Inputs[6] // { // @0452 stack[-3] // @0452 stack[-1] // @0456 stack[-11] // @045D stack[-10] // @045E stack[-7] // @0460 memory[stack[-10]:stack[-10] + 0x20] // } 0451 5B JUMPDEST 0452 91 SWAP2 0453 50 POP 0454 60 PUSH1 0x03 0456 8A DUP11 0457 01 ADD 0458 99 SWAP10 0459 50 POP 045A 61 PUSH2 0x048e 045D 89 DUP10 045E 87 DUP8 045F 81 DUP2 0460 51 MLOAD 0461 81 DUP2 0462 10 LT 0463 61 PUSH2 0x0468 0466 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0452 stack[-3] = stack[-1] // @0458 stack[-11] = stack[-11] + 0x03 // @045A stack[-1] = 0x048e // @045D stack[0] = stack[-10] // @045E stack[1] = stack[-7] // } // Block ends with conditional call to 0x0468, returns to 0x048E, if stack[-7] < memory[stack[-10]:stack[-10] + 0x20] label_0467: // Incoming jump from 0x0466, if not stack[-7] < memory[stack[-10]:stack[-10] + 0x20] 0467 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0467 assert(); } // Block terminates label_0468: // Incoming call from 0x0466, returns to 0x048E, if stack[-7] < memory[stack[-10]:stack[-10] + 0x20] // Inputs[6] // { // @0469 stack[-1] // @0469 stack[-2] // @0472 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0473 stack[-11] // @0474 stack[-9] // @0476 memory[stack[-11]:stack[-11] + 0x20] // } 0468 5B JUMPDEST 0469 90 SWAP1 046A 60 PUSH1 0x20 046C 01 ADD 046D 90 SWAP1 046E 60 PUSH1 0x20 0470 02 MUL 0471 01 ADD 0472 51 MLOAD 0473 89 DUP10 0474 88 DUP9 0475 81 DUP2 0476 51 MLOAD 0477 81 DUP2 0478 10 LT 0479 61 PUSH2 0x047e 047C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0472 stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0473 stack[-1] = stack[-11] // @0474 stack[0] = stack[-9] // } // Block ends with conditional jump to 0x047e, if stack[-9] < memory[stack[-11]:stack[-11] + 0x20] label_047D: // Incoming jump from 0x047C, if not stack[-9] < memory[stack[-11]:stack[-11] + 0x20] 047D FE *ASSERT // Stack delta = +0 // Outputs[1] { @047D assert(); } // Block terminates label_047E: // Incoming jump from 0x047C, if stack[-9] < memory[stack[-11]:stack[-11] + 0x20] // Inputs[4] // { // @047F stack[-1] // @047F stack[-2] // @0488 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0489 stack[-6] // } 047E 5B JUMPDEST 047F 90 SWAP1 0480 60 PUSH1 0x20 0482 01 ADD 0483 90 SWAP1 0484 60 PUSH1 0x20 0486 02 MUL 0487 01 ADD 0488 51 MLOAD 0489 84 DUP5 048A 61 PUSH2 0x067e 048D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0488 stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0489 stack[-1] = stack[-6] // } // Block ends with unconditional jump to 0x067e label_048E: // Incoming return from call to 0x0468 at 0x0466 // Inputs[2] // { // @048F stack[-1] // @048F stack[-2] // } 048E 5B JUMPDEST 048F 90 SWAP1 0490 50 POP // Stack delta = -1 // Outputs[1] { @048F stack[-2] = stack[-1] } // Block continues label_0491: // Incoming jump from 0x0490 // Incoming jump from 0x0445, if !stack[-1] // Inputs[1] { @0494 stack[-1] } 0491 5B JUMPDEST 0492 60 PUSH1 0x00 0494 81 DUP2 0495 60 PUSH1 0xff 0497 16 AND 0498 11 GT 0499 15 ISZERO 049A 61 PUSH2 0x04c0 049D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c0, if !(0xff & stack[-1] > 0x00) label_049E: // Incoming jump from 0x049D, if not !(0xff & stack[-1] > 0x00) // Inputs[4] // { // @049E stack[-1] // @049F stack[-7] // @04A0 stack[-6] // @04A2 memory[stack[-7]:stack[-7] + 0x20] // } 049E 80 DUP1 049F 87 DUP8 04A0 87 DUP8 04A1 81 DUP2 04A2 51 MLOAD 04A3 81 DUP2 04A4 10 LT 04A5 61 PUSH2 0x04aa 04A8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @049E stack[0] = stack[-1] // @049F stack[1] = stack[-7] // @04A0 stack[2] = stack[-6] // } // Block ends with conditional jump to 0x04aa, if stack[-6] < memory[stack[-7]:stack[-7] + 0x20] label_04A9: // Incoming jump from 0x04A8, if not stack[-6] < memory[stack[-7]:stack[-7] + 0x20] 04A9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @04A9 assert(); } // Block terminates label_04AA: // Incoming jump from 0x04A8, if stack[-6] < memory[stack[-7]:stack[-7] + 0x20] // Incoming jump from 0x04FD, if stack[-8] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[3] // { // @04AD stack[-1] // @04AE stack[-3] // @04B6 stack[-2] // } 04AA 5B JUMPDEST 04AB 60 PUSH1 0xff 04AD 90 SWAP1 04AE 92 SWAP3 04AF 16 AND 04B0 60 PUSH1 0x20 04B2 92 SWAP3 04B3 83 DUP4 04B4 02 MUL 04B5 90 SWAP1 04B6 91 SWAP2 04B7 01 ADD 04B8 90 SWAP1 04B9 91 SWAP2 04BA 01 ADD 04BB 52 MSTORE 04BC 61 PUSH2 0x0533 04BF 56 *JUMP // Stack delta = -3 // Outputs[1] { @04BB memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff } // Block ends with unconditional jump to 0x0533 label_04C0: // Incoming jump from 0x049D, if !(0xff & stack[-1] > 0x00) // Inputs[2] // { // @04C4 stack[-11] // @04C7 stack[-10] // } 04C0 5B JUMPDEST 04C1 61 PUSH2 0x04cc 04C4 8B DUP12 04C5 60 PUSH1 0x01 04C7 8C DUP13 04C8 61 PUSH2 0x0668 04CB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04C1 stack[0] = 0x04cc // @04C4 stack[1] = stack[-11] // @04C5 stack[2] = 0x01 // @04C7 stack[3] = stack[-10] // } // Block ends with call to 0x0668, returns to 0x04CC label_04CC: // Incoming return from call to 0x0668 at 0x04CB // Inputs[3] // { // @04CD stack[-3] // @04CD stack[-1] // @04D1 stack[-11] // } 04CC 5B JUMPDEST 04CD 91 SWAP2 04CE 50 POP 04CF 60 PUSH1 0x01 04D1 8A DUP11 04D2 01 ADD 04D3 99 SWAP10 04D4 50 POP 04D5 81 DUP2 04D6 60 PUSH1 0x00 04D8 14 EQ 04D9 15 ISZERO 04DA 61 PUSH2 0x04ff 04DD 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @04CD stack[-3] = stack[-1] // @04D3 stack[-11] = stack[-11] + 0x01 // } // Block ends with conditional jump to 0x04ff, if !(0x00 == stack[-1]) label_04DE: // Incoming jump from 0x04DD, if not !(0x00 == stack[-1]) // Inputs[3] // { // @04DE stack[-9] // @04DF stack[-6] // @04E1 memory[stack[-9]:stack[-9] + 0x20] // } 04DE 88 DUP9 04DF 86 DUP7 04E0 81 DUP2 04E1 51 MLOAD 04E2 81 DUP2 04E3 10 LT 04E4 61 PUSH2 0x04e9 04E7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @04DE stack[0] = stack[-9] // @04DF stack[1] = stack[-6] // } // Block ends with conditional jump to 0x04e9, if stack[-6] < memory[stack[-9]:stack[-9] + 0x20] label_04E8: // Incoming jump from 0x04E7, if not stack[-6] < memory[stack[-9]:stack[-9] + 0x20] 04E8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @04E8 assert(); } // Block terminates label_04E9: // Incoming jump from 0x04E7, if stack[-6] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[6] // { // @04EA stack[-2] // @04EA stack[-1] // @04F3 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @04F4 stack[-9] // @04F5 stack[-8] // @04F7 memory[stack[-9]:stack[-9] + 0x20] // } 04E9 5B JUMPDEST 04EA 90 SWAP1 04EB 60 PUSH1 0x20 04ED 01 ADD 04EE 90 SWAP1 04EF 60 PUSH1 0x20 04F1 02 MUL 04F2 01 ADD 04F3 51 MLOAD 04F4 87 DUP8 04F5 87 DUP8 04F6 81 DUP2 04F7 51 MLOAD 04F8 81 DUP2 04F9 10 LT 04FA 61 PUSH2 0x04aa 04FD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @04F3 stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @04F4 stack[-1] = stack[-9] // @04F5 stack[0] = stack[-8] // } // Block ends with conditional jump to 0x04aa, if stack[-8] < memory[stack[-9]:stack[-9] + 0x20] label_04FE: // Incoming jump from 0x04FD, if not stack[-8] < memory[stack[-9]:stack[-9] + 0x20] 04FE FE *ASSERT // Stack delta = +0 // Outputs[1] { @04FE assert(); } // Block terminates label_04FF: // Incoming jump from 0x04DD, if !(0x00 == stack[-1]) // Inputs[3] // { // @0500 stack[-8] // @0501 stack[-6] // @0503 memory[stack[-8]:stack[-8] + 0x20] // } 04FF 5B JUMPDEST 0500 87 DUP8 0501 86 DUP7 0502 81 DUP2 0503 51 MLOAD 0504 81 DUP2 0505 10 LT 0506 61 PUSH2 0x050b 0509 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0500 stack[0] = stack[-8] // @0501 stack[1] = stack[-6] // } // Block ends with conditional jump to 0x050b, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20] label_050A: // Incoming jump from 0x0509, if not stack[-6] < memory[stack[-8]:stack[-8] + 0x20] 050A FE *ASSERT // Stack delta = +0 // Outputs[1] { @050A assert(); } // Block terminates label_050B: // Incoming jump from 0x0509, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20] // Inputs[6] // { // @050C stack[-1] // @050C stack[-2] // @0515 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0516 stack[-9] // @0517 stack[-8] // @0519 memory[stack[-9]:stack[-9] + 0x20] // } 050B 5B JUMPDEST 050C 90 SWAP1 050D 60 PUSH1 0x20 050F 01 ADD 0510 90 SWAP1 0511 60 PUSH1 0x20 0513 02 MUL 0514 01 ADD 0515 51 MLOAD 0516 87 DUP8 0517 87 DUP8 0518 81 DUP2 0519 51 MLOAD 051A 81 DUP2 051B 10 LT 051C 61 PUSH2 0x0521 051F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0515 stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0516 stack[-1] = stack[-9] // @0517 stack[0] = stack[-8] // } // Block ends with conditional jump to 0x0521, if stack[-8] < memory[stack[-9]:stack[-9] + 0x20] label_0520: // Incoming jump from 0x051F, if not stack[-8] < memory[stack[-9]:stack[-9] + 0x20] 0520 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0520 assert(); } // Block terminates label_0521: // Incoming jump from 0x051F, if stack[-8] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[3] // { // @0524 stack[-1] // @0525 stack[-3] // @052D stack[-2] // } 0521 5B JUMPDEST 0522 60 PUSH1 0xff 0524 90 SWAP1 0525 92 SWAP3 0526 16 AND 0527 60 PUSH1 0x20 0529 92 SWAP3 052A 83 DUP4 052B 02 MUL 052C 90 SWAP1 052D 91 SWAP2 052E 01 ADD 052F 90 SWAP1 0530 91 SWAP2 0531 01 ADD 0532 52 MSTORE // Stack delta = -3 // Outputs[1] { @0532 memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff } // Block continues label_0533: // Incoming jump from 0x04BF // Incoming jump from 0x0532 // Inputs[2] // { // @0536 stack[-1] // @0537 stack[-6] // } 0533 5B JUMPDEST 0534 60 PUSH1 0x01 0536 90 SWAP1 0537 95 SWAP6 0538 01 ADD 0539 94 SWAP5 053A 61 PUSH2 0x03f3 053D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0539 stack[-6] = stack[-6] + 0x01 // @0539 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x03f3 label_053E: // Incoming jump from 0x03FC, if !(stack[-6] < 0x30) // Incoming jump from 0x03FC, if !(0x00 < 0x30) // Inputs[1] { @0542 stack[-7] } 053E 5B JUMPDEST 053F 61 PUSH2 0x0547 0542 87 DUP8 0543 61 PUSH2 0x055a 0546 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @053F stack[0] = 0x0547 // @0542 stack[1] = stack[-7] // } // Block ends with call to 0x055a, returns to 0x0547 label_0547: // Incoming return from call to 0x055A at 0x0546 // Inputs[3] // { // @0548 stack[-1] // @0548 stack[-17] // @0549 stack[-16] // } 0547 5B JUMPDEST 0548 9F SWAP16 0549 9E SWAP15 054A 50 POP 054B 50 POP 054C 50 POP 054D 50 POP 054E 50 POP 054F 50 POP 0550 50 POP 0551 50 POP 0552 50 POP 0553 50 POP 0554 50 POP 0555 50 POP 0556 50 POP 0557 50 POP 0558 50 POP 0559 56 *JUMP // Stack delta = -16 // Outputs[1] { @0548 stack[-17] = stack[-1] } // Block ends with unconditional jump to stack[-17] label_055A: // Incoming call from 0x00ED, returns to 0x008D // Incoming call from 0x0546, returns to 0x0547 055A 5B JUMPDEST 055B 60 PUSH1 0x00 055D 80 DUP1 055E 5B JUMPDEST 055F 60 PUSH1 0x30 0561 81 DUP2 0562 10 LT 0563 15 ISZERO 0564 61 PUSH2 0x0597 0567 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @055B stack[0] = 0x00 // @055D stack[1] = 0x00 // } // Block ends with conditional jump to 0x0597, if !(0x00 < 0x30) label_0568: // Incoming jump from 0x0567, if not !(0x00 < 0x30) // Incoming jump from 0x0567, if not !(stack[-1] < 0x30) // Inputs[4] // { // @056A stack[-1] // @056B stack[-2] // @056E stack[-3] // @0575 memory[stack[-3]:stack[-3] + 0x20] // } 0568 60 PUSH1 0x20 056A 90 SWAP1 056B 91 SWAP2 056C 02 MUL 056D 90 SWAP1 056E 82 DUP3 056F 60 PUSH1 0x2f 0571 82 DUP3 0572 90 SWAP1 0573 03 SUB 0574 81 DUP2 0575 51 MLOAD 0576 81 DUP2 0577 10 LT 0578 61 PUSH2 0x057d 057B 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @056D stack[-2] = stack[-2] * 0x20 // @056D stack[-1] = stack[-1] // @056E stack[0] = stack[-3] // @0573 stack[1] = 0x2f - stack[-1] // } // Block ends with conditional jump to 0x057d, if 0x2f - stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_057C: // Incoming jump from 0x057B, if not 0x2f - stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 057C FE *ASSERT // Stack delta = +0 // Outputs[1] { @057C assert(); } // Block terminates label_057D: // Incoming jump from 0x057B, if 0x2f - stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @057E stack[-1] // @057E stack[-2] // @0587 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @058B stack[-4] // @058C stack[-3] // } 057D 5B JUMPDEST 057E 90 SWAP1 057F 60 PUSH1 0x20 0581 01 ADD 0582 90 SWAP1 0583 60 PUSH1 0x20 0585 02 MUL 0586 01 ADD 0587 51 MLOAD 0588 60 PUSH1 0xff 058A 16 AND 058B 91 SWAP2 058C 90 SWAP1 058D 91 SWAP2 058E 17 OR 058F 90 SWAP1 0590 60 PUSH1 0x01 0592 01 ADD 0593 61 PUSH2 0x055e 0596 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @058F stack[-4] = (0xff & memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]) | stack[-4] // @0592 stack[-3] = 0x01 + stack[-3] // } // Block ends with unconditional jump to 0x055e label_0597: // Incoming jump from 0x0567, if !(0x00 < 0x30) // Incoming jump from 0x0567, if !(stack[-1] < 0x30) // Inputs[3] // { // @0599 stack[-4] // @0599 stack[-2] // @059A stack[-3] // } 0597 5B JUMPDEST 0598 50 POP 0599 91 SWAP2 059A 90 SWAP1 059B 50 POP 059C 56 *JUMP // Stack delta = -3 // Outputs[1] { @0599 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_059D: // Incoming call from 0x0100, returns to 0x0101 // Inputs[2] // { // @05A0 storage[0x00] // @05A4 stack[-1] // } 059D 5B JUMPDEST 059E 60 PUSH1 0x00 05A0 54 SLOAD 05A1 60 PUSH1 0xff 05A3 16 AND 05A4 81 DUP2 05A5 56 *JUMP // Stack delta = +1 // Outputs[1] { @05A3 stack[0] = 0xff & storage[0x00] } // Block ends with unconditional jump to stack[-1] label_05A6: // Incoming call from 0x0268, returns to 0x0269 // Incoming call from 0x0273, returns to 0x0274 // Incoming call from 0x012A, returns to 0x012B 05A6 5B JUMPDEST 05A7 61 PUSH2 0x05ae 05AA 61 PUSH2 0x0709 05AD 56 *JUMP // Stack delta = +1 // Outputs[1] { @05A7 stack[0] = 0x05ae } // Block ends with call to 0x0709, returns to 0x05AE label_05AE: // Incoming return from call to 0x0709 at 0x05AD 05AE 5B JUMPDEST 05AF 61 PUSH2 0x05b6 05B2 61 PUSH2 0x0709 05B5 56 *JUMP // Stack delta = +1 // Outputs[1] { @05AF stack[0] = 0x05b6 } // Block ends with call to 0x0709, returns to 0x05B6 label_05B6: // Incoming return from call to 0x0709 at 0x05B5 // Inputs[2] // { // @05BD memory[0x40:0x60] // @05BF MSIZE() // } 05B6 5B JUMPDEST 05B7 60 PUSH1 0x00 05B9 60 PUSH1 0x30 05BB 60 PUSH1 0x40 05BD 51 MLOAD 05BE 80 DUP1 05BF 59 MSIZE 05C0 10 LT 05C1 61 PUSH2 0x05c7 05C4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05B7 stack[0] = 0x00 // @05B9 stack[1] = 0x30 // @05BD stack[2] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x05c7, if MSIZE() < memory[0x40:0x60] label_05C5: // Incoming jump from 0x05C4, if not MSIZE() < memory[0x40:0x60] // Inputs[4] // { // @05C6 MSIZE() // @05C8 stack[-2] // @05D9 stack[-4] // @05DD stack[-3] // } 05C5 50 POP 05C6 59 MSIZE 05C7 5B JUMPDEST 05C8 90 SWAP1 05C9 80 DUP1 05CA 82 DUP3 05CB 52 MSTORE 05CC 80 DUP1 05CD 60 PUSH1 0x20 05CF 02 MUL 05D0 60 PUSH1 0x20 05D2 01 ADD 05D3 82 DUP3 05D4 01 ADD 05D5 60 PUSH1 0x40 05D7 52 MSTORE 05D8 50 POP 05D9 91 SWAP2 05DA 50 POP 05DB 60 PUSH1 0x00 05DD 90 SWAP1 05DE 50 POP 05DF 5B JUMPDEST 05E0 60 PUSH1 0x30 05E2 81 DUP2 05E3 10 LT 05E4 15 ISZERO 05E5 61 PUSH2 0x0617 05E8 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @05CB memory[MSIZE():MSIZE() + 0x20] = stack[-2] // @05D7 memory[0x40:0x60] = MSIZE() + 0x20 + 0x20 * stack[-2] // @05D9 stack[-4] = MSIZE() // @05DD stack[-3] = 0x00 // } // Block ends with conditional jump to 0x0617, if !(0x00 < 0x30) label_05E9: // Incoming jump from 0x05E8, if not !(0x00 < 0x30) // Incoming jump from 0x05E8, if not !(0x00 < 0x30) // Incoming jump from 0x05E8, if not !(stack[-1] < 0x30) // Inputs[2] // { // @05EC stack[-4] // @05ED stack[-1] // } 05E9 61 PUSH2 0x05f2 05EC 84 DUP5 05ED 82 DUP3 05EE 61 PUSH2 0x06f1 05F1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05E9 stack[0] = 0x05f2 // @05EC stack[1] = stack[-4] // @05ED stack[2] = stack[-1] // } // Block ends with call to 0x06f1, returns to 0x05F2 label_05F2: // Incoming return from call to 0x06F1 at 0x05F1 // Inputs[3] // { // @05F3 stack[-3] // @05F4 stack[-2] // @05F6 memory[stack[-3]:stack[-3] + 0x20] // } 05F2 5B JUMPDEST 05F3 82 DUP3 05F4 82 DUP3 05F5 81 DUP2 05F6 51 MLOAD 05F7 81 DUP2 05F8 10 LT 05F9 61 PUSH2 0x05fe 05FC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @05F3 stack[0] = stack[-3] // @05F4 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x05fe, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_05FD: // Incoming jump from 0x05FC, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] 05FD FE *ASSERT // Stack delta = +0 // Outputs[1] { @05FD assert(); } // Block terminates label_05FE: // Incoming jump from 0x05FC, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0601 stack[-1] // @0602 stack[-3] // @060A stack[-2] // @0612 stack[-4] // } 05FE 5B JUMPDEST 05FF 60 PUSH1 0xff 0601 90 SWAP1 0602 92 SWAP3 0603 16 AND 0604 60 PUSH1 0x20 0606 92 SWAP3 0607 83 DUP4 0608 02 MUL 0609 90 SWAP1 060A 91 SWAP2 060B 01 ADD 060C 90 SWAP1 060D 91 SWAP2 060E 01 ADD 060F 52 MSTORE 0610 60 PUSH1 0x01 0612 01 ADD 0613 61 PUSH2 0x05df 0616 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @060F memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff // @0612 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x05df label_0617: // Incoming jump from 0x063A, if !(stack[-1] < 0x0c) // Incoming jump from 0x05E8, if !(0x00 < 0x30) // Incoming jump from 0x063A, if !(0x00 < 0x0c) // Incoming jump from 0x05E8, if !(0x00 < 0x30) // Incoming jump from 0x05E8, if !(stack[-1] < 0x30) // Inputs[3] // { // @0619 stack[-2] // @0619 stack[-5] // @061A stack[-4] // } 0617 5B JUMPDEST 0618 50 POP 0619 92 SWAP3 061A 91 SWAP2 061B 50 POP 061C 50 POP 061D 56 *JUMP // Stack delta = -4 // Outputs[1] { @0619 stack[-5] = stack[-2] } // Block ends with unconditional jump to stack[-5] label_061E: // Incoming call from 0x0193, returns to 0x0194 061E 5B JUMPDEST 061F 61 PUSH2 0x0626 0622 61 PUSH2 0x071b 0625 56 *JUMP // Stack delta = +1 // Outputs[1] { @061F stack[0] = 0x0626 } // Block ends with call to 0x071b, returns to 0x0626 label_0626: // Incoming return from call to 0x071B at 0x0625 0626 5B JUMPDEST 0627 61 PUSH2 0x062e 062A 61 PUSH2 0x071b 062D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0627 stack[0] = 0x062e } // Block ends with call to 0x071b, returns to 0x062E label_062E: // Incoming return from call to 0x071B at 0x062D 062E 5B JUMPDEST 062F 60 PUSH1 0x00 0631 5B JUMPDEST 0632 60 PUSH1 0x0c 0634 81 DUP2 0635 10 LT 0636 15 ISZERO 0637 61 PUSH2 0x0617 063A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @062F stack[0] = 0x00 } // Block ends with conditional jump to 0x0617, if !(0x00 < 0x0c) label_063B: // Incoming jump from 0x063A, if not !(0x00 < 0x0c) // Incoming jump from 0x063A, if not !(stack[-1] < 0x0c) // Inputs[2] // { // @063E stack[-4] // @063F stack[-1] // } 063B 61 PUSH2 0x0647 063E 84 DUP5 063F 82 DUP3 0640 60 PUSH1 0x04 0642 02 MUL 0643 61 PUSH2 0x06f1 0646 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @063B stack[0] = 0x0647 // @063E stack[1] = stack[-4] // @0642 stack[2] = 0x04 * stack[-1] // } // Block ends with call to 0x06f1, returns to 0x0647 label_0647: // Incoming return from call to 0x06F1 at 0x0646 // Inputs[2] // { // @0648 stack[-3] // @0649 stack[-2] // } 0647 5B JUMPDEST 0648 82 DUP3 0649 82 DUP3 064A 60 PUSH1 0x0c 064C 81 DUP2 064D 10 LT 064E 61 PUSH2 0x0653 0651 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0648 stack[0] = stack[-3] // @0649 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0653, if stack[-2] < 0x0c label_0652: // Incoming jump from 0x0651, if not stack[-2] < 0x0c 0652 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0652 assert(); } // Block terminates label_0653: // Incoming jump from 0x0651, if stack[-2] < 0x0c // Inputs[4] // { // @0656 stack[-1] // @0657 stack[-3] // @065F stack[-2] // @0663 stack[-4] // } 0653 5B JUMPDEST 0654 60 PUSH1 0xff 0656 90 SWAP1 0657 92 SWAP3 0658 16 AND 0659 60 PUSH1 0x20 065B 92 SWAP3 065C 90 SWAP1 065D 92 SWAP3 065E 02 MUL 065F 01 ADD 0660 52 MSTORE 0661 60 PUSH1 0x01 0663 01 ADD 0664 61 PUSH2 0x0631 0667 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0660 memory[0x20 * stack[-1] + stack[-2]:0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] & 0xff // @0663 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x0631 label_0668: // Incoming call from 0x02C6, returns to 0x02C7 // Incoming call from 0x0701, returns to 0x0702 // Incoming call from 0x04CB, returns to 0x04CC // Incoming call from 0x0450, returns to 0x0451 // Incoming call from 0x0354, returns to 0x0355 // Inputs[4] // { // @066B stack[-1] // @066E stack[-2] // @0677 stack[-3] // @067C stack[-4] // } 0668 5B JUMPDEST 0669 60 PUSH1 0x02 066B 90 SWAP1 066C 81 DUP2 066D 0A EXP 066E 91 SWAP2 066F 90 SWAP1 0670 0A EXP 0671 60 PUSH1 0x00 0673 19 NOT 0674 01 ADD 0675 81 DUP2 0676 02 MUL 0677 91 SWAP2 0678 90 SWAP1 0679 91 SWAP2 067A 16 AND 067B 04 DIV 067C 90 SWAP1 067D 56 *JUMP // Stack delta = -3 // Outputs[1] { @067C stack[-4] = (0x02 ** stack[-1] * (~0x00 + 0x02 ** stack[-2]) & stack[-3]) / 0x02 ** stack[-1] } // Block ends with unconditional jump to stack[-4] label_067E: // Incoming jump from 0x048D // Inputs[2] // { // @0681 stack[-3] // @0682 stack[-2] // } 067E 5B JUMPDEST 067F 60 PUSH1 0x00 0681 83 DUP4 0682 83 DUP4 0683 82 DUP3 0684 60 PUSH1 0xff 0686 80 DUP1 0687 83 DUP4 0688 16 AND 0689 90 SWAP1 068A 84 DUP5 068B 16 AND 068C 11 GT 068D 15 ISZERO 068E 61 PUSH2 0x0698 0691 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @067F stack[0] = 0x00 // @0681 stack[1] = stack[-3] // @0682 stack[2] = stack[-2] // @0683 stack[3] = 0x00 // } // Block ends with conditional jump to 0x0698, if !(stack[-3] & 0xff > stack[-2] & 0xff) label_0692: // Incoming jump from 0x0691, if not !(stack[-3] & 0xff > stack[-2] & 0xff) // Inputs[4] // { // @0692 stack[-7] // @0693 stack[-2] // @0695 stack[-6] // @0696 stack[-3] // } 0692 86 DUP7 0693 91 SWAP2 0694 50 POP 0695 85 DUP6 0696 92 SWAP3 0697 50 POP 0698 5B JUMPDEST 0699 82 DUP3 069A 82 DUP3 069B 03 SUB 069C 60 PUSH1 0xff 069E 16 AND 069F 60 PUSH1 0x01 06A1 14 EQ 06A2 80 DUP1 06A3 15 ISZERO 06A4 61 PUSH2 0x06b6 06A7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0693 stack[-2] = stack[-7] // @0696 stack[-3] = stack[-6] // @06A1 stack[0] = 0x01 == 0xff & stack[-7] - stack[-6] // } // Block ends with conditional jump to 0x06b6, if !(0x01 == 0xff & stack[-7] - stack[-6]) label_06A8: // Incoming jump from 0x06A7, if not !(0x01 == 0xff & stack[-2] - stack[-3]) // Incoming jump from 0x06A7, if not !(0x01 == 0xff & stack[-7] - stack[-6]) // Inputs[1] { @06AD stack[-4] } 06A8 50 POP 06A9 60 PUSH1 0x02 06AB 60 PUSH1 0xff 06AD 84 DUP5 06AE 16 AND 06AF 06 MOD 06B0 60 PUSH1 0xff 06B2 16 AND 06B3 60 PUSH1 0x00 06B5 14 EQ 06B6 5B JUMPDEST 06B7 15 ISZERO 06B8 61 PUSH2 0x06e7 06BB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06e7, if !(0x00 == 0xff & (stack[-4] & 0xff) % 0x02) label_06BC: // Incoming jump from 0x06BB, if not !(0x00 == 0xff & (stack[-4] & 0xff) % 0x02) // Incoming jump from 0x06BB, if not !stack[-1] // Inputs[1] { @06BE stack[-3] } 06BC 60 PUSH1 0x17 06BE 83 DUP4 06BF 60 PUSH1 0xff 06C1 16 AND 06C2 10 LT 06C3 15 ISZERO 06C4 61 PUSH2 0x06cf 06C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06cf, if !(0xff & stack[-3] < 0x17) label_06C8: // Incoming jump from 0x06C7, if not !(0xff & stack[-3] < 0x17) 06C8 50 POP 06C9 60 PUSH1 0x01 06CB 61 PUSH2 0x06d3 06CE 56 *JUMP // Stack delta = +0 // Outputs[1] { @06C9 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x06d3 label_06CF: // Incoming jump from 0x06C7, if !(0xff & stack[-3] < 0x17) // Inputs[1] { @06D5 stack[-5] } 06CF 5B JUMPDEST 06D0 50 POP 06D1 60 PUSH1 0x00 06D3 5B JUMPDEST 06D4 80 DUP1 06D5 85 DUP6 06D6 11 GT 06D7 61 PUSH2 0x06e7 06DA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @06D1 stack[-1] = 0x00 } // Block ends with conditional jump to 0x06e7, if stack[-5] > 0x00 label_06DB: // Incoming jump from 0x06DA, if not stack[-5] > 0x00 // Incoming jump from 0x06DA, if not stack[-5] > stack[-1] // Inputs[2] // { // @06DF stack[-3] // @06E5 stack[-4] // } 06DB 60 PUSH1 0x02 06DD 60 PUSH1 0xff 06DF 84 DUP5 06E0 16 AND 06E1 04 DIV 06E2 60 PUSH1 0x10 06E4 01 ADD 06E5 93 SWAP4 06E6 50 POP // Stack delta = +0 // Outputs[1] { @06E5 stack[-4] = 0x10 + (stack[-3] & 0xff) / 0x02 } // Block continues label_06E7: // Incoming jump from 0x06DA, if stack[-5] > 0x00 // Incoming jump from 0x06E6 // Incoming jump from 0x06BB, if !(0x00 == 0xff & (stack[-4] & 0xff) % 0x02) // Incoming jump from 0x06BB, if !stack[-1] // Incoming jump from 0x06DA, if stack[-5] > stack[-1] // Inputs[3] // { // @06EB stack[-4] // @06EB stack[-8] // @06EC stack[-7] // } 06E7 5B JUMPDEST 06E8 50 POP 06E9 50 POP 06EA 50 POP 06EB 93 SWAP4 06EC 92 SWAP3 06ED 50 POP 06EE 50 POP 06EF 50 POP 06F0 56 *JUMP // Stack delta = -7 // Outputs[1] { @06EB stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_06F1: // Incoming call from 0x05F1, returns to 0x05F2 // Incoming call from 0x0646, returns to 0x0647 // Inputs[2] // { // @06F7 stack[-2] // @06FA stack[-1] // } 06F1 5B JUMPDEST 06F2 60 PUSH1 0x00 06F4 61 PUSH2 0x0702 06F7 83 DUP4 06F8 60 PUSH1 0x05 06FA 84 DUP5 06FB 60 PUSH1 0x05 06FD 02 MUL 06FE 61 PUSH2 0x0668 0701 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @06F2 stack[0] = 0x00 // @06F4 stack[1] = 0x0702 // @06F7 stack[2] = stack[-2] // @06F8 stack[3] = 0x05 // @06FD stack[4] = 0x05 * stack[-1] // } // Block ends with call to 0x0668, returns to 0x0702 label_0702: // Incoming return from call to 0x0668 at 0x0701 // Inputs[3] // { // @0703 stack[-5] // @0703 stack[-1] // @0704 stack[-4] // } 0702 5B JUMPDEST 0703 93 SWAP4 0704 92 SWAP3 0705 50 POP 0706 50 POP 0707 50 POP 0708 56 *JUMP // Stack delta = -4 // Outputs[1] { @0703 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0709: // Incoming call from 0x01E1, returns to 0x01E2 // Incoming call from 0x05AD, returns to 0x05AE // Incoming call from 0x01D9, returns to 0x01DA // Incoming call from 0x05B5, returns to 0x05B6 // Incoming call from 0x01E9, returns to 0x01EA // Inputs[2] // { // @070E memory[0x40:0x60] // @0719 stack[-1] // } 0709 5B JUMPDEST 070A 60 PUSH1 0x20 070C 60 PUSH1 0x40 070E 51 MLOAD 070F 90 SWAP1 0710 81 DUP2 0711 01 ADD 0712 60 PUSH1 0x40 0714 52 MSTORE 0715 60 PUSH1 0x00 0717 81 DUP2 0718 52 MSTORE 0719 90 SWAP1 071A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0714 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0718 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0719 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_071B: // Incoming call from 0x062D, returns to 0x062E // Incoming call from 0x0625, returns to 0x0626 // Inputs[1] { @0721 memory[0x40:0x60] } 071B 5B JUMPDEST 071C 61 PUSH2 0x0180 071F 60 PUSH1 0x40 0721 51 MLOAD 0722 90 SWAP1 0723 81 DUP2 0724 01 ADD 0725 60 PUSH1 0x40 0727 52 MSTORE 0728 60 PUSH1 0x0c 072A 81 DUP2 072B 5B JUMPDEST 072C 60 PUSH1 0x00 072E 81 DUP2 072F 52 MSTORE 0730 60 PUSH1 0x00 0732 19 NOT 0733 90 SWAP1 0734 91 SWAP2 0735 01 ADD 0736 90 SWAP1 0737 60 PUSH1 0x20 0739 01 ADD 073A 81 DUP2 073B 61 PUSH2 0x072b 073E 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0722 stack[0] = memory[0x40:0x60] // @0727 memory[0x40:0x60] = memory[0x40:0x60] + 0x0180 // @072F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0736 stack[1] = 0x0c + ~0x00 // @0739 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x072b, if 0x0c + ~0x00 label_073F: // Incoming jump from 0x073E, if not stack[-2] + ~0x00 // Incoming jump from 0x073E, if not 0x0c + ~0x00 // Inputs[4] // { // @073F stack[-1] // @073F stack[-2] // @0742 stack[-4] // @0742 stack[-3] // } 073F 90 SWAP1 0740 50 POP 0741 50 POP 0742 90 SWAP1 0743 56 *JUMP // Stack delta = -3 // Outputs[1] { @0742 stack[-4] = stack[-3] } // Block ends with unconditional jump to stack[-4] 0744 00 *STOP 0745 A1 LOG1 0746 65 PUSH6 0x627a7a723058 074D 20 SHA3 074E 02 MUL 074F 48 48 0750 3C EXTCODECOPY 0751 C8 C8 0752 EE EE 0753 32 ORIGIN 0754 39 CODECOPY 0755 61 PUSH2 0xb70a 0758 73 PUSH20 0x1235c3564df45a0ae6eb45983dc9e88e1c380635 076D 78 PUSH25 0x0029
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]