Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x023b 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x023b, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x6ad1fe02 0019 11 GT 001A 61 PUSH2 0x012e 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x012e, if 0x6ad1fe02 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6ad1fe02 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xba41b0c6 0024 11 GT 0025 61 PUSH2 0x00ab 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ab, if 0xba41b0c6 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xba41b0c6 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xdab5f340 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xdab5f340 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xdab5f340 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xdab5f340 003A 14 EQ 003B 61 PUSH2 0x065f 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065f, if 0xdab5f340 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xdab5f340 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x067f 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x067f, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xebf0c717 0050 14 EQ 0051 61 PUSH2 0x06c8 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c8, if 0xebf0c717 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xebf0c717 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x06de 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06de, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xfebfec50 0066 14 EQ 0067 61 PUSH2 0x06fe 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06fe, if 0xfebfec50 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xfebfec50 == stack[-1] // Inputs[1] { @006E memory[0x00:0x00] } 006B 60 PUSH1 0x00 006D 80 DUP1 006E FD *REVERT // Stack delta = +0 // Outputs[1] { @006E revert(memory[0x00:0x00]); } // Block terminates label_006F: // Incoming jump from 0x0033, if 0xdab5f340 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xba41b0c6 0076 14 EQ 0077 61 PUSH2 0x05e0 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e0, if 0xba41b0c6 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xba41b0c6 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xbc63f02e 0081 14 EQ 0082 61 PUSH2 0x05f3 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f3, if 0xbc63f02e == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xbc63f02e == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc87b56dd 008C 14 EQ 008D 61 PUSH2 0x0613 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0613, if 0xc87b56dd == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xcc9ff9c6 0097 14 EQ 0098 61 PUSH2 0x0633 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0633, if 0xcc9ff9c6 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xcc9ff9c6 == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xd5abeb01 00A2 14 EQ 00A3 61 PUSH2 0x0649 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0649, if 0xd5abeb01 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @00AA memory[0x00:0x00] } 00A7 60 PUSH1 0x00 00A9 80 DUP1 00AA FD *REVERT // Stack delta = +0 // Outputs[1] { @00AA revert(memory[0x00:0x00]); } // Block terminates label_00AB: // Incoming jump from 0x0028, if 0xba41b0c6 > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AB 5B JUMPDEST 00AC 80 DUP1 00AD 63 PUSH4 0x8da5cb5b 00B2 11 GT 00B3 61 PUSH2 0x00f2 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f2, if 0x8da5cb5b > stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x8da5cb5b 00BD 14 EQ 00BE 61 PUSH2 0x0552 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0552, if 0x8da5cb5b == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x95d89b41 00C8 14 EQ 00C9 61 PUSH2 0x0575 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0575, if 0x95d89b41 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xa22cb465 00D3 14 EQ 00D4 61 PUSH2 0x058a 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058a, if 0xa22cb465 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0xa759a7c8 00DE 14 EQ 00DF 61 PUSH2 0x05aa 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05aa, if 0xa759a7c8 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xa759a7c8 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xb88d4fde 00E9 14 EQ 00EA 61 PUSH2 0x05c0 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c0, if 0xb88d4fde == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00F1 memory[0x00:0x00] } 00EE 60 PUSH1 0x00 00F0 80 DUP1 00F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F1 revert(memory[0x00:0x00]); } // Block terminates label_00F2: // Incoming jump from 0x00B6, if 0x8da5cb5b > stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F2 5B JUMPDEST 00F3 80 DUP1 00F4 63 PUSH4 0x6ad1fe02 00F9 14 EQ 00FA 61 PUSH2 0x04c1 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c1, if 0x6ad1fe02 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x6ad1fe02 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x6f8b44b0 0104 14 EQ 0105 61 PUSH2 0x04e8 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e8, if 0x6f8b44b0 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x6f8b44b0 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x6f9fb98a 010F 14 EQ 0110 61 PUSH2 0x0508 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0508, if 0x6f9fb98a == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x6f9fb98a == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x70a08231 011A 14 EQ 011B 61 PUSH2 0x051d 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051d, if 0x70a08231 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x70a08231 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x715018a6 0125 14 EQ 0126 61 PUSH2 0x053d 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053d, if 0x715018a6 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x715018a6 == stack[-1] // Inputs[1] { @012D memory[0x00:0x00] } 012A 60 PUSH1 0x00 012C 80 DUP1 012D FD *REVERT // Stack delta = +0 // Outputs[1] { @012D revert(memory[0x00:0x00]); } // Block terminates label_012E: // Incoming jump from 0x001D, if 0x6ad1fe02 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @012F stack[-1] } 012E 5B JUMPDEST 012F 80 DUP1 0130 63 PUSH4 0x2a3f300c 0135 11 GT 0136 61 PUSH2 0x01bc 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01bc, if 0x2a3f300c > stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x2a3f300c > stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x4f6ccce7 0140 11 GT 0141 61 PUSH2 0x0180 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0180, if 0x4f6ccce7 > stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x4f6ccce7 014B 14 EQ 014C 61 PUSH2 0x0428 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0428, if 0x4f6ccce7 == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x51830227 0156 14 EQ 0157 61 PUSH2 0x0448 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0448, if 0x51830227 == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x51830227 == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x55f804b3 0161 14 EQ 0162 61 PUSH2 0x0469 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0469, if 0x55f804b3 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x5c975abb 016C 14 EQ 016D 61 PUSH2 0x0489 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0489, if 0x5c975abb == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x5c975abb == stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x6352211e 0177 14 EQ 0178 61 PUSH2 0x04a1 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a1, if 0x6352211e == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x6352211e == stack[-1] // Inputs[1] { @017F memory[0x00:0x00] } 017C 60 PUSH1 0x00 017E 80 DUP1 017F FD *REVERT // Stack delta = +0 // Outputs[1] { @017F revert(memory[0x00:0x00]); } // Block terminates label_0180: // Incoming jump from 0x0144, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @0181 stack[-1] } 0180 5B JUMPDEST 0181 80 DUP1 0182 63 PUSH4 0x2a3f300c 0187 14 EQ 0188 61 PUSH2 0x03a0 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a0, if 0x2a3f300c == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x2a3f300c == stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x2f745c59 0192 14 EQ 0193 61 PUSH2 0x03c0 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c0, if 0x2f745c59 == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x3ccfd60b 019D 14 EQ 019E 61 PUSH2 0x03e0 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e0, if 0x3ccfd60b == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A2 80 DUP1 01A3 63 PUSH4 0x42842e0e 01A8 14 EQ 01A9 61 PUSH2 0x03e8 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e8, if 0x42842e0e == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x42842e0e == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x42966c68 01B3 14 EQ 01B4 61 PUSH2 0x0408 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0408, if 0x42966c68 == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x42966c68 == stack[-1] // Inputs[1] { @01BB memory[0x00:0x00] } 01B8 60 PUSH1 0x00 01BA 80 DUP1 01BB FD *REVERT // Stack delta = +0 // Outputs[1] { @01BB revert(memory[0x00:0x00]); } // Block terminates label_01BC: // Incoming jump from 0x0139, if 0x2a3f300c > stack[-1] // Inputs[1] { @01BD stack[-1] } 01BC 5B JUMPDEST 01BD 80 DUP1 01BE 63 PUSH4 0x13faede6 01C3 11 GT 01C4 61 PUSH2 0x0203 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0203, if 0x13faede6 > stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x13faede6 > stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C8 80 DUP1 01C9 63 PUSH4 0x13faede6 01CE 14 EQ 01CF 61 PUSH2 0x0311 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0311, if 0x13faede6 == stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x13faede6 == stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x16c38b3c 01D9 14 EQ 01DA 61 PUSH2 0x0335 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0335, if 0x16c38b3c == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x16c38b3c == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x18160ddd 01E4 14 EQ 01E5 61 PUSH2 0x0355 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0355, if 0x18160ddd == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x18160ddd == stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x239c70ae 01EF 14 EQ 01F0 61 PUSH2 0x036a 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036a, if 0x239c70ae == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x239c70ae == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x23b872dd 01FA 14 EQ 01FB 61 PUSH2 0x0380 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0380, if 0x23b872dd == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x23b872dd == stack[-1] // Inputs[1] { @0202 memory[0x00:0x00] } 01FF 60 PUSH1 0x00 0201 80 DUP1 0202 FD *REVERT // Stack delta = +0 // Outputs[1] { @0202 revert(memory[0x00:0x00]); } // Block terminates label_0203: // Incoming jump from 0x01C7, if 0x13faede6 > stack[-1] // Inputs[1] { @0204 stack[-1] } 0203 5B JUMPDEST 0204 80 DUP1 0205 63 PUSH4 0x01ffc9a7 020A 14 EQ 020B 61 PUSH2 0x0240 020E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0240, if 0x01ffc9a7 == stack[-1] label_020F: // Incoming jump from 0x020E, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @020F stack[-1] } 020F 80 DUP1 0210 63 PUSH4 0x06fdde03 0215 14 EQ 0216 61 PUSH2 0x0275 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0275, if 0x06fdde03 == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x06fdde03 == stack[-1] // Inputs[1] { @021A stack[-1] } 021A 80 DUP1 021B 63 PUSH4 0x081812fc 0220 14 EQ 0221 61 PUSH2 0x0297 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0297, if 0x081812fc == stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x081812fc == stack[-1] // Inputs[1] { @0225 stack[-1] } 0225 80 DUP1 0226 63 PUSH4 0x095ea7b3 022B 14 EQ 022C 61 PUSH2 0x02cf 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cf, if 0x095ea7b3 == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0230 stack[-1] } 0230 80 DUP1 0231 63 PUSH4 0x10ceb677 0236 14 EQ 0237 61 PUSH2 0x02f1 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f1, if 0x10ceb677 == stack[-1] label_023B: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x023A, if not 0x10ceb677 == stack[-1] // Inputs[1] { @023F memory[0x00:0x00] } 023B 5B JUMPDEST 023C 60 PUSH1 0x00 023E 80 DUP1 023F FD *REVERT // Stack delta = +0 // Outputs[1] { @023F revert(memory[0x00:0x00]); } // Block terminates label_0240: // Incoming jump from 0x020E, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0241 msg.value } 0240 5B JUMPDEST 0241 34 CALLVALUE 0242 80 DUP1 0243 15 ISZERO 0244 61 PUSH2 0x024c 0247 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0241 stack[0] = msg.value } // Block ends with conditional jump to 0x024c, if !msg.value label_0248: // Incoming jump from 0x0247, if not !msg.value // Inputs[1] { @024B memory[0x00:0x00] } 0248 60 PUSH1 0x00 024A 80 DUP1 024B FD *REVERT // Stack delta = +0 // Outputs[1] { @024B revert(memory[0x00:0x00]); } // Block terminates label_024C: // Incoming jump from 0x0247, if !msg.value // Inputs[1] { @0254 msg.data.length } 024C 5B JUMPDEST 024D 50 POP 024E 61 PUSH2 0x0260 0251 61 PUSH2 0x025b 0254 36 CALLDATASIZE 0255 60 PUSH1 0x04 0257 61 PUSH2 0x24e6 025A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @024E stack[-1] = 0x0260 // @0251 stack[0] = 0x025b // @0254 stack[1] = msg.data.length // @0255 stack[2] = 0x04 // } // Block ends with call to 0x24e6, returns to 0x025B label_025B: // Incoming return from call to 0x24E6 at 0x025A 025B 5B JUMPDEST 025C 61 PUSH2 0x071e 025F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x071e label_0260: // Incoming jump from 0x04A0 // Incoming jump from 0x0468 // Inputs[4] // { // @0263 memory[0x40:0x60] // @0264 stack[-1] // @026F memory[0x40:0x60] // @0274 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0260 5B JUMPDEST 0261 60 PUSH1 0x40 0263 51 MLOAD 0264 90 SWAP1 0265 15 ISZERO 0266 15 ISZERO 0267 81 DUP2 0268 52 MSTORE 0269 60 PUSH1 0x20 026B 01 ADD 026C 5B JUMPDEST 026D 60 PUSH1 0x40 026F 51 MLOAD 0270 80 DUP1 0271 91 SWAP2 0272 03 SUB 0273 90 SWAP1 0274 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0268 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0274 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0275: // Incoming jump from 0x0219, if 0x06fdde03 == stack[-1] // Inputs[1] { @0276 msg.value } 0275 5B JUMPDEST 0276 34 CALLVALUE 0277 80 DUP1 0278 15 ISZERO 0279 61 PUSH2 0x0281 027C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0276 stack[0] = msg.value } // Block ends with conditional jump to 0x0281, if !msg.value label_027D: // Incoming jump from 0x027C, if not !msg.value // Inputs[1] { @0280 memory[0x00:0x00] } 027D 60 PUSH1 0x00 027F 80 DUP1 0280 FD *REVERT // Stack delta = +0 // Outputs[1] { @0280 revert(memory[0x00:0x00]); } // Block terminates label_0281: // Incoming jump from 0x027C, if !msg.value 0281 5B JUMPDEST 0282 50 POP 0283 61 PUSH2 0x028a 0286 61 PUSH2 0x072f 0289 56 *JUMP // Stack delta = +0 // Outputs[1] { @0283 stack[-1] = 0x028a } // Block ends with call to 0x072f, returns to 0x028A label_028A: // Incoming return from call to 0x062E at 0x062D // Incoming return from call to 0x0ED0 at 0x0589 // Incoming return from call to 0x072F at 0x0289 // Inputs[2] // { // @028D memory[0x40:0x60] // @0291 stack[-1] // } 028A 5B JUMPDEST 028B 60 PUSH1 0x40 028D 51 MLOAD 028E 61 PUSH2 0x026c 0291 91 SWAP2 0292 90 SWAP1 0293 61 PUSH2 0x255b 0296 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0291 stack[-1] = 0x026c // @0292 stack[1] = memory[0x40:0x60] // @0292 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x255b label_0297: // Incoming jump from 0x0224, if 0x081812fc == stack[-1] // Inputs[1] { @0298 msg.value } 0297 5B JUMPDEST 0298 34 CALLVALUE 0299 80 DUP1 029A 15 ISZERO 029B 61 PUSH2 0x02a3 029E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0298 stack[0] = msg.value } // Block ends with conditional jump to 0x02a3, if !msg.value label_029F: // Incoming jump from 0x029E, if not !msg.value // Inputs[1] { @02A2 memory[0x00:0x00] } 029F 60 PUSH1 0x00 02A1 80 DUP1 02A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A2 revert(memory[0x00:0x00]); } // Block terminates label_02A3: // Incoming jump from 0x029E, if !msg.value // Inputs[1] { @02AB msg.data.length } 02A3 5B JUMPDEST 02A4 50 POP 02A5 61 PUSH2 0x02b7 02A8 61 PUSH2 0x02b2 02AB 36 CALLDATASIZE 02AC 60 PUSH1 0x04 02AE 61 PUSH2 0x256e 02B1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02A5 stack[-1] = 0x02b7 // @02A8 stack[0] = 0x02b2 // @02AB stack[1] = msg.data.length // @02AC stack[2] = 0x04 // } // Block ends with call to 0x256e, returns to 0x02B2 label_02B2: // Incoming return from call to 0x256E at 0x02B1 02B2 5B JUMPDEST 02B3 61 PUSH2 0x07c1 02B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07c1 label_02B7: // Incoming return from call to 0x04BC at 0x04BB // Incoming jump from 0x0574 // Incoming return from call to 0x02B2 at 0x02B1 // Inputs[2] // { // @02BA memory[0x40:0x60] // @02C4 stack[-1] // } 02B7 5B JUMPDEST 02B8 60 PUSH1 0x40 02BA 51 MLOAD 02BB 60 PUSH1 0x01 02BD 60 PUSH1 0x01 02BF 60 PUSH1 0xa0 02C1 1B SHL 02C2 03 SUB 02C3 90 SWAP1 02C4 91 SWAP2 02C5 16 AND 02C6 81 DUP2 02C7 52 MSTORE 02C8 60 PUSH1 0x20 02CA 01 ADD 02CB 61 PUSH2 0x026c 02CE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02CA stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x026c label_02CF: // Incoming jump from 0x022F, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02D0 msg.value } 02CF 5B JUMPDEST 02D0 34 CALLVALUE 02D1 80 DUP1 02D2 15 ISZERO 02D3 61 PUSH2 0x02db 02D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02D0 stack[0] = msg.value } // Block ends with conditional jump to 0x02db, if !msg.value label_02D7: // Incoming jump from 0x02D6, if not !msg.value // Inputs[1] { @02DA memory[0x00:0x00] } 02D7 60 PUSH1 0x00 02D9 80 DUP1 02DA FD *REVERT // Stack delta = +0 // Outputs[1] { @02DA revert(memory[0x00:0x00]); } // Block terminates label_02DB: // Incoming jump from 0x02D6, if !msg.value // Inputs[1] { @02E3 msg.data.length } 02DB 5B JUMPDEST 02DC 50 POP 02DD 61 PUSH2 0x02ef 02E0 61 PUSH2 0x02ea 02E3 36 CALLDATASIZE 02E4 60 PUSH1 0x04 02E6 61 PUSH2 0x259e 02E9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02DD stack[-1] = 0x02ef // @02E0 stack[0] = 0x02ea // @02E3 stack[1] = msg.data.length // @02E4 stack[2] = 0x04 // } // Block ends with call to 0x259e, returns to 0x02EA label_02EA: // Incoming return from call to 0x259E at 0x02E9 02EA 5B JUMPDEST 02EB 61 PUSH2 0x085b 02EE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x085b label_02EF: // Incoming return from call to 0x0B04 at 0x03E7 // Incoming return from call to 0x060E at 0x060D // Incoming return from call to 0x0719 at 0x0718 // Incoming return from call to 0x03BB at 0x03BA // Incoming return from call to 0x067A at 0x0679 // Incoming return from call to 0x0E94 at 0x0551 // Incoming return from call to 0x05EE at 0x05ED // Incoming return from call to 0x0503 at 0x0502 // Incoming return from call to 0x030C at 0x030B 02EF 5B JUMPDEST 02F0 00 *STOP // Stack delta = +0 // Outputs[1] { @02F0 stop(); } // Block terminates label_02F1: // Incoming jump from 0x023A, if 0x10ceb677 == stack[-1] // Inputs[1] { @02F2 msg.value } 02F1 5B JUMPDEST 02F2 34 CALLVALUE 02F3 80 DUP1 02F4 15 ISZERO 02F5 61 PUSH2 0x02fd 02F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F2 stack[0] = msg.value } // Block ends with conditional jump to 0x02fd, if !msg.value label_02F9: // Incoming jump from 0x02F8, if not !msg.value // Inputs[1] { @02FC memory[0x00:0x00] } 02F9 60 PUSH1 0x00 02FB 80 DUP1 02FC FD *REVERT // Stack delta = +0 // Outputs[1] { @02FC revert(memory[0x00:0x00]); } // Block terminates label_02FD: // Incoming jump from 0x02F8, if !msg.value // Inputs[1] { @0305 msg.data.length } 02FD 5B JUMPDEST 02FE 50 POP 02FF 61 PUSH2 0x02ef 0302 61 PUSH2 0x030c 0305 36 CALLDATASIZE 0306 60 PUSH1 0x04 0308 61 PUSH2 0x256e 030B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02FF stack[-1] = 0x02ef // @0302 stack[0] = 0x030c // @0305 stack[1] = msg.data.length // @0306 stack[2] = 0x04 // } // Block ends with call to 0x256e, returns to 0x030C label_030C: // Incoming return from call to 0x256E at 0x030B 030C 5B JUMPDEST 030D 61 PUSH2 0x0971 0310 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0971 label_0311: // Incoming jump from 0x01D2, if 0x13faede6 == stack[-1] // Inputs[1] { @0312 msg.value } 0311 5B JUMPDEST 0312 34 CALLVALUE 0313 80 DUP1 0314 15 ISZERO 0315 61 PUSH2 0x031d 0318 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0312 stack[0] = msg.value } // Block ends with conditional jump to 0x031d, if !msg.value label_0319: // Incoming jump from 0x0318, if not !msg.value // Inputs[1] { @031C memory[0x00:0x00] } 0319 60 PUSH1 0x00 031B 80 DUP1 031C FD *REVERT // Stack delta = +0 // Outputs[1] { @031C revert(memory[0x00:0x00]); } // Block terminates label_031D: // Incoming jump from 0x0318, if !msg.value // Inputs[1] { @0324 storage[0x0d] } 031D 5B JUMPDEST 031E 50 POP 031F 61 PUSH2 0x0327 0322 60 PUSH1 0x0d 0324 54 SLOAD 0325 81 DUP2 0326 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @031F stack[-1] = 0x0327 // @0324 stack[0] = storage[0x0d] // } // Block ends with unconditional jump to 0x0327 label_0327: // Incoming jump from 0x0648 // Incoming jump from 0x037F // Incoming jump from 0x0369 // Incoming jump from 0x0326 // Incoming return from call to 0x0443 at 0x0442 // Incoming return from call to 0x0DD5 at 0x051C // Incoming return from call to 0x0538 at 0x0537 // Incoming return from call to 0x03DB at 0x03DA // Incoming jump from 0x065E // Incoming jump from 0x06DD // Incoming jump from 0x05BF // Inputs[2] // { // @032A memory[0x40:0x60] // @032B stack[-1] // } 0327 5B JUMPDEST 0328 60 PUSH1 0x40 032A 51 MLOAD 032B 90 SWAP1 032C 81 DUP2 032D 52 MSTORE 032E 60 PUSH1 0x20 0330 01 ADD 0331 61 PUSH2 0x026c 0334 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @032D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0330 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x026c label_0335: // Incoming jump from 0x01DD, if 0x16c38b3c == stack[-1] // Inputs[1] { @0336 msg.value } 0335 5B JUMPDEST 0336 34 CALLVALUE 0337 80 DUP1 0338 15 ISZERO 0339 61 PUSH2 0x0341 033C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0336 stack[0] = msg.value } // Block ends with conditional jump to 0x0341, if !msg.value label_033D: // Incoming jump from 0x033C, if not !msg.value // Inputs[1] { @0340 memory[0x00:0x00] } 033D 60 PUSH1 0x00 033F 80 DUP1 0340 FD *REVERT // Stack delta = +0 // Outputs[1] { @0340 revert(memory[0x00:0x00]); } // Block terminates label_0341: // Incoming jump from 0x033C, if !msg.value // Inputs[1] { @0349 msg.data.length } 0341 5B JUMPDEST 0342 50 POP 0343 61 PUSH2 0x02ef 0346 61 PUSH2 0x0350 0349 36 CALLDATASIZE 034A 60 PUSH1 0x04 034C 61 PUSH2 0x25d8 034F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0343 stack[-1] = 0x02ef // @0346 stack[0] = 0x0350 // @0349 stack[1] = msg.data.length // @034A stack[2] = 0x04 // } // Block ends with call to 0x25d8, returns to 0x0350 label_0350: // Incoming return from call to 0x25D8 at 0x034F 0350 5B JUMPDEST 0351 61 PUSH2 0x09a6 0354 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09a6 label_0355: // Incoming jump from 0x01E8, if 0x18160ddd == stack[-1] // Inputs[1] { @0356 msg.value } 0355 5B JUMPDEST 0356 34 CALLVALUE 0357 80 DUP1 0358 15 ISZERO 0359 61 PUSH2 0x0361 035C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0356 stack[0] = msg.value } // Block ends with conditional jump to 0x0361, if !msg.value label_035D: // Incoming jump from 0x035C, if not !msg.value // Inputs[1] { @0360 memory[0x00:0x00] } 035D 60 PUSH1 0x00 035F 80 DUP1 0360 FD *REVERT // Stack delta = +0 // Outputs[1] { @0360 revert(memory[0x00:0x00]); } // Block terminates label_0361: // Incoming jump from 0x035C, if !msg.value // Inputs[1] { @0365 storage[0x08] } 0361 5B JUMPDEST 0362 50 POP 0363 60 PUSH1 0x08 0365 54 SLOAD 0366 61 PUSH2 0x0327 0369 56 *JUMP // Stack delta = +0 // Outputs[1] { @0365 stack[-1] = storage[0x08] } // Block ends with unconditional jump to 0x0327 label_036A: // Incoming jump from 0x01F3, if 0x239c70ae == stack[-1] // Inputs[1] { @036B msg.value } 036A 5B JUMPDEST 036B 34 CALLVALUE 036C 80 DUP1 036D 15 ISZERO 036E 61 PUSH2 0x0376 0371 57 *JUMPI // Stack delta = +1 // Outputs[1] { @036B stack[0] = msg.value } // Block ends with conditional jump to 0x0376, if !msg.value label_0372: // Incoming jump from 0x0371, if not !msg.value // Inputs[1] { @0375 memory[0x00:0x00] } 0372 60 PUSH1 0x00 0374 80 DUP1 0375 FD *REVERT // Stack delta = +0 // Outputs[1] { @0375 revert(memory[0x00:0x00]); } // Block terminates label_0376: // Incoming jump from 0x0371, if !msg.value // Inputs[1] { @037D storage[0x10] } 0376 5B JUMPDEST 0377 50 POP 0378 61 PUSH2 0x0327 037B 60 PUSH1 0x10 037D 54 SLOAD 037E 81 DUP2 037F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0378 stack[-1] = 0x0327 // @037D stack[0] = storage[0x10] // } // Block ends with unconditional jump to 0x0327 label_0380: // Incoming jump from 0x01FE, if 0x23b872dd == stack[-1] // Inputs[1] { @0381 msg.value } 0380 5B JUMPDEST 0381 34 CALLVALUE 0382 80 DUP1 0383 15 ISZERO 0384 61 PUSH2 0x038c 0387 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0381 stack[0] = msg.value } // Block ends with conditional jump to 0x038c, if !msg.value label_0388: // Incoming jump from 0x0387, if not !msg.value // Inputs[1] { @038B memory[0x00:0x00] } 0388 60 PUSH1 0x00 038A 80 DUP1 038B FD *REVERT // Stack delta = +0 // Outputs[1] { @038B revert(memory[0x00:0x00]); } // Block terminates label_038C: // Incoming jump from 0x0387, if !msg.value // Inputs[1] { @0394 msg.data.length } 038C 5B JUMPDEST 038D 50 POP 038E 61 PUSH2 0x02ef 0391 61 PUSH2 0x039b 0394 36 CALLDATASIZE 0395 60 PUSH1 0x04 0397 61 PUSH2 0x25f3 039A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @038E stack[-1] = 0x02ef // @0391 stack[0] = 0x039b // @0394 stack[1] = msg.data.length // @0395 stack[2] = 0x04 // } // Block ends with call to 0x25f3, returns to 0x039B label_039B: // Incoming return from call to 0x25F3 at 0x039A 039B 5B JUMPDEST 039C 61 PUSH2 0x09ee 039F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09ee label_03A0: // Incoming jump from 0x018B, if 0x2a3f300c == stack[-1] // Inputs[1] { @03A1 msg.value } 03A0 5B JUMPDEST 03A1 34 CALLVALUE 03A2 80 DUP1 03A3 15 ISZERO 03A4 61 PUSH2 0x03ac 03A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A1 stack[0] = msg.value } // Block ends with conditional jump to 0x03ac, if !msg.value label_03A8: // Incoming jump from 0x03A7, if not !msg.value // Inputs[1] { @03AB memory[0x00:0x00] } 03A8 60 PUSH1 0x00 03AA 80 DUP1 03AB FD *REVERT // Stack delta = +0 // Outputs[1] { @03AB revert(memory[0x00:0x00]); } // Block terminates label_03AC: // Incoming jump from 0x03A7, if !msg.value // Inputs[1] { @03B4 msg.data.length } 03AC 5B JUMPDEST 03AD 50 POP 03AE 61 PUSH2 0x02ef 03B1 61 PUSH2 0x03bb 03B4 36 CALLDATASIZE 03B5 60 PUSH1 0x04 03B7 61 PUSH2 0x25d8 03BA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03AE stack[-1] = 0x02ef // @03B1 stack[0] = 0x03bb // @03B4 stack[1] = msg.data.length // @03B5 stack[2] = 0x04 // } // Block ends with call to 0x25d8, returns to 0x03BB label_03BB: // Incoming return from call to 0x25D8 at 0x03BA 03BB 5B JUMPDEST 03BC 61 PUSH2 0x0a20 03BF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a20 label_03C0: // Incoming jump from 0x0196, if 0x2f745c59 == stack[-1] // Inputs[1] { @03C1 msg.value } 03C0 5B JUMPDEST 03C1 34 CALLVALUE 03C2 80 DUP1 03C3 15 ISZERO 03C4 61 PUSH2 0x03cc 03C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C1 stack[0] = msg.value } // Block ends with conditional jump to 0x03cc, if !msg.value label_03C8: // Incoming jump from 0x03C7, if not !msg.value // Inputs[1] { @03CB memory[0x00:0x00] } 03C8 60 PUSH1 0x00 03CA 80 DUP1 03CB FD *REVERT // Stack delta = +0 // Outputs[1] { @03CB revert(memory[0x00:0x00]); } // Block terminates label_03CC: // Incoming jump from 0x03C7, if !msg.value // Inputs[1] { @03D4 msg.data.length } 03CC 5B JUMPDEST 03CD 50 POP 03CE 61 PUSH2 0x0327 03D1 61 PUSH2 0x03db 03D4 36 CALLDATASIZE 03D5 60 PUSH1 0x04 03D7 61 PUSH2 0x259e 03DA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03CE stack[-1] = 0x0327 // @03D1 stack[0] = 0x03db // @03D4 stack[1] = msg.data.length // @03D5 stack[2] = 0x04 // } // Block ends with call to 0x259e, returns to 0x03DB label_03DB: // Incoming return from call to 0x259E at 0x03DA 03DB 5B JUMPDEST 03DC 61 PUSH2 0x0a6e 03DF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a6e label_03E0: // Incoming jump from 0x01A1, if 0x3ccfd60b == stack[-1] 03E0 5B JUMPDEST 03E1 61 PUSH2 0x02ef 03E4 61 PUSH2 0x0b04 03E7 56 *JUMP // Stack delta = +1 // Outputs[1] { @03E1 stack[0] = 0x02ef } // Block ends with call to 0x0b04, returns to 0x02EF label_03E8: // Incoming jump from 0x01AC, if 0x42842e0e == stack[-1] // Inputs[1] { @03E9 msg.value } 03E8 5B JUMPDEST 03E9 34 CALLVALUE 03EA 80 DUP1 03EB 15 ISZERO 03EC 61 PUSH2 0x03f4 03EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E9 stack[0] = msg.value } // Block ends with conditional jump to 0x03f4, if !msg.value label_03F0: // Incoming jump from 0x03EF, if not !msg.value // Inputs[1] { @03F3 memory[0x00:0x00] } 03F0 60 PUSH1 0x00 03F2 80 DUP1 03F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F3 revert(memory[0x00:0x00]); } // Block terminates label_03F4: // Incoming jump from 0x03EF, if !msg.value // Inputs[1] { @03FC msg.data.length } 03F4 5B JUMPDEST 03F5 50 POP 03F6 61 PUSH2 0x02ef 03F9 61 PUSH2 0x0403 03FC 36 CALLDATASIZE 03FD 60 PUSH1 0x04 03FF 61 PUSH2 0x25f3 0402 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F6 stack[-1] = 0x02ef // @03F9 stack[0] = 0x0403 // @03FC stack[1] = msg.data.length // @03FD stack[2] = 0x04 // } // Block ends with call to 0x25f3, returns to 0x0403 label_0403: // Incoming return from call to 0x25F3 at 0x0402 0403 5B JUMPDEST 0404 61 PUSH2 0x0bbd 0407 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bbd label_0408: // Incoming jump from 0x01B7, if 0x42966c68 == stack[-1] // Inputs[1] { @0409 msg.value } 0408 5B JUMPDEST 0409 34 CALLVALUE 040A 80 DUP1 040B 15 ISZERO 040C 61 PUSH2 0x0414 040F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0409 stack[0] = msg.value } // Block ends with conditional jump to 0x0414, if !msg.value label_0410: // Incoming jump from 0x040F, if not !msg.value // Inputs[1] { @0413 memory[0x00:0x00] } 0410 60 PUSH1 0x00 0412 80 DUP1 0413 FD *REVERT // Stack delta = +0 // Outputs[1] { @0413 revert(memory[0x00:0x00]); } // Block terminates label_0414: // Incoming jump from 0x040F, if !msg.value // Inputs[1] { @041C msg.data.length } 0414 5B JUMPDEST 0415 50 POP 0416 61 PUSH2 0x02ef 0419 61 PUSH2 0x0423 041C 36 CALLDATASIZE 041D 60 PUSH1 0x04 041F 61 PUSH2 0x256e 0422 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0416 stack[-1] = 0x02ef // @0419 stack[0] = 0x0423 // @041C stack[1] = msg.data.length // @041D stack[2] = 0x04 // } // Block ends with call to 0x256e, returns to 0x0423 label_0423: // Incoming return from call to 0x256E at 0x0422 0423 5B JUMPDEST 0424 61 PUSH2 0x0bd8 0427 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bd8 label_0428: // Incoming jump from 0x014F, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @0429 msg.value } 0428 5B JUMPDEST 0429 34 CALLVALUE 042A 80 DUP1 042B 15 ISZERO 042C 61 PUSH2 0x0434 042F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0429 stack[0] = msg.value } // Block ends with conditional jump to 0x0434, if !msg.value label_0430: // Incoming jump from 0x042F, if not !msg.value // Inputs[1] { @0433 memory[0x00:0x00] } 0430 60 PUSH1 0x00 0432 80 DUP1 0433 FD *REVERT // Stack delta = +0 // Outputs[1] { @0433 revert(memory[0x00:0x00]); } // Block terminates label_0434: // Incoming jump from 0x042F, if !msg.value // Inputs[1] { @043C msg.data.length } 0434 5B JUMPDEST 0435 50 POP 0436 61 PUSH2 0x0327 0439 61 PUSH2 0x0443 043C 36 CALLDATASIZE 043D 60 PUSH1 0x04 043F 61 PUSH2 0x256e 0442 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0436 stack[-1] = 0x0327 // @0439 stack[0] = 0x0443 // @043C stack[1] = msg.data.length // @043D stack[2] = 0x04 // } // Block ends with call to 0x256e, returns to 0x0443 label_0443: // Incoming return from call to 0x256E at 0x0442 0443 5B JUMPDEST 0444 61 PUSH2 0x0c4f 0447 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c4f label_0448: // Incoming jump from 0x015A, if 0x51830227 == stack[-1] // Inputs[1] { @0449 msg.value } 0448 5B JUMPDEST 0449 34 CALLVALUE 044A 80 DUP1 044B 15 ISZERO 044C 61 PUSH2 0x0454 044F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0449 stack[0] = msg.value } // Block ends with conditional jump to 0x0454, if !msg.value label_0450: // Incoming jump from 0x044F, if not !msg.value // Inputs[1] { @0453 memory[0x00:0x00] } 0450 60 PUSH1 0x00 0452 80 DUP1 0453 FD *REVERT // Stack delta = +0 // Outputs[1] { @0453 revert(memory[0x00:0x00]); } // Block terminates label_0454: // Incoming jump from 0x044F, if !msg.value // Inputs[1] { @0458 storage[0x0a] } 0454 5B JUMPDEST 0455 50 POP 0456 60 PUSH1 0x0a 0458 54 SLOAD 0459 61 PUSH2 0x0260 045C 90 SWAP1 045D 60 PUSH1 0x01 045F 60 PUSH1 0xa8 0461 1B SHL 0462 90 SWAP1 0463 04 DIV 0464 60 PUSH1 0xff 0466 16 AND 0467 81 DUP2 0468 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @045C stack[-1] = 0x0260 // @0466 stack[0] = 0xff & storage[0x0a] / (0x01 << 0xa8) // } // Block ends with unconditional jump to 0x0260 label_0469: // Incoming jump from 0x0165, if 0x55f804b3 == stack[-1] // Inputs[1] { @046A msg.value } 0469 5B JUMPDEST 046A 34 CALLVALUE 046B 80 DUP1 046C 15 ISZERO 046D 61 PUSH2 0x0475 0470 57 *JUMPI // Stack delta = +1 // Outputs[1] { @046A stack[0] = msg.value } // Block ends with conditional jump to 0x0475, if !msg.value label_0471: // Incoming jump from 0x0470, if not !msg.value // Inputs[1] { @0474 memory[0x00:0x00] } 0471 60 PUSH1 0x00 0473 80 DUP1 0474 FD *REVERT // Stack delta = +0 // Outputs[1] { @0474 revert(memory[0x00:0x00]); } // Block terminates label_0475: // Incoming jump from 0x0470, if !msg.value // Inputs[1] { @047D msg.data.length } 0475 5B JUMPDEST 0476 50 POP 0477 61 PUSH2 0x02ef 047A 61 PUSH2 0x0484 047D 36 CALLDATASIZE 047E 60 PUSH1 0x04 0480 61 PUSH2 0x26bb 0483 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0477 stack[-1] = 0x02ef // @047A stack[0] = 0x0484 // @047D stack[1] = msg.data.length // @047E stack[2] = 0x04 // } // Block ends with call to 0x26bb, returns to 0x0484 label_0484: // Incoming return from call to 0x26BB at 0x0483 0484 5B JUMPDEST 0485 61 PUSH2 0x0ce2 0488 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ce2 label_0489: // Incoming jump from 0x0170, if 0x5c975abb == stack[-1] // Inputs[1] { @048A msg.value } 0489 5B JUMPDEST 048A 34 CALLVALUE 048B 80 DUP1 048C 15 ISZERO 048D 61 PUSH2 0x0495 0490 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048A stack[0] = msg.value } // Block ends with conditional jump to 0x0495, if !msg.value label_0491: // Incoming jump from 0x0490, if not !msg.value // Inputs[1] { @0494 memory[0x00:0x00] } 0491 60 PUSH1 0x00 0493 80 DUP1 0494 FD *REVERT // Stack delta = +0 // Outputs[1] { @0494 revert(memory[0x00:0x00]); } // Block terminates label_0495: // Incoming jump from 0x0490, if !msg.value // Inputs[1] { @0499 storage[0x0a] } 0495 5B JUMPDEST 0496 50 POP 0497 60 PUSH1 0x0a 0499 54 SLOAD 049A 60 PUSH1 0xff 049C 16 AND 049D 61 PUSH2 0x0260 04A0 56 *JUMP // Stack delta = +0 // Outputs[1] { @049C stack[-1] = 0xff & storage[0x0a] } // Block ends with unconditional jump to 0x0260 label_04A1: // Incoming jump from 0x017B, if 0x6352211e == stack[-1] // Inputs[1] { @04A2 msg.value } 04A1 5B JUMPDEST 04A2 34 CALLVALUE 04A3 80 DUP1 04A4 15 ISZERO 04A5 61 PUSH2 0x04ad 04A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A2 stack[0] = msg.value } // Block ends with conditional jump to 0x04ad, if !msg.value label_04A9: // Incoming jump from 0x04A8, if not !msg.value // Inputs[1] { @04AC memory[0x00:0x00] } 04A9 60 PUSH1 0x00 04AB 80 DUP1 04AC FD *REVERT // Stack delta = +0 // Outputs[1] { @04AC revert(memory[0x00:0x00]); } // Block terminates label_04AD: // Incoming jump from 0x04A8, if !msg.value // Inputs[1] { @04B5 msg.data.length } 04AD 5B JUMPDEST 04AE 50 POP 04AF 61 PUSH2 0x02b7 04B2 61 PUSH2 0x04bc 04B5 36 CALLDATASIZE 04B6 60 PUSH1 0x04 04B8 61 PUSH2 0x256e 04BB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04AF stack[-1] = 0x02b7 // @04B2 stack[0] = 0x04bc // @04B5 stack[1] = msg.data.length // @04B6 stack[2] = 0x04 // } // Block ends with call to 0x256e, returns to 0x04BC label_04BC: // Incoming return from call to 0x256E at 0x04BB 04BC 5B JUMPDEST 04BD 61 PUSH2 0x0d29 04C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d29 label_04C1: // Incoming jump from 0x00FD, if 0x6ad1fe02 == stack[-1] // Inputs[1] { @04C2 msg.value } 04C1 5B JUMPDEST 04C2 34 CALLVALUE 04C3 80 DUP1 04C4 15 ISZERO 04C5 61 PUSH2 0x04cd 04C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C2 stack[0] = msg.value } // Block ends with conditional jump to 0x04cd, if !msg.value label_04C9: // Incoming jump from 0x04C8, if not !msg.value // Inputs[1] { @04CC memory[0x00:0x00] } 04C9 60 PUSH1 0x00 04CB 80 DUP1 04CC FD *REVERT // Stack delta = +0 // Outputs[1] { @04CC revert(memory[0x00:0x00]); } // Block terminates label_04CD: // Incoming jump from 0x04C8, if !msg.value // Inputs[1] { @04D1 storage[0x11] } 04CD 5B JUMPDEST 04CE 50 POP 04CF 60 PUSH1 0x11 04D1 54 SLOAD 04D2 61 PUSH2 0x04db 04D5 90 SWAP1 04D6 60 PUSH1 0xff 04D8 16 AND 04D9 81 DUP2 04DA 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04D5 stack[-1] = 0x04db // @04D8 stack[0] = 0xff & storage[0x11] // } // Block ends with unconditional jump to 0x04db label_04DB: // Incoming jump from 0x04DA // Inputs[2] // { // @04DE memory[0x40:0x60] // @04E2 stack[-1] // } 04DB 5B JUMPDEST 04DC 60 PUSH1 0x40 04DE 51 MLOAD 04DF 61 PUSH2 0x026c 04E2 91 SWAP2 04E3 90 SWAP1 04E4 61 PUSH2 0x271a 04E7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04E2 stack[-1] = 0x026c // @04E3 stack[1] = memory[0x40:0x60] // @04E3 stack[0] = stack[-1] // } // Block ends with call to 0x271a, returns to 0x026C label_04E8: // Incoming jump from 0x0108, if 0x6f8b44b0 == stack[-1] // Inputs[1] { @04E9 msg.value } 04E8 5B JUMPDEST 04E9 34 CALLVALUE 04EA 80 DUP1 04EB 15 ISZERO 04EC 61 PUSH2 0x04f4 04EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E9 stack[0] = msg.value } // Block ends with conditional jump to 0x04f4, if !msg.value label_04F0: // Incoming jump from 0x04EF, if not !msg.value // Inputs[1] { @04F3 memory[0x00:0x00] } 04F0 60 PUSH1 0x00 04F2 80 DUP1 04F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F3 revert(memory[0x00:0x00]); } // Block terminates label_04F4: // Incoming jump from 0x04EF, if !msg.value // Inputs[1] { @04FC msg.data.length } 04F4 5B JUMPDEST 04F5 50 POP 04F6 61 PUSH2 0x02ef 04F9 61 PUSH2 0x0503 04FC 36 CALLDATASIZE 04FD 60 PUSH1 0x04 04FF 61 PUSH2 0x256e 0502 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F6 stack[-1] = 0x02ef // @04F9 stack[0] = 0x0503 // @04FC stack[1] = msg.data.length // @04FD stack[2] = 0x04 // } // Block ends with call to 0x256e, returns to 0x0503 label_0503: // Incoming return from call to 0x256E at 0x0502 0503 5B JUMPDEST 0504 61 PUSH2 0x0da0 0507 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0da0 label_0508: // Incoming jump from 0x0113, if 0x6f9fb98a == stack[-1] // Inputs[1] { @0509 msg.value } 0508 5B JUMPDEST 0509 34 CALLVALUE 050A 80 DUP1 050B 15 ISZERO 050C 61 PUSH2 0x0514 050F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0509 stack[0] = msg.value } // Block ends with conditional jump to 0x0514, if !msg.value label_0510: // Incoming jump from 0x050F, if not !msg.value // Inputs[1] { @0513 memory[0x00:0x00] } 0510 60 PUSH1 0x00 0512 80 DUP1 0513 FD *REVERT // Stack delta = +0 // Outputs[1] { @0513 revert(memory[0x00:0x00]); } // Block terminates label_0514: // Incoming jump from 0x050F, if !msg.value 0514 5B JUMPDEST 0515 50 POP 0516 61 PUSH2 0x0327 0519 61 PUSH2 0x0dd5 051C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0516 stack[-1] = 0x0327 } // Block ends with call to 0x0dd5, returns to 0x0327 label_051D: // Incoming jump from 0x011E, if 0x70a08231 == stack[-1] // Inputs[1] { @051E msg.value } 051D 5B JUMPDEST 051E 34 CALLVALUE 051F 80 DUP1 0520 15 ISZERO 0521 61 PUSH2 0x0529 0524 57 *JUMPI // Stack delta = +1 // Outputs[1] { @051E stack[0] = msg.value } // Block ends with conditional jump to 0x0529, if !msg.value label_0525: // Incoming jump from 0x0524, if not !msg.value // Inputs[1] { @0528 memory[0x00:0x00] } 0525 60 PUSH1 0x00 0527 80 DUP1 0528 FD *REVERT // Stack delta = +0 // Outputs[1] { @0528 revert(memory[0x00:0x00]); } // Block terminates label_0529: // Incoming jump from 0x0524, if !msg.value // Inputs[1] { @0531 msg.data.length } 0529 5B JUMPDEST 052A 50 POP 052B 61 PUSH2 0x0327 052E 61 PUSH2 0x0538 0531 36 CALLDATASIZE 0532 60 PUSH1 0x04 0534 61 PUSH2 0x2742 0537 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @052B stack[-1] = 0x0327 // @052E stack[0] = 0x0538 // @0531 stack[1] = msg.data.length // @0532 stack[2] = 0x04 // } // Block ends with call to 0x2742, returns to 0x0538 label_0538: // Incoming return from call to 0x2742 at 0x0537 0538 5B JUMPDEST 0539 61 PUSH2 0x0e0d 053C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e0d label_053D: // Incoming jump from 0x0129, if 0x715018a6 == stack[-1] // Inputs[1] { @053E msg.value } 053D 5B JUMPDEST 053E 34 CALLVALUE 053F 80 DUP1 0540 15 ISZERO 0541 61 PUSH2 0x0549 0544 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053E stack[0] = msg.value } // Block ends with conditional jump to 0x0549, if !msg.value label_0545: // Incoming jump from 0x0544, if not !msg.value // Inputs[1] { @0548 memory[0x00:0x00] } 0545 60 PUSH1 0x00 0547 80 DUP1 0548 FD *REVERT // Stack delta = +0 // Outputs[1] { @0548 revert(memory[0x00:0x00]); } // Block terminates label_0549: // Incoming jump from 0x0544, if !msg.value 0549 5B JUMPDEST 054A 50 POP 054B 61 PUSH2 0x02ef 054E 61 PUSH2 0x0e94 0551 56 *JUMP // Stack delta = +0 // Outputs[1] { @054B stack[-1] = 0x02ef } // Block ends with call to 0x0e94, returns to 0x02EF label_0552: // Incoming jump from 0x00C1, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0553 msg.value } 0552 5B JUMPDEST 0553 34 CALLVALUE 0554 80 DUP1 0555 15 ISZERO 0556 61 PUSH2 0x055e 0559 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0553 stack[0] = msg.value } // Block ends with conditional jump to 0x055e, if !msg.value label_055A: // Incoming jump from 0x0559, if not !msg.value // Inputs[1] { @055D memory[0x00:0x00] } 055A 60 PUSH1 0x00 055C 80 DUP1 055D FD *REVERT // Stack delta = +0 // Outputs[1] { @055D revert(memory[0x00:0x00]); } // Block terminates label_055E: // Incoming jump from 0x0559, if !msg.value // Inputs[1] { @0562 storage[0x0a] } 055E 5B JUMPDEST 055F 50 POP 0560 60 PUSH1 0x0a 0562 54 SLOAD 0563 61 PUSH2 0x0100 0566 90 SWAP1 0567 04 DIV 0568 60 PUSH1 0x01 056A 60 PUSH1 0x01 056C 60 PUSH1 0xa0 056E 1B SHL 056F 03 SUB 0570 16 AND 0571 61 PUSH2 0x02b7 0574 56 *JUMP // Stack delta = +0 // Outputs[1] { @0570 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 } // Block ends with unconditional jump to 0x02b7 label_0575: // Incoming jump from 0x00CC, if 0x95d89b41 == stack[-1] // Inputs[1] { @0576 msg.value } 0575 5B JUMPDEST 0576 34 CALLVALUE 0577 80 DUP1 0578 15 ISZERO 0579 61 PUSH2 0x0581 057C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0576 stack[0] = msg.value } // Block ends with conditional jump to 0x0581, if !msg.value label_057D: // Incoming jump from 0x057C, if not !msg.value // Inputs[1] { @0580 memory[0x00:0x00] } 057D 60 PUSH1 0x00 057F 80 DUP1 0580 FD *REVERT // Stack delta = +0 // Outputs[1] { @0580 revert(memory[0x00:0x00]); } // Block terminates label_0581: // Incoming jump from 0x057C, if !msg.value 0581 5B JUMPDEST 0582 50 POP 0583 61 PUSH2 0x028a 0586 61 PUSH2 0x0ed0 0589 56 *JUMP // Stack delta = +0 // Outputs[1] { @0583 stack[-1] = 0x028a } // Block ends with call to 0x0ed0, returns to 0x028A label_058A: // Incoming jump from 0x00D7, if 0xa22cb465 == stack[-1] // Inputs[1] { @058B msg.value } 058A 5B JUMPDEST 058B 34 CALLVALUE 058C 80 DUP1 058D 15 ISZERO 058E 61 PUSH2 0x0596 0591 57 *JUMPI // Stack delta = +1 // Outputs[1] { @058B stack[0] = msg.value } // Block ends with conditional jump to 0x0596, if !msg.value label_0592: // Incoming jump from 0x0591, if not !msg.value // Inputs[1] { @0595 memory[0x00:0x00] } 0592 60 PUSH1 0x00 0594 80 DUP1 0595 FD *REVERT // Stack delta = +0 // Outputs[1] { @0595 revert(memory[0x00:0x00]); } // Block terminates label_0596: // Incoming jump from 0x0591, if !msg.value // Inputs[1] { @059E msg.data.length } 0596 5B JUMPDEST 0597 50 POP 0598 61 PUSH2 0x02ef 059B 61 PUSH2 0x05a5 059E 36 CALLDATASIZE 059F 60 PUSH1 0x04 05A1 61 PUSH2 0x275d 05A4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0598 stack[-1] = 0x02ef // @059B stack[0] = 0x05a5 // @059E stack[1] = msg.data.length // @059F stack[2] = 0x04 // } // Block ends with unconditional jump to 0x275d 05A5 5B JUMPDEST 05A6 61 PUSH2 0x0edf 05A9 56 *JUMP label_05AA: // Incoming jump from 0x00E2, if 0xa759a7c8 == stack[-1] // Inputs[1] { @05AB msg.value } 05AA 5B JUMPDEST 05AB 34 CALLVALUE 05AC 80 DUP1 05AD 15 ISZERO 05AE 61 PUSH2 0x05b6 05B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05AB stack[0] = msg.value } // Block ends with conditional jump to 0x05b6, if !msg.value label_05B2: // Incoming jump from 0x05B1, if not !msg.value // Inputs[1] { @05B5 memory[0x00:0x00] } 05B2 60 PUSH1 0x00 05B4 80 DUP1 05B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B5 revert(memory[0x00:0x00]); } // Block terminates label_05B6: // Incoming jump from 0x05B1, if !msg.value // Inputs[1] { @05BD storage[0x0f] } 05B6 5B JUMPDEST 05B7 50 POP 05B8 61 PUSH2 0x0327 05BB 60 PUSH1 0x0f 05BD 54 SLOAD 05BE 81 DUP2 05BF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05B8 stack[-1] = 0x0327 // @05BD stack[0] = storage[0x0f] // } // Block ends with unconditional jump to 0x0327 label_05C0: // Incoming jump from 0x00ED, if 0xb88d4fde == stack[-1] // Inputs[1] { @05C1 msg.value } 05C0 5B JUMPDEST 05C1 34 CALLVALUE 05C2 80 DUP1 05C3 15 ISZERO 05C4 61 PUSH2 0x05cc 05C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C1 stack[0] = msg.value } // Block ends with conditional jump to 0x05cc, if !msg.value label_05C8: // Incoming jump from 0x05C7, if not !msg.value // Inputs[1] { @05CB memory[0x00:0x00] } 05C8 60 PUSH1 0x00 05CA 80 DUP1 05CB FD *REVERT // Stack delta = +0 // Outputs[1] { @05CB revert(memory[0x00:0x00]); } // Block terminates label_05CC: // Incoming jump from 0x05C7, if !msg.value // Inputs[1] { @05D4 msg.data.length } 05CC 5B JUMPDEST 05CD 50 POP 05CE 61 PUSH2 0x02ef 05D1 61 PUSH2 0x05db 05D4 36 CALLDATASIZE 05D5 60 PUSH1 0x04 05D7 61 PUSH2 0x2790 05DA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05CE stack[-1] = 0x02ef // @05D1 stack[0] = 0x05db // @05D4 stack[1] = msg.data.length // @05D5 stack[2] = 0x04 // } // Block ends with call to 0x2790, returns to 0x05DB label_05DB: // Incoming return from call to 0x2790 at 0x05DA 05DB 5B JUMPDEST 05DC 61 PUSH2 0x0eea 05DF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eea label_05E0: // Incoming jump from 0x007A, if 0xba41b0c6 == stack[-1] // Inputs[1] { @05E7 msg.data.length } 05E0 5B JUMPDEST 05E1 61 PUSH2 0x02ef 05E4 61 PUSH2 0x05ee 05E7 36 CALLDATASIZE 05E8 60 PUSH1 0x04 05EA 61 PUSH2 0x280c 05ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05E1 stack[0] = 0x02ef // @05E4 stack[1] = 0x05ee // @05E7 stack[2] = msg.data.length // @05E8 stack[3] = 0x04 // } // Block ends with call to 0x280c, returns to 0x05EE label_05EE: // Incoming return from call to 0x280C at 0x05ED 05EE 5B JUMPDEST 05EF 61 PUSH2 0x0f22 05F2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f22 label_05F3: // Incoming jump from 0x0085, if 0xbc63f02e == stack[-1] // Inputs[1] { @05F4 msg.value } 05F3 5B JUMPDEST 05F4 34 CALLVALUE 05F5 80 DUP1 05F6 15 ISZERO 05F7 61 PUSH2 0x05ff 05FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F4 stack[0] = msg.value } // Block ends with conditional jump to 0x05ff, if !msg.value label_05FB: // Incoming jump from 0x05FA, if not !msg.value // Inputs[1] { @05FE memory[0x00:0x00] } 05FB 60 PUSH1 0x00 05FD 80 DUP1 05FE FD *REVERT // Stack delta = +0 // Outputs[1] { @05FE revert(memory[0x00:0x00]); } // Block terminates label_05FF: // Incoming jump from 0x05FA, if !msg.value // Inputs[1] { @0607 msg.data.length } 05FF 5B JUMPDEST 0600 50 POP 0601 61 PUSH2 0x02ef 0604 61 PUSH2 0x060e 0607 36 CALLDATASIZE 0608 60 PUSH1 0x04 060A 61 PUSH2 0x288b 060D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0601 stack[-1] = 0x02ef // @0604 stack[0] = 0x060e // @0607 stack[1] = msg.data.length // @0608 stack[2] = 0x04 // } // Block ends with call to 0x288b, returns to 0x060E label_060E: // Incoming return from call to 0x288B at 0x060D 060E 5B JUMPDEST 060F 61 PUSH2 0x12b6 0612 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12b6 label_0613: // Incoming jump from 0x0090, if 0xc87b56dd == stack[-1] // Inputs[1] { @0614 msg.value } 0613 5B JUMPDEST 0614 34 CALLVALUE 0615 80 DUP1 0616 15 ISZERO 0617 61 PUSH2 0x061f 061A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0614 stack[0] = msg.value } // Block ends with conditional jump to 0x061f, if !msg.value label_061B: // Incoming jump from 0x061A, if not !msg.value // Inputs[1] { @061E memory[0x00:0x00] } 061B 60 PUSH1 0x00 061D 80 DUP1 061E FD *REVERT // Stack delta = +0 // Outputs[1] { @061E revert(memory[0x00:0x00]); } // Block terminates label_061F: // Incoming jump from 0x061A, if !msg.value // Inputs[1] { @0627 msg.data.length } 061F 5B JUMPDEST 0620 50 POP 0621 61 PUSH2 0x028a 0624 61 PUSH2 0x062e 0627 36 CALLDATASIZE 0628 60 PUSH1 0x04 062A 61 PUSH2 0x256e 062D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0621 stack[-1] = 0x028a // @0624 stack[0] = 0x062e // @0627 stack[1] = msg.data.length // @0628 stack[2] = 0x04 // } // Block ends with call to 0x256e, returns to 0x062E label_062E: // Incoming return from call to 0x256E at 0x062D 062E 5B JUMPDEST 062F 61 PUSH2 0x13b3 0632 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13b3 label_0633: // Incoming jump from 0x009B, if 0xcc9ff9c6 == stack[-1] // Inputs[1] { @0634 msg.value } 0633 5B JUMPDEST 0634 34 CALLVALUE 0635 80 DUP1 0636 15 ISZERO 0637 61 PUSH2 0x063f 063A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0634 stack[0] = msg.value } // Block ends with conditional jump to 0x063f, if !msg.value label_063B: // Incoming jump from 0x063A, if not !msg.value // Inputs[1] { @063E memory[0x00:0x00] } 063B 60 PUSH1 0x00 063D 80 DUP1 063E FD *REVERT // Stack delta = +0 // Outputs[1] { @063E revert(memory[0x00:0x00]); } // Block terminates label_063F: // Incoming jump from 0x063A, if !msg.value // Inputs[1] { @0646 storage[0x0c] } 063F 5B JUMPDEST 0640 50 POP 0641 61 PUSH2 0x0327 0644 60 PUSH1 0x0c 0646 54 SLOAD 0647 81 DUP2 0648 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0641 stack[-1] = 0x0327 // @0646 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x0327 label_0649: // Incoming jump from 0x00A6, if 0xd5abeb01 == stack[-1] // Inputs[1] { @064A msg.value } 0649 5B JUMPDEST 064A 34 CALLVALUE 064B 80 DUP1 064C 15 ISZERO 064D 61 PUSH2 0x0655 0650 57 *JUMPI // Stack delta = +1 // Outputs[1] { @064A stack[0] = msg.value } // Block ends with conditional jump to 0x0655, if !msg.value label_0651: // Incoming jump from 0x0650, if not !msg.value // Inputs[1] { @0654 memory[0x00:0x00] } 0651 60 PUSH1 0x00 0653 80 DUP1 0654 FD *REVERT // Stack delta = +0 // Outputs[1] { @0654 revert(memory[0x00:0x00]); } // Block terminates label_0655: // Incoming jump from 0x0650, if !msg.value // Inputs[1] { @065C storage[0x0e] } 0655 5B JUMPDEST 0656 50 POP 0657 61 PUSH2 0x0327 065A 60 PUSH1 0x0e 065C 54 SLOAD 065D 81 DUP2 065E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0657 stack[-1] = 0x0327 // @065C stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x0327 label_065F: // Incoming jump from 0x003E, if 0xdab5f340 == stack[-1] // Inputs[1] { @0660 msg.value } 065F 5B JUMPDEST 0660 34 CALLVALUE 0661 80 DUP1 0662 15 ISZERO 0663 61 PUSH2 0x066b 0666 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0660 stack[0] = msg.value } // Block ends with conditional jump to 0x066b, if !msg.value label_0667: // Incoming jump from 0x0666, if not !msg.value // Inputs[1] { @066A memory[0x00:0x00] } 0667 60 PUSH1 0x00 0669 80 DUP1 066A FD *REVERT // Stack delta = +0 // Outputs[1] { @066A revert(memory[0x00:0x00]); } // Block terminates label_066B: // Incoming jump from 0x0666, if !msg.value // Inputs[1] { @0673 msg.data.length } 066B 5B JUMPDEST 066C 50 POP 066D 61 PUSH2 0x02ef 0670 61 PUSH2 0x067a 0673 36 CALLDATASIZE 0674 60 PUSH1 0x04 0676 61 PUSH2 0x256e 0679 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @066D stack[-1] = 0x02ef // @0670 stack[0] = 0x067a // @0673 stack[1] = msg.data.length // @0674 stack[2] = 0x04 // } // Block ends with call to 0x256e, returns to 0x067A label_067A: // Incoming return from call to 0x256E at 0x0679 067A 5B JUMPDEST 067B 61 PUSH2 0x1470 067E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1470 label_067F: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0680 msg.value } 067F 5B JUMPDEST 0680 34 CALLVALUE 0681 80 DUP1 0682 15 ISZERO 0683 61 PUSH2 0x068b 0686 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0680 stack[0] = msg.value } // Block ends with conditional jump to 0x068b, if !msg.value label_0687: // Incoming jump from 0x0686, if not !msg.value // Inputs[1] { @068A memory[0x00:0x00] } 0687 60 PUSH1 0x00 0689 80 DUP1 068A FD *REVERT // Stack delta = +0 // Outputs[1] { @068A revert(memory[0x00:0x00]); } // Block terminates label_068B: // Incoming jump from 0x0686, if !msg.value // Inputs[1] { @0693 msg.data.length } 068B 5B JUMPDEST 068C 50 POP 068D 61 PUSH2 0x0260 0690 61 PUSH2 0x069a 0693 36 CALLDATASIZE 0694 60 PUSH1 0x04 0696 61 PUSH2 0x28ae 0699 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @068D stack[-1] = 0x0260 // @0690 stack[0] = 0x069a // @0693 stack[1] = msg.data.length // @0694 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x28ae label_069A: // Incoming call from 0x08EF, returns to 0x08F0 // Inputs[6] // { // @06A3 stack[-2] // @06B6 memory[0x00:0x40] // @06B7 stack[-1] // @06C1 memory[0x00:0x40] // @06C2 storage[keccak256(memory[0x00:0x40])] // @06C6 stack[-3] // } 069A 5B JUMPDEST 069B 60 PUSH1 0x01 069D 60 PUSH1 0x01 069F 60 PUSH1 0xa0 06A1 1B SHL 06A2 03 SUB 06A3 91 SWAP2 06A4 82 DUP3 06A5 16 AND 06A6 60 PUSH1 0x00 06A8 90 SWAP1 06A9 81 DUP2 06AA 52 MSTORE 06AB 60 PUSH1 0x05 06AD 60 PUSH1 0x20 06AF 90 SWAP1 06B0 81 DUP2 06B1 52 MSTORE 06B2 60 PUSH1 0x40 06B4 80 DUP1 06B5 83 DUP4 06B6 20 SHA3 06B7 93 SWAP4 06B8 90 SWAP1 06B9 94 SWAP5 06BA 16 AND 06BB 82 DUP3 06BC 52 MSTORE 06BD 91 SWAP2 06BE 90 SWAP1 06BF 91 SWAP2 06C0 52 MSTORE 06C1 20 SHA3 06C2 54 SLOAD 06C3 60 PUSH1 0xff 06C5 16 AND 06C6 90 SWAP1 06C7 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @06AA memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @06B1 memory[0x20:0x40] = 0x05 // @06BC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @06C0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06C6 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_06C8: // Incoming jump from 0x0054, if 0xebf0c717 == stack[-1] // Inputs[1] { @06C9 msg.value } 06C8 5B JUMPDEST 06C9 34 CALLVALUE 06CA 80 DUP1 06CB 15 ISZERO 06CC 61 PUSH2 0x06d4 06CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06C9 stack[0] = msg.value } // Block ends with conditional jump to 0x06d4, if !msg.value label_06D0: // Incoming jump from 0x06CF, if not !msg.value // Inputs[1] { @06D3 memory[0x00:0x00] } 06D0 60 PUSH1 0x00 06D2 80 DUP1 06D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @06D3 revert(memory[0x00:0x00]); } // Block terminates label_06D4: // Incoming jump from 0x06CF, if !msg.value // Inputs[1] { @06DB storage[0x12] } 06D4 5B JUMPDEST 06D5 50 POP 06D6 61 PUSH2 0x0327 06D9 60 PUSH1 0x12 06DB 54 SLOAD 06DC 81 DUP2 06DD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06D6 stack[-1] = 0x0327 // @06DB stack[0] = storage[0x12] // } // Block ends with unconditional jump to 0x0327 label_06DE: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @06DF msg.value } 06DE 5B JUMPDEST 06DF 34 CALLVALUE 06E0 80 DUP1 06E1 15 ISZERO 06E2 61 PUSH2 0x06ea 06E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06DF stack[0] = msg.value } // Block ends with conditional jump to 0x06ea, if !msg.value label_06E6: // Incoming jump from 0x06E5, if not !msg.value // Inputs[1] { @06E9 memory[0x00:0x00] } 06E6 60 PUSH1 0x00 06E8 80 DUP1 06E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E9 revert(memory[0x00:0x00]); } // Block terminates label_06EA: // Incoming jump from 0x06E5, if !msg.value // Inputs[1] { @06F2 msg.data.length } 06EA 5B JUMPDEST 06EB 50 POP 06EC 61 PUSH2 0x02ef 06EF 61 PUSH2 0x06f9 06F2 36 CALLDATASIZE 06F3 60 PUSH1 0x04 06F5 61 PUSH2 0x2742 06F8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06EC stack[-1] = 0x02ef // @06EF stack[0] = 0x06f9 // @06F2 stack[1] = msg.data.length // @06F3 stack[2] = 0x04 // } // Block ends with call to 0x2742, returns to 0x06F9 label_06F9: // Incoming return from call to 0x2742 at 0x06F8 06F9 5B JUMPDEST 06FA 61 PUSH2 0x14a5 06FD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14a5 label_06FE: // Incoming jump from 0x006A, if 0xfebfec50 == stack[-1] // Inputs[1] { @06FF msg.value } 06FE 5B JUMPDEST 06FF 34 CALLVALUE 0700 80 DUP1 0701 15 ISZERO 0702 61 PUSH2 0x070a 0705 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06FF stack[0] = msg.value } // Block ends with conditional jump to 0x070a, if !msg.value label_0706: // Incoming jump from 0x0705, if not !msg.value // Inputs[1] { @0709 memory[0x00:0x00] } 0706 60 PUSH1 0x00 0708 80 DUP1 0709 FD *REVERT // Stack delta = +0 // Outputs[1] { @0709 revert(memory[0x00:0x00]); } // Block terminates label_070A: // Incoming jump from 0x0705, if !msg.value // Inputs[1] { @0712 msg.data.length } 070A 5B JUMPDEST 070B 50 POP 070C 61 PUSH2 0x02ef 070F 61 PUSH2 0x0719 0712 36 CALLDATASIZE 0713 60 PUSH1 0x04 0715 61 PUSH2 0x28d8 0718 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @070C stack[-1] = 0x02ef // @070F stack[0] = 0x0719 // @0712 stack[1] = msg.data.length // @0713 stack[2] = 0x04 // } // Block ends with call to 0x28d8, returns to 0x0719 label_0719: // Incoming return from call to 0x28D8 at 0x0718 0719 5B JUMPDEST 071A 61 PUSH2 0x1543 071D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1543 label_071E: // Incoming jump from 0x025F // Inputs[1] { @0724 stack[-1] } 071E 5B JUMPDEST 071F 60 PUSH1 0x00 0721 61 PUSH2 0x0729 0724 82 DUP3 0725 61 PUSH2 0x159a 0728 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @071F stack[0] = 0x00 // @0721 stack[1] = 0x0729 // @0724 stack[2] = stack[-1] // } // Block ends with call to 0x159a, returns to 0x0729 label_0729: // Incoming jump from 0x1D16 // Incoming jump from 0x1CFD, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1CC7 at 0x15BE // Incoming jump from 0x15B5, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0D46, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1CFD, if stack[-1] // Incoming return from call to 0x159A at 0x0728 // Inputs[3] // { // @072A stack[-1] // @072A stack[-4] // @072B stack[-3] // } 0729 5B JUMPDEST 072A 92 SWAP3 072B 91 SWAP2 072C 50 POP 072D 50 POP 072E 56 *JUMP // Stack delta = -3 // Outputs[1] { @072A stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_072F: // Incoming call from 0x0289, returns to 0x028A // Inputs[1] { @0735 storage[0x00] } 072F 5B JUMPDEST 0730 60 PUSH1 0x60 0732 60 PUSH1 0x00 0734 80 DUP1 0735 54 SLOAD 0736 61 PUSH2 0x073e 0739 90 SWAP1 073A 61 PUSH2 0x28f9 073D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0730 stack[0] = 0x60 // @0732 stack[1] = 0x00 // @0739 stack[2] = 0x073e // @0739 stack[3] = storage[0x00] // } // Block ends with call to 0x28f9, returns to 0x073E label_073E: // Incoming return from call to 0x28F9 at 0x1F30 // Incoming return from call to 0x28F9 at 0x0EDE // Incoming return from call to 0x28F9 at 0x073D // Inputs[4] // { // @073F stack[-1] // @074E memory[0x40:0x60] // @0756 stack[-2] // @0761 storage[stack[-2]] // } 073E 5B JUMPDEST 073F 80 DUP1 0740 60 PUSH1 0x1f 0742 01 ADD 0743 60 PUSH1 0x20 0745 80 DUP1 0746 91 SWAP2 0747 04 DIV 0748 02 MUL 0749 60 PUSH1 0x20 074B 01 ADD 074C 60 PUSH1 0x40 074E 51 MLOAD 074F 90 SWAP1 0750 81 DUP2 0751 01 ADD 0752 60 PUSH1 0x40 0754 52 MSTORE 0755 80 DUP1 0756 92 SWAP3 0757 91 SWAP2 0758 90 SWAP1 0759 81 DUP2 075A 81 DUP2 075B 52 MSTORE 075C 60 PUSH1 0x20 075E 01 ADD 075F 82 DUP3 0760 80 DUP1 0761 54 SLOAD 0762 61 PUSH2 0x076a 0765 90 SWAP1 0766 61 PUSH2 0x28f9 0769 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0754 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0756 stack[-2] = memory[0x40:0x60] // @0757 stack[-1] = stack[-2] // @0758 stack[0] = stack[-1] // @075B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @075E stack[1] = 0x20 + memory[0x40:0x60] // @075F stack[2] = stack[-2] // @0765 stack[4] = storage[stack[-2]] // @0765 stack[3] = 0x076a // } // Block ends with call to 0x28f9, returns to 0x076A label_076A: // Incoming return from call to 0x28F9 at 0x0769 // Inputs[1] { @076B stack[-1] } 076A 5B JUMPDEST 076B 80 DUP1 076C 15 ISZERO 076D 61 PUSH2 0x07b7 0770 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07b7, if !stack[-1] label_0771: // Incoming jump from 0x0770, if not !stack[-1] // Inputs[1] { @0771 stack[-1] } 0771 80 DUP1 0772 60 PUSH1 0x1f 0774 10 LT 0775 61 PUSH2 0x078c 0778 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x078c, if 0x1f < stack[-1] label_0779: // Incoming jump from 0x0778, if not 0x1f < stack[-1] // Inputs[4] // { // @077D stack[-2] // @077E storage[stack[-2]] // @0781 stack[-3] // @0783 stack[-1] // } 0779 61 PUSH2 0x0100 077C 80 DUP1 077D 83 DUP4 077E 54 SLOAD 077F 04 DIV 0780 02 MUL 0781 83 DUP4 0782 52 MSTORE 0783 91 SWAP2 0784 60 PUSH1 0x20 0786 01 ADD 0787 91 SWAP2 0788 61 PUSH2 0x07b7 078B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0782 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0787 stack[-1] = stack[-1] // @0787 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07b7 label_078C: // Incoming jump from 0x0778, if 0x1f < stack[-1] // Inputs[5] // { // @078D stack[-3] // @078E stack[-1] // @0790 stack[-2] // @0798 memory[0x00:0x20] // @079C storage[keccak256(memory[0x00:0x20])] // } 078C 5B JUMPDEST 078D 82 DUP3 078E 01 ADD 078F 91 SWAP2 0790 90 SWAP1 0791 60 PUSH1 0x00 0793 52 MSTORE 0794 60 PUSH1 0x20 0796 60 PUSH1 0x00 0798 20 SHA3 0799 90 SWAP1 079A 5B JUMPDEST 079B 81 DUP2 079C 54 SLOAD 079D 81 DUP2 079E 52 MSTORE 079F 90 SWAP1 07A0 60 PUSH1 0x01 07A2 01 ADD 07A3 90 SWAP1 07A4 60 PUSH1 0x20 07A6 01 ADD 07A7 80 DUP1 07A8 83 DUP4 07A9 11 GT 07AA 61 PUSH2 0x079a 07AD 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @078F stack[-3] = stack[-3] + stack[-1] // @0793 memory[0x00:0x20] = stack[-2] // @079E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @07A3 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07A6 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x079a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07AE: // Incoming jump from 0x07AD, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x07AD, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @07AE stack[-3] // @07AF stack[-1] // } 07AE 82 DUP3 07AF 90 SWAP1 07B0 03 SUB 07B1 60 PUSH1 0x1f 07B3 16 AND 07B4 82 DUP3 07B5 01 ADD 07B6 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @07B6 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @07B6 stack[-1] = stack[-3] // } // Block continues label_07B7: // Incoming jump from 0x07B6 // Incoming jump from 0x0770, if !stack[-1] // Incoming jump from 0x078B // Inputs[3] // { // @07BD stack[-7] // @07BD stack[-6] // @07BF stack[-8] // } 07B7 5B JUMPDEST 07B8 50 POP 07B9 50 POP 07BA 50 POP 07BB 50 POP 07BC 50 POP 07BD 90 SWAP1 07BE 50 POP 07BF 90 SWAP1 07C0 56 *JUMP // Stack delta = -7 // Outputs[1] { @07BF stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_07C1: // Incoming call from 0x17CB, returns to 0x17CC // Incoming jump from 0x02B6 // Inputs[3] // { // @07C4 stack[-1] // @07CF memory[0x00:0x40] // @07D0 storage[keccak256(memory[0x00:0x40])] // } 07C1 5B JUMPDEST 07C2 60 PUSH1 0x00 07C4 81 DUP2 07C5 81 DUP2 07C6 52 MSTORE 07C7 60 PUSH1 0x02 07C9 60 PUSH1 0x20 07CB 52 MSTORE 07CC 60 PUSH1 0x40 07CE 81 DUP2 07CF 20 SHA3 07D0 54 SLOAD 07D1 60 PUSH1 0x01 07D3 60 PUSH1 0x01 07D5 60 PUSH1 0xa0 07D7 1B SHL 07D8 03 SUB 07D9 16 AND 07DA 61 PUSH2 0x083f 07DD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @07C2 stack[0] = 0x00 // @07C6 memory[0x00:0x20] = stack[-1] // @07CB memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x083f, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_07DE: // Incoming jump from 0x07DD, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @07E0 memory[0x40:0x60] } 07DE 60 PUSH1 0x40 07E0 51 MLOAD 07E1 62 PUSH3 0x461bcd 07E5 60 PUSH1 0xe5 07E7 1B SHL 07E8 81 DUP2 07E9 52 MSTORE 07EA 60 PUSH1 0x20 07EC 60 PUSH1 0x04 07EE 82 DUP3 07EF 01 ADD 07F0 52 MSTORE 07F1 60 PUSH1 0x2c 07F3 60 PUSH1 0x24 07F5 82 DUP3 07F6 01 ADD 07F7 52 MSTORE 07F8 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 0819 60 PUSH1 0x44 081B 82 DUP3 081C 01 ADD 081D 52 MSTORE 081E 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 082B 60 PUSH1 0xa1 082D 1B SHL 082E 60 PUSH1 0x64 0830 82 DUP3 0831 01 ADD 0832 52 MSTORE 0833 60 PUSH1 0x84 0835 01 ADD // Stack delta = +1 // Outputs[6] // { // @07E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07F0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07F7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @081D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @0832 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @0835 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0836: // Incoming return from call to 0x2934 at 0x0B33 // Incoming jump from 0x20A0 // Incoming jump from 0x08D3 // Incoming return from call to 0x2934 at 0x09D5 // Incoming jump from 0x11C4 // Incoming return from call to 0x29D0 at 0x1D39 // Incoming return from call to 0x2934 at 0x0E07 // Incoming jump from 0x1015 // Incoming jump from 0x10A5 // Incoming return from call to 0x2934 at 0x0D11 // Incoming jump from 0x1889 // Incoming return from call to 0x2934 at 0x09A0 // Incoming jump from 0x0961 // Incoming jump from 0x1388 // Incoming jump from 0x1334 // Incoming jump from 0x0FC1 // Incoming jump from 0x1790 // Incoming jump from 0x0CBC // Incoming jump from 0x0835 // Incoming jump from 0x122D // Incoming return from call to 0x2934 at 0x0A4F // Incoming jump from 0x20F6 // Incoming jump from 0x10EF // Incoming jump from 0x0BBC // Incoming jump from 0x1C6B // Incoming return from call to 0x29D0 at 0x0F44 // Incoming return from call to 0x2934 at 0x0EC3 // Incoming return from call to 0x2969 at 0x0F0F // Incoming return from call to 0x2934 at 0x14D4 // Incoming return from call to 0x2934 at 0x12E5 // Incoming jump from 0x0ADA // Incoming return from call to 0x29D0 at 0x16E2 // Incoming jump from 0x1675 // Incoming jump from 0x1539 // Incoming jump from 0x215B // Incoming jump from 0x127E // Incoming jump from 0x0E77 // Incoming return from call to 0x2934 at 0x149F // Incoming jump from 0x18EB // Incoming jump from 0x0D9F // Incoming jump from 0x0C45 // Incoming return from call to 0x2934 at 0x1572 // Incoming return from call to 0x2934 at 0x0DCF // Inputs[3] // { // @0839 memory[0x40:0x60] // @083B stack[-1] // @083E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0836 5B JUMPDEST 0837 60 PUSH1 0x40 0839 51 MLOAD 083A 80 DUP1 083B 91 SWAP2 083C 03 SUB 083D 90 SWAP1 083E FD *REVERT // Stack delta = -1 // Outputs[1] { @083E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_083F: // Incoming jump from 0x07DD, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @0843 stack[-2] // @084E memory[0x00:0x40] // @084F storage[keccak256(memory[0x00:0x40])] // @0859 stack[-3] // } 083F 5B JUMPDEST 0840 50 POP 0841 60 PUSH1 0x00 0843 90 SWAP1 0844 81 DUP2 0845 52 MSTORE 0846 60 PUSH1 0x04 0848 60 PUSH1 0x20 084A 52 MSTORE 084B 60 PUSH1 0x40 084D 90 SWAP1 084E 20 SHA3 084F 54 SLOAD 0850 60 PUSH1 0x01 0852 60 PUSH1 0x01 0854 60 PUSH1 0xa0 0856 1B SHL 0857 03 SUB 0858 16 AND 0859 90 SWAP1 085A 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0845 memory[0x00:0x20] = stack[-2] // @084A memory[0x20:0x40] = 0x04 // @0859 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_085B: // Incoming jump from 0x02EE // Inputs[1] { @0861 stack[-1] } 085B 5B JUMPDEST 085C 60 PUSH1 0x00 085E 61 PUSH2 0x0866 0861 82 DUP3 0862 61 PUSH2 0x0d29 0865 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @085C stack[0] = 0x00 // @085E stack[1] = 0x0866 // @0861 stack[2] = stack[-1] // } // Block ends with call to 0x0d29, returns to 0x0866 label_0866: // Incoming return from call to 0x0D29 at 0x0865 // Inputs[3] // { // @0867 stack[-2] // @0867 stack[-1] // @0873 stack[-4] // } 0866 5B JUMPDEST 0867 90 SWAP1 0868 50 POP 0869 80 DUP1 086A 60 PUSH1 0x01 086C 60 PUSH1 0x01 086E 60 PUSH1 0xa0 0870 1B SHL 0871 03 SUB 0872 16 AND 0873 83 DUP4 0874 60 PUSH1 0x01 0876 60 PUSH1 0x01 0878 60 PUSH1 0xa0 087A 1B SHL 087B 03 SUB 087C 16 AND 087D 14 EQ 087E 15 ISZERO 087F 61 PUSH2 0x08d4 0882 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0867 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x08d4, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0883: // Incoming jump from 0x0882, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0885 memory[0x40:0x60] } 0883 60 PUSH1 0x40 0885 51 MLOAD 0886 62 PUSH3 0x461bcd 088A 60 PUSH1 0xe5 088C 1B SHL 088D 81 DUP2 088E 52 MSTORE 088F 60 PUSH1 0x20 0891 60 PUSH1 0x04 0893 82 DUP3 0894 01 ADD 0895 52 MSTORE 0896 60 PUSH1 0x21 0898 60 PUSH1 0x24 089A 82 DUP3 089B 01 ADD 089C 52 MSTORE 089D 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 08BE 60 PUSH1 0x44 08C0 82 DUP3 08C1 01 ADD 08C2 52 MSTORE 08C3 60 PUSH1 0x39 08C5 60 PUSH1 0xf9 08C7 1B SHL 08C8 60 PUSH1 0x64 08CA 82 DUP3 08CB 01 ADD 08CC 52 MSTORE 08CD 60 PUSH1 0x84 08CF 01 ADD 08D0 61 PUSH2 0x0836 08D3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @088E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0895 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @089C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @08C2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @08CC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39 << 0xf9 // @08CF stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_08D4: // Incoming jump from 0x0882, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @08D5 msg.sender // @08DE stack[-1] // } 08D4 5B JUMPDEST 08D5 33 CALLER 08D6 60 PUSH1 0x01 08D8 60 PUSH1 0x01 08DA 60 PUSH1 0xa0 08DC 1B SHL 08DD 03 SUB 08DE 82 DUP3 08DF 16 AND 08E0 14 EQ 08E1 80 DUP1 08E2 61 PUSH2 0x08f0 08E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08E0 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x08f0, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_08E6: // Incoming jump from 0x08E5, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @08EA stack[-2] // @08EB msg.sender // } 08E6 50 POP 08E7 61 PUSH2 0x08f0 08EA 81 DUP2 08EB 33 CALLER 08EC 61 PUSH2 0x069a 08EF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08E7 stack[-1] = 0x08f0 // @08EA stack[0] = stack[-2] // @08EB stack[1] = msg.sender // } // Block ends with call to 0x069a, returns to 0x08F0 label_08F0: // Incoming return from call to 0x069A at 0x08EF // Incoming jump from 0x08E5, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @08F4 stack[-1] } 08F0 5B JUMPDEST 08F1 61 PUSH2 0x0962 08F4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0962, if stack[-1] label_08F5: // Incoming jump from 0x08F4, if not stack[-1] // Inputs[1] { @08F7 memory[0x40:0x60] } 08F5 60 PUSH1 0x40 08F7 51 MLOAD 08F8 62 PUSH3 0x461bcd 08FC 60 PUSH1 0xe5 08FE 1B SHL 08FF 81 DUP2 0900 52 MSTORE 0901 60 PUSH1 0x20 0903 60 PUSH1 0x04 0905 82 DUP3 0906 01 ADD 0907 52 MSTORE 0908 60 PUSH1 0x38 090A 60 PUSH1 0x24 090C 82 DUP3 090D 01 ADD 090E 52 MSTORE 090F 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 0930 60 PUSH1 0x44 0932 82 DUP3 0933 01 ADD 0934 52 MSTORE 0935 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 0956 60 PUSH1 0x64 0958 82 DUP3 0959 01 ADD 095A 52 MSTORE 095B 60 PUSH1 0x84 095D 01 ADD 095E 61 PUSH2 0x0836 0961 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0900 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0907 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @090E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x38 // @0934 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @095A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 // @095D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_0962: // Incoming jump from 0x08F4, if stack[-1] // Inputs[2] // { // @0966 stack[-3] // @0967 stack[-2] // } 0962 5B JUMPDEST 0963 61 PUSH2 0x096c 0966 83 DUP4 0967 83 DUP4 0968 61 PUSH2 0x15bf 096B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0963 stack[0] = 0x096c // @0966 stack[1] = stack[-3] // @0967 stack[2] = stack[-2] // } // Block ends with call to 0x15bf, returns to 0x096C label_096C: // Incoming jump from 0x2045, if !(0xff & storage[0x0a]) // Incoming return from call to 0x2344 at 0x2283 // Incoming jump from 0x229D, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Incoming return from call to 0x202F at 0x1D44 // Incoming return from call to 0x23F3 at 0x22A6 // Incoming return from call to 0x15BF at 0x096B // Inputs[1] { @0970 stack[-4] } 096C 5B JUMPDEST 096D 50 POP 096E 50 POP 096F 50 POP 0970 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0971: // Incoming jump from 0x0310 // Inputs[2] // { // @0974 storage[0x0a] // @0984 msg.sender // } 0971 5B JUMPDEST 0972 60 PUSH1 0x0a 0974 54 SLOAD 0975 60 PUSH1 0x01 0977 60 PUSH1 0x01 0979 60 PUSH1 0xa0 097B 1B SHL 097C 03 SUB 097D 61 PUSH2 0x0100 0980 90 SWAP1 0981 91 SWAP2 0982 04 DIV 0983 16 AND 0984 33 CALLER 0985 14 EQ 0986 61 PUSH2 0x09a1 0989 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09a1, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_098A: // Incoming jump from 0x0989, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @098C memory[0x40:0x60] } 098A 60 PUSH1 0x40 098C 51 MLOAD 098D 62 PUSH3 0x461bcd 0991 60 PUSH1 0xe5 0993 1B SHL 0994 81 DUP2 0995 52 MSTORE 0996 60 PUSH1 0x04 0998 01 ADD 0999 61 PUSH2 0x0836 099C 90 SWAP1 099D 61 PUSH2 0x2934 09A0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0995 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @099C stack[0] = 0x0836 // @099C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_09A1: // Incoming jump from 0x0989, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @09A4 stack[-1] // @09A5 stack[-2] // } 09A1 5B JUMPDEST 09A2 60 PUSH1 0x0f 09A4 55 SSTORE 09A5 56 *JUMP // Stack delta = -2 // Outputs[1] { @09A4 storage[0x0f] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_09A6: // Incoming jump from 0x0354 // Inputs[2] // { // @09A9 storage[0x0a] // @09B9 msg.sender // } 09A6 5B JUMPDEST 09A7 60 PUSH1 0x0a 09A9 54 SLOAD 09AA 60 PUSH1 0x01 09AC 60 PUSH1 0x01 09AE 60 PUSH1 0xa0 09B0 1B SHL 09B1 03 SUB 09B2 61 PUSH2 0x0100 09B5 90 SWAP1 09B6 91 SWAP2 09B7 04 DIV 09B8 16 AND 09B9 33 CALLER 09BA 14 EQ 09BB 61 PUSH2 0x09d6 09BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09d6, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_09BF: // Incoming jump from 0x09BE, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @09C1 memory[0x40:0x60] } 09BF 60 PUSH1 0x40 09C1 51 MLOAD 09C2 62 PUSH3 0x461bcd 09C6 60 PUSH1 0xe5 09C8 1B SHL 09C9 81 DUP2 09CA 52 MSTORE 09CB 60 PUSH1 0x04 09CD 01 ADD 09CE 61 PUSH2 0x0836 09D1 90 SWAP1 09D2 61 PUSH2 0x2934 09D5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09D1 stack[0] = 0x0836 // @09D1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_09D6: // Incoming jump from 0x09BE, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @09D7 stack[-1] } 09D6 5B JUMPDEST 09D7 80 DUP1 09D8 61 PUSH2 0x09e6 09DB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09e6, if stack[-1] label_09DC: // Incoming jump from 0x09DB, if not stack[-1] 09DC 61 PUSH2 0x09e3 09DF 61 PUSH2 0x162d 09E2 56 *JUMP // Stack delta = +1 // Outputs[1] { @09DC stack[0] = 0x09e3 } // Block ends with call to 0x162d, returns to 0x09E3 label_09E3: // Incoming return from call to 0x162D at 0x09E2 // Incoming jump from 0x24E1, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1A61 at 0x1542 // Incoming return from call to 0x16C0 at 0x09ED // Incoming jump from 0x0B84, if stack[-3] // Incoming jump from 0x0B84, if stack[-3] // Inputs[1] { @09E5 stack[-2] } 09E3 5B JUMPDEST 09E4 50 POP 09E5 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_09E6: // Incoming jump from 0x09DB, if stack[-1] 09E6 5B JUMPDEST 09E7 61 PUSH2 0x09e3 09EA 61 PUSH2 0x16c0 09ED 56 *JUMP // Stack delta = +1 // Outputs[1] { @09E7 stack[0] = 0x09e3 } // Block ends with call to 0x16c0, returns to 0x09E3 label_09EE: // Incoming jump from 0x039F // Inputs[1] { @09F2 msg.sender } 09EE 5B JUMPDEST 09EF 61 PUSH2 0x09f9 09F2 33 CALLER // Stack delta = +2 // Outputs[2] // { // @09EF stack[0] = 0x09f9 // @09F2 stack[1] = msg.sender // } // Block continues label_09F3: // Incoming jump from 0x09F2 // Incoming call from 0x0BE0, returns to 0x0BE1 // Inputs[1] { @09F4 stack[-3] } 09F3 5B JUMPDEST 09F4 82 DUP3 09F5 61 PUSH2 0x1718 09F8 56 *JUMP // Stack delta = +1 // Outputs[1] { @09F4 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x1718 09F9 5B JUMPDEST 09FA 61 PUSH2 0x0a15 09FD 57 *JUMPI 09FE 60 PUSH1 0x40 0A00 51 MLOAD 0A01 62 PUSH3 0x461bcd 0A05 60 PUSH1 0xe5 0A07 1B SHL 0A08 81 DUP2 0A09 52 MSTORE 0A0A 60 PUSH1 0x04 0A0C 01 ADD 0A0D 61 PUSH2 0x0836 0A10 90 SWAP1 0A11 61 PUSH2 0x2969 0A14 56 *JUMP 0A15 5B JUMPDEST 0A16 61 PUSH2 0x096c 0A19 83 DUP4 0A1A 83 DUP4 0A1B 83 DUP4 0A1C 61 PUSH2 0x180f 0A1F 56 *JUMP label_0A20: // Incoming jump from 0x03BF // Inputs[2] // { // @0A23 storage[0x0a] // @0A33 msg.sender // } 0A20 5B JUMPDEST 0A21 60 PUSH1 0x0a 0A23 54 SLOAD 0A24 60 PUSH1 0x01 0A26 60 PUSH1 0x01 0A28 60 PUSH1 0xa0 0A2A 1B SHL 0A2B 03 SUB 0A2C 61 PUSH2 0x0100 0A2F 90 SWAP1 0A30 91 SWAP2 0A31 04 DIV 0A32 16 AND 0A33 33 CALLER 0A34 14 EQ 0A35 61 PUSH2 0x0a50 0A38 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a50, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0A39: // Incoming jump from 0x0A38, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A3B memory[0x40:0x60] } 0A39 60 PUSH1 0x40 0A3B 51 MLOAD 0A3C 62 PUSH3 0x461bcd 0A40 60 PUSH1 0xe5 0A42 1B SHL 0A43 81 DUP2 0A44 52 MSTORE 0A45 60 PUSH1 0x04 0A47 01 ADD 0A48 61 PUSH2 0x0836 0A4B 90 SWAP1 0A4C 61 PUSH2 0x2934 0A4F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A44 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A4B stack[0] = 0x0836 // @0A4B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_0A50: // Incoming jump from 0x0A38, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0A54 storage[0x0a] // @0A55 stack[-1] // @0A6D stack[-2] // } 0A50 5B JUMPDEST 0A51 60 PUSH1 0x0a 0A53 80 DUP1 0A54 54 SLOAD 0A55 91 SWAP2 0A56 15 ISZERO 0A57 15 ISZERO 0A58 60 PUSH1 0x01 0A5A 60 PUSH1 0xa8 0A5C 1B SHL 0A5D 02 MUL 0A5E 60 PUSH1 0xff 0A60 60 PUSH1 0xa8 0A62 1B SHL 0A63 19 NOT 0A64 90 SWAP1 0A65 92 SWAP3 0A66 16 AND 0A67 91 SWAP2 0A68 90 SWAP1 0A69 91 SWAP2 0A6A 17 OR 0A6B 90 SWAP1 0A6C 55 SSTORE 0A6D 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A6C storage[0x0a] = (storage[0x0a] & ~(0xff << 0xa8)) | (0x01 << 0xa8) * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_0A6E: // Incoming jump from 0x03DF // Inputs[1] { @0A74 stack[-2] } 0A6E 5B JUMPDEST 0A6F 60 PUSH1 0x00 0A71 61 PUSH2 0x0a79 0A74 83 DUP4 0A75 61 PUSH2 0x0e0d 0A78 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A6F stack[0] = 0x00 // @0A71 stack[1] = 0x0a79 // @0A74 stack[2] = stack[-2] // } // Block ends with call to 0x0e0d, returns to 0x0A79 label_0A79: // Incoming return from call to 0x0E0D at 0x0A78 // Inputs[2] // { // @0A7A stack[-3] // @0A7B stack[-1] // } 0A79 5B JUMPDEST 0A7A 82 DUP3 0A7B 10 LT 0A7C 61 PUSH2 0x0adb 0A7F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0adb, if stack[-3] < stack[-1] label_0A80: // Incoming jump from 0x0A7F, if not stack[-3] < stack[-1] // Inputs[1] { @0A82 memory[0x40:0x60] } 0A80 60 PUSH1 0x40 0A82 51 MLOAD 0A83 62 PUSH3 0x461bcd 0A87 60 PUSH1 0xe5 0A89 1B SHL 0A8A 81 DUP2 0A8B 52 MSTORE 0A8C 60 PUSH1 0x20 0A8E 60 PUSH1 0x04 0A90 82 DUP3 0A91 01 ADD 0A92 52 MSTORE 0A93 60 PUSH1 0x2b 0A95 60 PUSH1 0x24 0A97 82 DUP3 0A98 01 ADD 0A99 52 MSTORE 0A9A 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 0ABB 60 PUSH1 0x44 0ABD 82 DUP3 0ABE 01 ADD 0ABF 52 MSTORE 0AC0 6A PUSH11 0x74206f6620626f756e6473 0ACC 60 PUSH1 0xa8 0ACE 1B SHL 0ACF 60 PUSH1 0x64 0AD1 82 DUP3 0AD2 01 ADD 0AD3 52 MSTORE 0AD4 60 PUSH1 0x84 0AD6 01 ADD 0AD7 61 PUSH2 0x0836 0ADA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0A8B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A92 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A99 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @0ABF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 // @0AD3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x74206f6620626f756e6473 << 0xa8 // @0AD6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_0ADB: // Incoming jump from 0x0A7F, if stack[-3] < stack[-1] // Inputs[6] // { // @0AE5 stack[-3] // @0AE6 stack[-2] // @0AF9 memory[0x00:0x40] // @0B00 memory[0x00:0x40] // @0B01 storage[keccak256(memory[0x00:0x40])] // @0B02 stack[-4] // } 0ADB 5B JUMPDEST 0ADC 50 POP 0ADD 60 PUSH1 0x01 0ADF 60 PUSH1 0x01 0AE1 60 PUSH1 0xa0 0AE3 1B SHL 0AE4 03 SUB 0AE5 91 SWAP2 0AE6 90 SWAP1 0AE7 91 SWAP2 0AE8 16 AND 0AE9 60 PUSH1 0x00 0AEB 90 SWAP1 0AEC 81 DUP2 0AED 52 MSTORE 0AEE 60 PUSH1 0x06 0AF0 60 PUSH1 0x20 0AF2 90 SWAP1 0AF3 81 DUP2 0AF4 52 MSTORE 0AF5 60 PUSH1 0x40 0AF7 80 DUP1 0AF8 83 DUP4 0AF9 20 SHA3 0AFA 93 SWAP4 0AFB 83 DUP4 0AFC 52 MSTORE 0AFD 92 SWAP3 0AFE 90 SWAP1 0AFF 52 MSTORE 0B00 20 SHA3 0B01 54 SLOAD 0B02 90 SWAP1 0B03 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0AED memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0AF4 memory[0x20:0x40] = 0x06 // @0AFC memory[0x00:0x20] = stack[-2] // @0AFF memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0B02 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0B04: // Incoming call from 0x03E7, returns to 0x02EF // Inputs[2] // { // @0B07 storage[0x0a] // @0B17 msg.sender // } 0B04 5B JUMPDEST 0B05 60 PUSH1 0x0a 0B07 54 SLOAD 0B08 60 PUSH1 0x01 0B0A 60 PUSH1 0x01 0B0C 60 PUSH1 0xa0 0B0E 1B SHL 0B0F 03 SUB 0B10 61 PUSH2 0x0100 0B13 90 SWAP1 0B14 91 SWAP2 0B15 04 DIV 0B16 16 AND 0B17 33 CALLER 0B18 14 EQ 0B19 61 PUSH2 0x0b34 0B1C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b34, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0B1D: // Incoming jump from 0x0B1C, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B1F memory[0x40:0x60] } 0B1D 60 PUSH1 0x40 0B1F 51 MLOAD 0B20 62 PUSH3 0x461bcd 0B24 60 PUSH1 0xe5 0B26 1B SHL 0B27 81 DUP2 0B28 52 MSTORE 0B29 60 PUSH1 0x04 0B2B 01 ADD 0B2C 61 PUSH2 0x0836 0B2F 90 SWAP1 0B30 61 PUSH2 0x2934 0B33 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B28 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B2F stack[0] = 0x0836 // @0B2F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_0B34: // Incoming jump from 0x0B1C, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[8] // { // @0B37 memory[0x40:0x60] // @0B3B msg.sender // @0B3D address(this).balance // @0B3D address(this) // @0B45 msg.gas // @0B46 address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0B46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0B4B returndata.length // } 0B34 5B JUMPDEST 0B35 60 PUSH1 0x40 0B37 51 MLOAD 0B38 60 PUSH1 0x00 0B3A 90 SWAP1 0B3B 33 CALLER 0B3C 90 SWAP1 0B3D 47 SELFBALANCE 0B3E 90 SWAP1 0B3F 83 DUP4 0B40 81 DUP2 0B41 81 DUP2 0B42 81 DUP2 0B43 85 DUP6 0B44 87 DUP8 0B45 5A GAS 0B46 F1 CALL 0B47 92 SWAP3 0B48 50 POP 0B49 50 POP 0B4A 50 POP 0B4B 3D RETURNDATASIZE 0B4C 80 DUP1 0B4D 60 PUSH1 0x00 0B4F 81 DUP2 0B50 14 EQ 0B51 61 PUSH2 0x0b76 0B54 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @0B3A stack[0] = 0x00 // @0B46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0B47 stack[1] = address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0B4B stack[2] = returndata.length // @0B4C stack[3] = returndata.length // } // Block ends with conditional jump to 0x0b76, if returndata.length == 0x00 label_0B55: // Incoming jump from 0x0B54, if not returndata.length == 0x00 // Inputs[6] // { // @0B57 memory[0x40:0x60] // @0B58 stack[-2] // @0B5F returndata.length // @0B67 returndata.length // @0B6A returndata.length // @0B71 returndata[0x00:0x00 + returndata.length] // } 0B55 60 PUSH1 0x40 0B57 51 MLOAD 0B58 91 SWAP2 0B59 50 POP 0B5A 60 PUSH1 0x1f 0B5C 19 NOT 0B5D 60 PUSH1 0x3f 0B5F 3D RETURNDATASIZE 0B60 01 ADD 0B61 16 AND 0B62 82 DUP3 0B63 01 ADD 0B64 60 PUSH1 0x40 0B66 52 MSTORE 0B67 3D RETURNDATASIZE 0B68 82 DUP3 0B69 52 MSTORE 0B6A 3D RETURNDATASIZE 0B6B 60 PUSH1 0x00 0B6D 60 PUSH1 0x20 0B6F 84 DUP5 0B70 01 ADD 0B71 3E RETURNDATACOPY 0B72 61 PUSH2 0x0b7b 0B75 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0B58 stack[-2] = memory[0x40:0x60] // @0B66 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0B69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0B71 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0b7b label_0B76: // Incoming jump from 0x0B54, if returndata.length == 0x00 // Inputs[3] // { // @0B79 stack[-2] // @0B7E stack[-4] // @0B7E stack[-3] // } 0B76 5B JUMPDEST 0B77 60 PUSH1 0x60 0B79 91 SWAP2 0B7A 50 POP 0B7B 5B JUMPDEST 0B7C 50 POP 0B7D 50 POP 0B7E 90 SWAP1 0B7F 50 POP 0B80 80 DUP1 0B81 61 PUSH2 0x09e3 0B84 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0B7E stack[-4] = stack[-3] } // Block ends with conditional jump to 0x09e3, if stack[-3] label_0B85: // Incoming jump from 0x0B84, if not stack[-3] // Incoming jump from 0x0B84, if not stack[-3] // Inputs[1] { @0B87 memory[0x40:0x60] } 0B85 60 PUSH1 0x40 0B87 51 MLOAD 0B88 62 PUSH3 0x461bcd 0B8C 60 PUSH1 0xe5 0B8E 1B SHL 0B8F 81 DUP2 0B90 52 MSTORE 0B91 60 PUSH1 0x20 0B93 60 PUSH1 0x04 0B95 82 DUP3 0B96 01 ADD 0B97 52 MSTORE 0B98 60 PUSH1 0x0e 0B9A 60 PUSH1 0x24 0B9C 82 DUP3 0B9D 01 ADD 0B9E 52 MSTORE 0B9F 6D PUSH14 0x2ba4aa24222920ab9022a92927a9 0BAE 60 PUSH1 0x91 0BB0 1B SHL 0BB1 60 PUSH1 0x44 0BB3 82 DUP3 0BB4 01 ADD 0BB5 52 MSTORE 0BB6 60 PUSH1 0x64 0BB8 01 ADD 0BB9 61 PUSH2 0x0836 0BBC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B90 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B97 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B9E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0BB5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x2ba4aa24222920ab9022a92927a9 << 0x91 // @0BB8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_0BBD: // Incoming jump from 0x0407 // Inputs[4] // { // @0BC1 stack[-3] // @0BC2 stack[-2] // @0BC3 stack[-1] // @0BC6 memory[0x40:0x60] // } 0BBD 5B JUMPDEST 0BBE 61 PUSH2 0x096c 0BC1 83 DUP4 0BC2 83 DUP4 0BC3 83 DUP4 0BC4 60 PUSH1 0x40 0BC6 51 MLOAD 0BC7 80 DUP1 0BC8 60 PUSH1 0x20 0BCA 01 ADD 0BCB 60 PUSH1 0x40 0BCD 52 MSTORE 0BCE 80 DUP1 0BCF 60 PUSH1 0x00 0BD1 81 DUP2 0BD2 52 MSTORE 0BD3 50 POP 0BD4 61 PUSH2 0x0eea 0BD7 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0BBE stack[0] = 0x096c // @0BC1 stack[1] = stack[-3] // @0BC2 stack[2] = stack[-2] // @0BC3 stack[3] = stack[-1] // @0BC6 stack[4] = memory[0x40:0x60] // @0BCD memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0BD2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0eea label_0BD8: // Incoming jump from 0x0427 // Inputs[1] { @0BDC msg.sender } 0BD8 5B JUMPDEST 0BD9 61 PUSH2 0x0be1 0BDC 33 CALLER 0BDD 61 PUSH2 0x09f3 0BE0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BD9 stack[0] = 0x0be1 // @0BDC stack[1] = msg.sender // } // Block ends with call to 0x09f3, returns to 0x0BE1 label_0BE1: // Incoming return from call to 0x09F3 at 0x0BE0 // Inputs[1] { @0BE5 stack[-1] } 0BE1 5B JUMPDEST 0BE2 61 PUSH2 0x0c46 0BE5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c46, if stack[-1] label_0BE6: // Incoming jump from 0x0BE5, if not stack[-1] // Inputs[1] { @0BE8 memory[0x40:0x60] } 0BE6 60 PUSH1 0x40 0BE8 51 MLOAD 0BE9 62 PUSH3 0x461bcd 0BED 60 PUSH1 0xe5 0BEF 1B SHL 0BF0 81 DUP2 0BF1 52 MSTORE 0BF2 60 PUSH1 0x20 0BF4 60 PUSH1 0x04 0BF6 82 DUP3 0BF7 01 ADD 0BF8 52 MSTORE 0BF9 60 PUSH1 0x30 0BFB 60 PUSH1 0x24 0BFD 82 DUP3 0BFE 01 ADD 0BFF 52 MSTORE 0C00 7F PUSH32 0x4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f77 0C21 60 PUSH1 0x44 0C23 82 DUP3 0C24 01 ADD 0C25 52 MSTORE 0C26 6F PUSH16 0x1b995c881b9bdc88185c1c1c9bdd9959 0C37 60 PUSH1 0x82 0C39 1B SHL 0C3A 60 PUSH1 0x64 0C3C 82 DUP3 0C3D 01 ADD 0C3E 52 MSTORE 0C3F 60 PUSH1 0x84 0C41 01 ADD 0C42 61 PUSH2 0x0836 0C45 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0BF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BF8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BFF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x30 // @0C25 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f77 // @0C3E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1b995c881b9bdc88185c1c1c9bdd9959 << 0x82 // @0C41 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_0C46: // Incoming jump from 0x0BE5, if stack[-1] // Inputs[1] { @0C4A stack[-1] } 0C46 5B JUMPDEST 0C47 61 PUSH2 0x09e3 0C4A 81 DUP2 0C4B 61 PUSH2 0x19ba 0C4E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C47 stack[0] = 0x09e3 // @0C4A stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x19ba label_0C4F: // Incoming jump from 0x0447 // Inputs[1] { @0C57 storage[0x08] } 0C4F 5B JUMPDEST 0C50 60 PUSH1 0x00 0C52 61 PUSH2 0x0c5a 0C55 60 PUSH1 0x08 0C57 54 SLOAD 0C58 90 SWAP1 0C59 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C50 stack[0] = 0x00 // @0C58 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x0c5a label_0C5A: // Incoming jump from 0x0C59 // Inputs[2] // { // @0C5B stack[-3] // @0C5C stack[-1] // } 0C5A 5B JUMPDEST 0C5B 82 DUP3 0C5C 10 LT 0C5D 61 PUSH2 0x0cbd 0C60 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cbd, if stack[-3] < stack[-1] label_0C61: // Incoming jump from 0x0C60, if not stack[-3] < stack[-1] // Inputs[1] { @0C63 memory[0x40:0x60] } 0C61 60 PUSH1 0x40 0C63 51 MLOAD 0C64 62 PUSH3 0x461bcd 0C68 60 PUSH1 0xe5 0C6A 1B SHL 0C6B 81 DUP2 0C6C 52 MSTORE 0C6D 60 PUSH1 0x20 0C6F 60 PUSH1 0x04 0C71 82 DUP3 0C72 01 ADD 0C73 52 MSTORE 0C74 60 PUSH1 0x2c 0C76 60 PUSH1 0x24 0C78 82 DUP3 0C79 01 ADD 0C7A 52 MSTORE 0C7B 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 0C9C 60 PUSH1 0x44 0C9E 82 DUP3 0C9F 01 ADD 0CA0 52 MSTORE 0CA1 6B PUSH12 0x7574206f6620626f756e6473 0CAE 60 PUSH1 0xa0 0CB0 1B SHL 0CB1 60 PUSH1 0x64 0CB3 82 DUP3 0CB4 01 ADD 0CB5 52 MSTORE 0CB6 60 PUSH1 0x84 0CB8 01 ADD 0CB9 61 PUSH2 0x0836 0CBC 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C6C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C73 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C7A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @0CA0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @0CB5 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7574206f6620626f756e6473 << 0xa0 // @0CB8 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_0CBD: // Incoming jump from 0x0C60, if stack[-3] < stack[-1] // Inputs[2] // { // @0CC0 stack[-2] // @0CC2 storage[0x08] // } 0CBD 5B JUMPDEST 0CBE 60 PUSH1 0x08 0CC0 82 DUP3 0CC1 81 DUP2 0CC2 54 SLOAD 0CC3 81 DUP2 0CC4 10 LT 0CC5 61 PUSH2 0x0cd0 0CC8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0CBE stack[0] = 0x08 // @0CC0 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0cd0, if stack[-2] < storage[0x08] label_0CC9: // Incoming jump from 0x0CC8, if not stack[-2] < storage[0x08] 0CC9 61 PUSH2 0x0cd0 0CCC 61 PUSH2 0x29ba 0CCF 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CC9 stack[0] = 0x0cd0 } // Block ends with unconditional jump to 0x29ba label_0CD0: // Incoming jump from 0x0CC8, if stack[-2] < storage[0x08] // Inputs[7] // { // @0CD1 stack[-2] // @0CD1 stack[-1] // @0CD9 memory[0x00:0x20] // @0CDB storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0CDC stack[-3] // @0CDE stack[-5] // @0CDF stack[-4] // } 0CD0 5B JUMPDEST 0CD1 90 SWAP1 0CD2 60 PUSH1 0x00 0CD4 52 MSTORE 0CD5 60 PUSH1 0x20 0CD7 60 PUSH1 0x00 0CD9 20 SHA3 0CDA 01 ADD 0CDB 54 SLOAD 0CDC 90 SWAP1 0CDD 50 POP 0CDE 91 SWAP2 0CDF 90 SWAP1 0CE0 50 POP 0CE1 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0CD4 memory[0x00:0x20] = stack[-2] // @0CDE stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_0CE2: // Incoming jump from 0x0488 // Inputs[2] // { // @0CE5 storage[0x0a] // @0CF5 msg.sender // } 0CE2 5B JUMPDEST 0CE3 60 PUSH1 0x0a 0CE5 54 SLOAD 0CE6 60 PUSH1 0x01 0CE8 60 PUSH1 0x01 0CEA 60 PUSH1 0xa0 0CEC 1B SHL 0CED 03 SUB 0CEE 61 PUSH2 0x0100 0CF1 90 SWAP1 0CF2 91 SWAP2 0CF3 04 DIV 0CF4 16 AND 0CF5 33 CALLER 0CF6 14 EQ 0CF7 61 PUSH2 0x0d12 0CFA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d12, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0CFB: // Incoming jump from 0x0CFA, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0CFD memory[0x40:0x60] } 0CFB 60 PUSH1 0x40 0CFD 51 MLOAD 0CFE 62 PUSH3 0x461bcd 0D02 60 PUSH1 0xe5 0D04 1B SHL 0D05 81 DUP2 0D06 52 MSTORE 0D07 60 PUSH1 0x04 0D09 01 ADD 0D0A 61 PUSH2 0x0836 0D0D 90 SWAP1 0D0E 61 PUSH2 0x2934 0D11 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D06 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D0D stack[0] = 0x0836 // @0D0D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_0D12: // Incoming jump from 0x0CFA, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0D13 stack[-1] // @0D14 memory[stack[-1]:stack[-1] + 0x20] // } 0D12 5B JUMPDEST 0D13 80 DUP1 0D14 51 MLOAD 0D15 61 PUSH2 0x0d25 0D18 90 SWAP1 0D19 60 PUSH1 0x0b 0D1B 90 SWAP1 0D1C 60 PUSH1 0x20 0D1E 84 DUP5 0D1F 01 ADD 0D20 90 SWAP1 0D21 61 PUSH2 0x2437 0D24 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D18 stack[0] = 0x0d25 // @0D1B stack[1] = 0x0b // @0D20 stack[2] = stack[-1] + 0x20 // @0D20 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2437 0D25 5B JUMPDEST 0D26 50 POP 0D27 50 POP 0D28 56 *JUMP label_0D29: // Incoming call from 0x15F3, returns to 0x15F4 // Incoming jump from 0x04C0 // Incoming call from 0x19C4, returns to 0x19C5 // Incoming call from 0x1821, returns to 0x1822 // Incoming call from 0x179B, returns to 0x179C // Incoming call from 0x0865, returns to 0x0866 // Inputs[3] // { // @0D2C stack[-1] // @0D37 memory[0x00:0x40] // @0D38 storage[keccak256(memory[0x00:0x40])] // } 0D29 5B JUMPDEST 0D2A 60 PUSH1 0x00 0D2C 81 DUP2 0D2D 81 DUP2 0D2E 52 MSTORE 0D2F 60 PUSH1 0x02 0D31 60 PUSH1 0x20 0D33 52 MSTORE 0D34 60 PUSH1 0x40 0D36 81 DUP2 0D37 20 SHA3 0D38 54 SLOAD 0D39 60 PUSH1 0x01 0D3B 60 PUSH1 0x01 0D3D 60 PUSH1 0xa0 0D3F 1B SHL 0D40 03 SUB 0D41 16 AND 0D42 80 DUP1 0D43 61 PUSH2 0x0729 0D46 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0D2A stack[0] = 0x00 // @0D2E memory[0x00:0x20] = stack[-1] // @0D33 memory[0x20:0x40] = 0x02 // @0D41 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0729, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0D47: // Incoming jump from 0x0D46, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0D49 memory[0x40:0x60] } 0D47 60 PUSH1 0x40 0D49 51 MLOAD 0D4A 62 PUSH3 0x461bcd 0D4E 60 PUSH1 0xe5 0D50 1B SHL 0D51 81 DUP2 0D52 52 MSTORE 0D53 60 PUSH1 0x20 0D55 60 PUSH1 0x04 0D57 82 DUP3 0D58 01 ADD 0D59 52 MSTORE 0D5A 60 PUSH1 0x29 0D5C 60 PUSH1 0x24 0D5E 82 DUP3 0D5F 01 ADD 0D60 52 MSTORE 0D61 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 0D82 60 PUSH1 0x44 0D84 82 DUP3 0D85 01 ADD 0D86 52 MSTORE 0D87 68 PUSH9 0x32b73a103a37b5b2b7 0D91 60 PUSH1 0xb9 0D93 1B SHL 0D94 60 PUSH1 0x64 0D96 82 DUP3 0D97 01 ADD 0D98 52 MSTORE 0D99 60 PUSH1 0x84 0D9B 01 ADD 0D9C 61 PUSH2 0x0836 0D9F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0D52 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D59 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D60 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0D86 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @0D98 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x32b73a103a37b5b2b7 << 0xb9 // @0D9B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_0DA0: // Incoming jump from 0x0507 // Inputs[2] // { // @0DA3 storage[0x0a] // @0DB3 msg.sender // } 0DA0 5B JUMPDEST 0DA1 60 PUSH1 0x0a 0DA3 54 SLOAD 0DA4 60 PUSH1 0x01 0DA6 60 PUSH1 0x01 0DA8 60 PUSH1 0xa0 0DAA 1B SHL 0DAB 03 SUB 0DAC 61 PUSH2 0x0100 0DAF 90 SWAP1 0DB0 91 SWAP2 0DB1 04 DIV 0DB2 16 AND 0DB3 33 CALLER 0DB4 14 EQ 0DB5 61 PUSH2 0x0dd0 0DB8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dd0, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0DB9: // Incoming jump from 0x0DB8, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0DBB memory[0x40:0x60] } 0DB9 60 PUSH1 0x40 0DBB 51 MLOAD 0DBC 62 PUSH3 0x461bcd 0DC0 60 PUSH1 0xe5 0DC2 1B SHL 0DC3 81 DUP2 0DC4 52 MSTORE 0DC5 60 PUSH1 0x04 0DC7 01 ADD 0DC8 61 PUSH2 0x0836 0DCB 90 SWAP1 0DCC 61 PUSH2 0x2934 0DCF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DC4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DCB stack[0] = 0x0836 // @0DCB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_0DD0: // Incoming jump from 0x0DB8, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0DD3 stack[-1] // @0DD4 stack[-2] // } 0DD0 5B JUMPDEST 0DD1 60 PUSH1 0x0e 0DD3 55 SSTORE 0DD4 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DD3 storage[0x0e] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0DD5: // Incoming call from 0x051C, returns to 0x0327 // Inputs[2] // { // @0DD8 storage[0x0a] // @0DEB msg.sender // } 0DD5 5B JUMPDEST 0DD6 60 PUSH1 0x0a 0DD8 54 SLOAD 0DD9 60 PUSH1 0x00 0DDB 90 SWAP1 0DDC 60 PUSH1 0x01 0DDE 60 PUSH1 0x01 0DE0 60 PUSH1 0xa0 0DE2 1B SHL 0DE3 03 SUB 0DE4 61 PUSH2 0x0100 0DE7 90 SWAP1 0DE8 91 SWAP2 0DE9 04 DIV 0DEA 16 AND 0DEB 33 CALLER 0DEC 14 EQ 0DED 61 PUSH2 0x0e08 0DF0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DDB stack[0] = 0x00 } // Block ends with conditional jump to 0x0e08, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0DF1: // Incoming jump from 0x0DF0, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0DF3 memory[0x40:0x60] } 0DF1 60 PUSH1 0x40 0DF3 51 MLOAD 0DF4 62 PUSH3 0x461bcd 0DF8 60 PUSH1 0xe5 0DFA 1B SHL 0DFB 81 DUP2 0DFC 52 MSTORE 0DFD 60 PUSH1 0x04 0DFF 01 ADD 0E00 61 PUSH2 0x0836 0E03 90 SWAP1 0E04 61 PUSH2 0x2934 0E07 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DFC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E03 stack[0] = 0x0836 // @0E03 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_0E08: // Incoming jump from 0x0DF0, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0E0A address(this).balance // @0E0A address(this) // @0E0B stack[-2] // } 0E08 5B JUMPDEST 0E09 50 POP 0E0A 47 SELFBALANCE 0E0B 90 SWAP1 0E0C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0E0B stack[-2] = address(this).balance } // Block ends with unconditional jump to stack[-2] label_0E0D: // Incoming call from 0x23FD, returns to 0x23FE // Incoming call from 0x0A78, returns to 0x0A79 // Incoming call from 0x22B3, returns to 0x22B4 // Incoming call from 0x11CF, returns to 0x11D0 // Incoming jump from 0x053C // Inputs[1] { @0E18 stack[-1] } 0E0D 5B JUMPDEST 0E0E 60 PUSH1 0x00 0E10 60 PUSH1 0x01 0E12 60 PUSH1 0x01 0E14 60 PUSH1 0xa0 0E16 1B SHL 0E17 03 SUB 0E18 82 DUP3 0E19 16 AND 0E1A 61 PUSH2 0x0e78 0E1D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E0E stack[0] = 0x00 } // Block ends with conditional jump to 0x0e78, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0E1E: // Incoming jump from 0x0E1D, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0E20 memory[0x40:0x60] } 0E1E 60 PUSH1 0x40 0E20 51 MLOAD 0E21 62 PUSH3 0x461bcd 0E25 60 PUSH1 0xe5 0E27 1B SHL 0E28 81 DUP2 0E29 52 MSTORE 0E2A 60 PUSH1 0x20 0E2C 60 PUSH1 0x04 0E2E 82 DUP3 0E2F 01 ADD 0E30 52 MSTORE 0E31 60 PUSH1 0x2a 0E33 60 PUSH1 0x24 0E35 82 DUP3 0E36 01 ADD 0E37 52 MSTORE 0E38 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 0E59 60 PUSH1 0x44 0E5B 82 DUP3 0E5C 01 ADD 0E5D 52 MSTORE 0E5E 69 PUSH10 0x726f2061646472657373 0E69 60 PUSH1 0xb0 0E6B 1B SHL 0E6C 60 PUSH1 0x64 0E6E 82 DUP3 0E6F 01 ADD 0E70 52 MSTORE 0E71 60 PUSH1 0x84 0E73 01 ADD 0E74 61 PUSH2 0x0836 0E77 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0E29 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E30 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E37 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @0E5D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @0E70 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x726f2061646472657373 << 0xb0 // @0E73 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_0E78: // Incoming jump from 0x0E1D, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0E82 stack[-2] // @0E90 memory[0x00:0x40] // @0E91 storage[keccak256(memory[0x00:0x40])] // @0E92 stack[-3] // } 0E78 5B JUMPDEST 0E79 50 POP 0E7A 60 PUSH1 0x01 0E7C 60 PUSH1 0x01 0E7E 60 PUSH1 0xa0 0E80 1B SHL 0E81 03 SUB 0E82 16 AND 0E83 60 PUSH1 0x00 0E85 90 SWAP1 0E86 81 DUP2 0E87 52 MSTORE 0E88 60 PUSH1 0x03 0E8A 60 PUSH1 0x20 0E8C 52 MSTORE 0E8D 60 PUSH1 0x40 0E8F 90 SWAP1 0E90 20 SHA3 0E91 54 SLOAD 0E92 90 SWAP1 0E93 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0E87 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0E8C memory[0x20:0x40] = 0x03 // @0E92 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0E94: // Incoming call from 0x0551, returns to 0x02EF // Inputs[2] // { // @0E97 storage[0x0a] // @0EA7 msg.sender // } 0E94 5B JUMPDEST 0E95 60 PUSH1 0x0a 0E97 54 SLOAD 0E98 60 PUSH1 0x01 0E9A 60 PUSH1 0x01 0E9C 60 PUSH1 0xa0 0E9E 1B SHL 0E9F 03 SUB 0EA0 61 PUSH2 0x0100 0EA3 90 SWAP1 0EA4 91 SWAP2 0EA5 04 DIV 0EA6 16 AND 0EA7 33 CALLER 0EA8 14 EQ 0EA9 61 PUSH2 0x0ec4 0EAC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ec4, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0EAD: // Incoming jump from 0x0EAC, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0EAF memory[0x40:0x60] } 0EAD 60 PUSH1 0x40 0EAF 51 MLOAD 0EB0 62 PUSH3 0x461bcd 0EB4 60 PUSH1 0xe5 0EB6 1B SHL 0EB7 81 DUP2 0EB8 52 MSTORE 0EB9 60 PUSH1 0x04 0EBB 01 ADD 0EBC 61 PUSH2 0x0836 0EBF 90 SWAP1 0EC0 61 PUSH2 0x2934 0EC3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EB8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EBF stack[0] = 0x0836 // @0EBF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_0EC4: // Incoming jump from 0x0EAC, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 0EC4 5B JUMPDEST 0EC5 61 PUSH2 0x0ece 0EC8 60 PUSH1 0x00 0ECA 61 PUSH2 0x1a61 0ECD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0EC5 stack[0] = 0x0ece // @0EC8 stack[1] = 0x00 // } // Block ends with call to 0x1a61, returns to 0x0ECE label_0ECE: // Incoming return from call to 0x1A61 at 0x0ECD // Inputs[1] { @0ECF stack[-1] } 0ECE 5B JUMPDEST 0ECF 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0ED0: // Incoming call from 0x0589, returns to 0x028A // Inputs[1] { @0ED6 storage[0x01] } 0ED0 5B JUMPDEST 0ED1 60 PUSH1 0x60 0ED3 60 PUSH1 0x01 0ED5 80 DUP1 0ED6 54 SLOAD 0ED7 61 PUSH2 0x073e 0EDA 90 SWAP1 0EDB 61 PUSH2 0x28f9 0EDE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0ED1 stack[0] = 0x60 // @0ED3 stack[1] = 0x01 // @0EDA stack[2] = 0x073e // @0EDA stack[3] = storage[0x01] // } // Block ends with call to 0x28f9, returns to 0x073E 0EDF 5B JUMPDEST 0EE0 61 PUSH2 0x0d25 0EE3 33 CALLER 0EE4 83 DUP4 0EE5 83 DUP4 0EE6 61 PUSH2 0x1abb 0EE9 56 *JUMP label_0EEA: // Incoming jump from 0x05DF // Incoming jump from 0x0BD7 // Inputs[2] // { // @0EEE msg.sender // @0EEF stack[-2] // } 0EEA 5B JUMPDEST 0EEB 61 PUSH2 0x0ef4 0EEE 33 CALLER 0EEF 83 DUP4 0EF0 61 PUSH2 0x1718 0EF3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EEB stack[0] = 0x0ef4 // @0EEE stack[1] = msg.sender // @0EEF stack[2] = stack[-2] // } // Block ends with call to 0x1718, returns to 0x0EF4 label_0EF4: // Incoming return from call to 0x1718 at 0x0EF3 // Inputs[1] { @0EF8 stack[-1] } 0EF4 5B JUMPDEST 0EF5 61 PUSH2 0x0f10 0EF8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f10, if stack[-1] label_0EF9: // Incoming jump from 0x0EF8, if not stack[-1] // Inputs[1] { @0EFB memory[0x40:0x60] } 0EF9 60 PUSH1 0x40 0EFB 51 MLOAD 0EFC 62 PUSH3 0x461bcd 0F00 60 PUSH1 0xe5 0F02 1B SHL 0F03 81 DUP2 0F04 52 MSTORE 0F05 60 PUSH1 0x04 0F07 01 ADD 0F08 61 PUSH2 0x0836 0F0B 90 SWAP1 0F0C 61 PUSH2 0x2969 0F0F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F0B stack[0] = 0x0836 // @0F0B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2969, returns to 0x0836 label_0F10: // Incoming jump from 0x0EF8, if stack[-1] // Inputs[4] // { // @0F14 stack[-4] // @0F15 stack[-3] // @0F16 stack[-2] // @0F17 stack[-1] // } 0F10 5B JUMPDEST 0F11 61 PUSH2 0x0f1c 0F14 84 DUP5 0F15 84 DUP5 0F16 84 DUP5 0F17 84 DUP5 0F18 61 PUSH2 0x1b8a 0F1B 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0F11 stack[0] = 0x0f1c // @0F14 stack[1] = stack[-4] // @0F15 stack[2] = stack[-3] // @0F16 stack[3] = stack[-2] // @0F17 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1b8a label_0F1C: // Incoming jump from 0x2526, if !(stack[-1] > stack[-4]) // Incoming jump from 0x1393, if 0x01 > stack[-3] // Inputs[1] { @0F21 stack[-5] } 0F1C 5B JUMPDEST 0F1D 50 POP 0F1E 50 POP 0F1F 50 POP 0F20 50 POP 0F21 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0F22: // Incoming jump from 0x05F2 // Inputs[1] { @0F25 storage[0x0a] } 0F22 5B JUMPDEST 0F23 60 PUSH1 0x0a 0F25 54 SLOAD 0F26 60 PUSH1 0xff 0F28 16 AND 0F29 15 ISZERO 0F2A 61 PUSH2 0x0f45 0F2D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f45, if !(0xff & storage[0x0a]) label_0F2E: // Incoming jump from 0x0F2D, if not !(0xff & storage[0x0a]) // Inputs[1] { @0F30 memory[0x40:0x60] } 0F2E 60 PUSH1 0x40 0F30 51 MLOAD 0F31 62 PUSH3 0x461bcd 0F35 60 PUSH1 0xe5 0F37 1B SHL 0F38 81 DUP2 0F39 52 MSTORE 0F3A 60 PUSH1 0x04 0F3C 01 ADD 0F3D 61 PUSH2 0x0836 0F40 90 SWAP1 0F41 61 PUSH2 0x29d0 0F44 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F39 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F40 stack[0] = 0x0836 // @0F40 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29d0, returns to 0x0836 label_0F45: // Incoming jump from 0x0F2D, if !(0xff & storage[0x0a]) // Inputs[1] { @0F4D storage[0x08] } 0F45 5B JUMPDEST 0F46 60 PUSH1 0x00 0F48 61 PUSH2 0x0f50 0F4B 60 PUSH1 0x08 0F4D 54 SLOAD 0F4E 90 SWAP1 0F4F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F46 stack[0] = 0x00 // @0F4E stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x0f50 label_0F50: // Incoming jump from 0x0F4F // Inputs[3] // { // @0F51 stack[-1] // @0F51 stack[-2] // @0F59 storage[0x11] // } 0F50 5B JUMPDEST 0F51 90 SWAP1 0F52 50 POP 0F53 60 PUSH1 0x00 0F55 60 PUSH1 0x01 0F57 60 PUSH1 0x11 0F59 54 SLOAD 0F5A 60 PUSH1 0xff 0F5C 16 AND 0F5D 60 PUSH1 0x02 0F5F 81 DUP2 0F60 11 GT 0F61 15 ISZERO 0F62 61 PUSH2 0x0f6d 0F65 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0F51 stack[-2] = stack[-1] // @0F53 stack[-1] = 0x00 // @0F55 stack[0] = 0x01 // @0F5C stack[1] = 0xff & storage[0x11] // } // Block ends with conditional jump to 0x0f6d, if !(0xff & storage[0x11] > 0x02) label_0F66: // Incoming jump from 0x0F65, if not !(0xff & storage[0x11] > 0x02) 0F66 61 PUSH2 0x0f6d 0F69 61 PUSH2 0x2704 0F6C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F66 stack[0] = 0x0f6d } // Block ends with unconditional jump to 0x2704 label_0F6D: // Incoming jump from 0x0F65, if !(0xff & storage[0x11] > 0x02) // Inputs[2] // { // @0F6E stack[-2] // @0F6E stack[-1] // } 0F6D 5B JUMPDEST 0F6E 14 EQ 0F6F 61 PUSH2 0x0f7a 0F72 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0f7a, if stack[-1] == stack[-2] label_0F73: // Incoming jump from 0x0F72, if not stack[-1] == stack[-2] // Inputs[1] { @0F75 storage[0x0d] } 0F73 60 PUSH1 0x0d 0F75 54 SLOAD 0F76 61 PUSH2 0x0f7e 0F79 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F75 stack[0] = storage[0x0d] } // Block ends with unconditional jump to 0x0f7e label_0F7A: // Incoming jump from 0x0F72, if stack[-1] == stack[-2] // Inputs[3] // { // @0F7D storage[0x0c] // @0F7F stack[-1] // @0F83 stack[-5] // } 0F7A 5B JUMPDEST 0F7B 60 PUSH1 0x0c 0F7D 54 SLOAD 0F7E 5B JUMPDEST 0F7F 90 SWAP1 0F80 50 POP 0F81 60 PUSH1 0x00 0F83 85 DUP6 0F84 11 GT 0F85 61 PUSH2 0x0fc2 0F88 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0F7F stack[-1] = storage[0x0c] } // Block ends with conditional jump to 0x0fc2, if stack[-5] > 0x00 label_0F89: // Incoming jump from 0x0F88, if not stack[-6] > 0x00 // Incoming jump from 0x0F88, if not stack[-5] > 0x00 // Inputs[1] { @0F8B memory[0x40:0x60] } 0F89 60 PUSH1 0x40 0F8B 51 MLOAD 0F8C 62 PUSH3 0x461bcd 0F90 60 PUSH1 0xe5 0F92 1B SHL 0F93 81 DUP2 0F94 52 MSTORE 0F95 60 PUSH1 0x20 0F97 60 PUSH1 0x04 0F99 82 DUP3 0F9A 01 ADD 0F9B 52 MSTORE 0F9C 60 PUSH1 0x0f 0F9E 60 PUSH1 0x24 0FA0 82 DUP3 0FA1 01 ADD 0FA2 52 MSTORE 0FA3 6E PUSH15 0x06d696e7420616d6f756e74203e203 0FB3 60 PUSH1 0x8c 0FB5 1B SHL 0FB6 60 PUSH1 0x44 0FB8 82 DUP3 0FB9 01 ADD 0FBA 52 MSTORE 0FBB 60 PUSH1 0x64 0FBD 01 ADD 0FBE 61 PUSH2 0x0836 0FC1 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F94 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F9B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FA2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @0FBA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x06d696e7420616d6f756e74203e203 << 0x8c // @0FBD stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_0FC2: // Incoming jump from 0x0F88, if stack[-6] > 0x00 // Incoming jump from 0x0F88, if stack[-5] > 0x00 // Inputs[3] // { // @0FC5 storage[0x0e] // @0FC9 stack[-5] // @0FCA stack[-2] // } 0FC2 5B JUMPDEST 0FC3 60 PUSH1 0x0e 0FC5 54 SLOAD 0FC6 61 PUSH2 0x0fcf 0FC9 86 DUP7 0FCA 84 DUP5 0FCB 61 PUSH2 0x2a10 0FCE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FC5 stack[0] = storage[0x0e] // @0FC6 stack[1] = 0x0fcf // @0FC9 stack[2] = stack[-5] // @0FCA stack[3] = stack[-2] // } // Block ends with call to 0x2a10, returns to 0x0FCF label_0FCF: // Incoming return from call to 0x2A10 at 0x0FCE // Inputs[2] // { // @0FD0 stack[-2] // @0FD0 stack[-1] // } 0FCF 5B JUMPDEST 0FD0 11 GT 0FD1 15 ISZERO 0FD2 61 PUSH2 0x1016 0FD5 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1016, if !(stack[-1] > stack[-2]) label_0FD6: // Incoming jump from 0x0FD5, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0FD8 memory[0x40:0x60] } 0FD6 60 PUSH1 0x40 0FD8 51 MLOAD 0FD9 62 PUSH3 0x461bcd 0FDD 60 PUSH1 0xe5 0FDF 1B SHL 0FE0 81 DUP2 0FE1 52 MSTORE 0FE2 60 PUSH1 0x20 0FE4 60 PUSH1 0x04 0FE6 82 DUP3 0FE7 01 ADD 0FE8 52 MSTORE 0FE9 60 PUSH1 0x16 0FEB 60 PUSH1 0x24 0FED 82 DUP3 0FEE 01 ADD 0FEF 52 MSTORE 0FF0 75 PUSH22 0x1b585e08139195081b1a5b5a5d08195e18d959591959 1007 60 PUSH1 0x52 1009 1B SHL 100A 60 PUSH1 0x44 100C 82 DUP3 100D 01 ADD 100E 52 MSTORE 100F 60 PUSH1 0x64 1011 01 ADD 1012 61 PUSH2 0x0836 1015 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0FE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FE8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FEF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @100E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b585e08139195081b1a5b5a5d08195e18d959591959 << 0x52 // @1011 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_1016: // Incoming jump from 0x0FD5, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1019 storage[0x0a] // @1031 msg.sender // } 1016 5B JUMPDEST 1017 60 PUSH1 0x0a 1019 54 SLOAD 101A 61 PUSH2 0x0100 101D 90 SWAP1 101E 04 DIV 101F 60 PUSH1 0x01 1021 60 PUSH1 0x01 1023 60 PUSH1 0xa0 1025 1B SHL 1026 03 SUB 1027 16 AND 1028 60 PUSH1 0x01 102A 60 PUSH1 0x01 102C 60 PUSH1 0xa0 102E 1B SHL 102F 03 SUB 1030 16 AND 1031 33 CALLER 1032 60 PUSH1 0x01 1034 60 PUSH1 0x01 1036 60 PUSH1 0xa0 1038 1B SHL 1039 03 SUB 103A 16 AND 103B 14 EQ 103C 61 PUSH2 0x127f 103F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x127f, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 label_1040: // Incoming jump from 0x103F, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 // Inputs[1] { @1044 storage[0x11] } 1040 60 PUSH1 0x00 1042 60 PUSH1 0x11 1044 54 SLOAD 1045 60 PUSH1 0xff 1047 16 AND 1048 60 PUSH1 0x02 104A 81 DUP2 104B 11 GT 104C 15 ISZERO 104D 61 PUSH2 0x1058 1050 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1040 stack[0] = 0x00 // @1047 stack[1] = 0xff & storage[0x11] // } // Block ends with conditional jump to 0x1058, if !(0xff & storage[0x11] > 0x02) label_1051: // Incoming jump from 0x1050, if not !(0xff & storage[0x11] > 0x02) 1051 61 PUSH2 0x1058 1054 61 PUSH2 0x2704 1057 56 *JUMP // Stack delta = +1 // Outputs[1] { @1051 stack[0] = 0x1058 } // Block ends with unconditional jump to 0x2704 label_1058: // Incoming jump from 0x1050, if !(0xff & storage[0x11] > 0x02) // Inputs[2] // { // @1059 stack[-2] // @1059 stack[-1] // } 1058 5B JUMPDEST 1059 14 EQ 105A 15 ISZERO 105B 61 PUSH2 0x10a6 105E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x10a6, if !(stack[-1] == stack[-2]) label_105F: // Incoming jump from 0x105E, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1061 memory[0x40:0x60] } 105F 60 PUSH1 0x40 1061 51 MLOAD 1062 62 PUSH3 0x461bcd 1066 60 PUSH1 0xe5 1068 1B SHL 1069 81 DUP2 106A 52 MSTORE 106B 60 PUSH1 0x20 106D 60 PUSH1 0x04 106F 82 DUP3 1070 01 ADD 1071 52 MSTORE 1072 60 PUSH1 0x18 1074 60 PUSH1 0x24 1076 82 DUP3 1077 01 ADD 1078 52 MSTORE 1079 7F PUSH32 0x53616c6520686173206e6f742073746172746564207965740000000000000000 109A 60 PUSH1 0x44 109C 82 DUP3 109D 01 ADD 109E 52 MSTORE 109F 60 PUSH1 0x64 10A1 01 ADD 10A2 61 PUSH2 0x0836 10A5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @106A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1071 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1078 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @109E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53616c6520686173206e6f742073746172746564207965740000000000000000 // @10A1 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_10A6: // Incoming jump from 0x105E, if !(stack[-1] == stack[-2]) // Inputs[2] // { // @10A9 storage[0x10] // @10AA stack[-5] // } 10A6 5B JUMPDEST 10A7 60 PUSH1 0x10 10A9 54 SLOAD 10AA 85 DUP6 10AB 11 GT 10AC 15 ISZERO 10AD 61 PUSH2 0x10f0 10B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10f0, if !(stack[-5] > storage[0x10]) label_10B1: // Incoming jump from 0x10B0, if not !(stack[-5] > storage[0x10]) // Inputs[1] { @10B3 memory[0x40:0x60] } 10B1 60 PUSH1 0x40 10B3 51 MLOAD 10B4 62 PUSH3 0x461bcd 10B8 60 PUSH1 0xe5 10BA 1B SHL 10BB 81 DUP2 10BC 52 MSTORE 10BD 60 PUSH1 0x20 10BF 60 PUSH1 0x04 10C1 82 DUP3 10C2 01 ADD 10C3 52 MSTORE 10C4 60 PUSH1 0x15 10C6 60 PUSH1 0x24 10C8 82 DUP3 10C9 01 ADD 10CA 52 MSTORE 10CB 74 PUSH21 0x151bdbc81b585b9e481a5d195b5cc81b5a5b9d1959 10E1 60 PUSH1 0x5a 10E3 1B SHL 10E4 60 PUSH1 0x44 10E6 82 DUP3 10E7 01 ADD 10E8 52 MSTORE 10E9 60 PUSH1 0x64 10EB 01 ADD 10EC 61 PUSH2 0x0836 10EF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @10BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10C3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10CA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @10E8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x151bdbc81b585b9e481a5d195b5cc81b5a5b9d1959 << 0x5a // @10EB stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_10F0: // Incoming jump from 0x10B0, if !(stack[-5] > storage[0x10]) // Inputs[1] { @10F5 storage[0x11] } 10F0 5B JUMPDEST 10F1 60 PUSH1 0x01 10F3 60 PUSH1 0x11 10F5 54 SLOAD 10F6 60 PUSH1 0xff 10F8 16 AND 10F9 60 PUSH1 0x02 10FB 81 DUP2 10FC 11 GT 10FD 15 ISZERO 10FE 61 PUSH2 0x1109 1101 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @10F1 stack[0] = 0x01 // @10F8 stack[1] = 0xff & storage[0x11] // } // Block ends with conditional jump to 0x1109, if !(0xff & storage[0x11] > 0x02) label_1102: // Incoming jump from 0x1101, if not !(0xff & storage[0x11] > 0x02) 1102 61 PUSH2 0x1109 1105 61 PUSH2 0x2704 1108 56 *JUMP // Stack delta = +1 // Outputs[1] { @1102 stack[0] = 0x1109 } // Block ends with unconditional jump to 0x2704 label_1109: // Incoming jump from 0x1101, if !(0xff & storage[0x11] > 0x02) // Inputs[2] // { // @110A stack[-1] // @110A stack[-2] // } 1109 5B JUMPDEST 110A 14 EQ 110B 15 ISZERO 110C 61 PUSH2 0x1231 110F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1231, if !(stack[-1] == stack[-2]) label_1110: // Incoming jump from 0x110F, if not !(stack[-1] == stack[-2]) // Inputs[10] // { // @1112 memory[0x40:0x60] // @1121 msg.sender // @1133 memory[0x40:0x60] // @1141 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1146 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @114C stack[-4] // @114D stack[-3] // @1158 memory[0x40:0x60] // @1172 msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @117F storage[0x12] // } 1110 60 PUSH1 0x40 1112 51 MLOAD 1113 6B PUSH12 0xffffffffffffffffffffffff 1120 19 NOT 1121 33 CALLER 1122 60 PUSH1 0x60 1124 1B SHL 1125 16 AND 1126 60 PUSH1 0x20 1128 82 DUP3 1129 01 ADD 112A 52 MSTORE 112B 60 PUSH1 0x00 112D 90 SWAP1 112E 60 PUSH1 0x34 1130 01 ADD 1131 60 PUSH1 0x40 1133 51 MLOAD 1134 60 PUSH1 0x20 1136 81 DUP2 1137 83 DUP4 1138 03 SUB 1139 03 SUB 113A 81 DUP2 113B 52 MSTORE 113C 90 SWAP1 113D 60 PUSH1 0x40 113F 52 MSTORE 1140 80 DUP1 1141 51 MLOAD 1142 90 SWAP1 1143 60 PUSH1 0x20 1145 01 ADD 1146 20 SHA3 1147 90 SWAP1 1148 50 POP 1149 61 PUSH2 0x1189 114C 85 DUP6 114D 85 DUP6 114E 80 DUP1 114F 80 DUP1 1150 60 PUSH1 0x20 1152 02 MUL 1153 60 PUSH1 0x20 1155 01 ADD 1156 60 PUSH1 0x40 1158 51 MLOAD 1159 90 SWAP1 115A 81 DUP2 115B 01 ADD 115C 60 PUSH1 0x40 115E 52 MSTORE 115F 80 DUP1 1160 93 SWAP4 1161 92 SWAP3 1162 91 SWAP2 1163 90 SWAP1 1164 81 DUP2 1165 81 DUP2 1166 52 MSTORE 1167 60 PUSH1 0x20 1169 01 ADD 116A 83 DUP4 116B 83 DUP4 116C 60 PUSH1 0x20 116E 02 MUL 116F 80 DUP1 1170 82 DUP3 1171 84 DUP5 1172 37 CALLDATACOPY 1173 60 PUSH1 0x00 1175 92 SWAP3 1176 01 ADD 1177 91 SWAP2 1178 90 SWAP1 1179 91 SWAP2 117A 52 MSTORE 117B 50 POP 117C 50 POP 117D 60 PUSH1 0x12 117F 54 SLOAD 1180 91 SWAP2 1181 50 POP 1182 84 DUP5 1183 90 SWAP1 1184 50 POP 1185 61 PUSH2 0x1bbd 1188 56 *JUMP // Stack delta = +5 // Outputs[12] // { // @112A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @113B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x34 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @113F memory[0x40:0x60] = 0x34 + memory[0x40:0x60] // @1147 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1149 stack[1] = 0x1189 // @115E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-3] // @1160 stack[2] = memory[0x40:0x60] // @1166 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @1172 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3]] = msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @117A memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-3]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3] + 0x20] = 0x00 // @1180 stack[3] = storage[0x12] // @1183 stack[4] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x1bbd, returns to 0x1189 label_1189: // Incoming return from call to 0x1BBD at 0x1188 // Inputs[1] { @118D stack[-1] } 1189 5B JUMPDEST 118A 61 PUSH2 0x11c5 118D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11c5, if stack[-1] label_118E: // Incoming jump from 0x118D, if not stack[-1] // Inputs[1] { @1190 memory[0x40:0x60] } 118E 60 PUSH1 0x40 1190 51 MLOAD 1191 62 PUSH3 0x461bcd 1195 60 PUSH1 0xe5 1197 1B SHL 1198 81 DUP2 1199 52 MSTORE 119A 60 PUSH1 0x20 119C 60 PUSH1 0x04 119E 82 DUP3 119F 01 ADD 11A0 52 MSTORE 11A1 60 PUSH1 0x0d 11A3 60 PUSH1 0x24 11A5 82 DUP3 11A6 01 ADD 11A7 52 MSTORE 11A8 6C PUSH13 0x34b73b30b634b210383937b7b3 11B6 60 PUSH1 0x99 11B8 1B SHL 11B9 60 PUSH1 0x44 11BB 82 DUP3 11BC 01 ADD 11BD 52 MSTORE 11BE 60 PUSH1 0x64 11C0 01 ADD 11C1 61 PUSH2 0x0836 11C4 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1199 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11A0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11A7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @11BD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x34b73b30b634b210383937b7b3 << 0x99 // @11C0 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_11C5: // Incoming jump from 0x118D, if stack[-1] // Inputs[1] { @11CB msg.sender } 11C5 5B JUMPDEST 11C6 60 PUSH1 0x00 11C8 61 PUSH2 0x11d0 11CB 33 CALLER 11CC 61 PUSH2 0x0e0d 11CF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11C6 stack[0] = 0x00 // @11C8 stack[1] = 0x11d0 // @11CB stack[2] = msg.sender // } // Block ends with call to 0x0e0d, returns to 0x11D0 label_11D0: // Incoming return from call to 0x0E0D at 0x11CF // Inputs[4] // { // @11D3 storage[0x0f] // @11D4 stack[-1] // @11D5 stack[-2] // @11DA stack[-8] // } 11D0 5B JUMPDEST 11D1 60 PUSH1 0x0f 11D3 54 SLOAD 11D4 90 SWAP1 11D5 91 SWAP2 11D6 50 POP 11D7 61 PUSH2 0x11e0 11DA 88 DUP9 11DB 83 DUP4 11DC 61 PUSH2 0x2a10 11DF 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @11D4 stack[-1] = storage[0x0f] // @11D5 stack[-2] = stack[-1] // @11D7 stack[0] = 0x11e0 // @11DA stack[1] = stack[-8] // @11DB stack[2] = stack[-1] // } // Block ends with call to 0x2a10, returns to 0x11E0 label_11E0: // Incoming return from call to 0x2A10 at 0x11DF // Inputs[2] // { // @11E1 stack[-1] // @11E1 stack[-2] // } 11E0 5B JUMPDEST 11E1 11 GT 11E2 15 ISZERO 11E3 61 PUSH2 0x122e 11E6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x122e, if !(stack[-1] > stack[-2]) label_11E7: // Incoming jump from 0x11E6, if not !(stack[-1] > stack[-2]) // Inputs[1] { @11E9 memory[0x40:0x60] } 11E7 60 PUSH1 0x40 11E9 51 MLOAD 11EA 62 PUSH3 0x461bcd 11EE 60 PUSH1 0xe5 11F0 1B SHL 11F1 81 DUP2 11F2 52 MSTORE 11F3 60 PUSH1 0x20 11F5 60 PUSH1 0x04 11F7 82 DUP3 11F8 01 ADD 11F9 52 MSTORE 11FA 60 PUSH1 0x18 11FC 60 PUSH1 0x24 11FE 82 DUP3 11FF 01 ADD 1200 52 MSTORE 1201 7F PUSH32 0x6d6178206d696e7420616d6f756e742065786365656465640000000000000000 1222 60 PUSH1 0x44 1224 82 DUP3 1225 01 ADD 1226 52 MSTORE 1227 60 PUSH1 0x64 1229 01 ADD 122A 61 PUSH2 0x0836 122D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11F9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1200 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @1226 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6d6178206d696e7420616d6f756e742065786365656465640000000000000000 // @1229 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_122E: // Incoming jump from 0x11E6, if !(stack[-1] > stack[-2]) 122E 5B JUMPDEST 122F 50 POP 1230 50 POP // Stack delta = -2 // Block continues label_1231: // Incoming jump from 0x110F, if !(stack[-1] == stack[-2]) // Incoming jump from 0x1230 // Inputs[2] // { // @1235 stack[-5] // @1236 stack[-1] // } 1231 5B JUMPDEST 1232 61 PUSH2 0x123b 1235 85 DUP6 1236 82 DUP3 1237 61 PUSH2 0x2a28 123A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1232 stack[0] = 0x123b // @1235 stack[1] = stack[-5] // @1236 stack[2] = stack[-1] // } // Block ends with call to 0x2a28, returns to 0x123B label_123B: // Incoming return from call to 0x2A28 at 0x123A // Inputs[2] // { // @123C msg.value // @123D stack[-1] // } 123B 5B JUMPDEST 123C 34 CALLVALUE 123D 10 LT 123E 15 ISZERO 123F 61 PUSH2 0x127f 1242 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x127f, if !(msg.value < stack[-1]) label_1243: // Incoming jump from 0x1242, if not !(msg.value < stack[-1]) // Inputs[1] { @1245 memory[0x40:0x60] } 1243 60 PUSH1 0x40 1245 51 MLOAD 1246 62 PUSH3 0x461bcd 124A 60 PUSH1 0xe5 124C 1B SHL 124D 81 DUP2 124E 52 MSTORE 124F 60 PUSH1 0x20 1251 60 PUSH1 0x04 1253 82 DUP3 1254 01 ADD 1255 52 MSTORE 1256 60 PUSH1 0x12 1258 60 PUSH1 0x24 125A 82 DUP3 125B 01 ADD 125C 52 MSTORE 125D 71 PUSH18 0x696e73756666696369656e742066756e6473 1270 60 PUSH1 0x70 1272 1B SHL 1273 60 PUSH1 0x44 1275 82 DUP3 1276 01 ADD 1277 52 MSTORE 1278 60 PUSH1 0x64 127A 01 ADD 127B 61 PUSH2 0x0836 127E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @124E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1255 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @125C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @1277 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x696e73756666696369656e742066756e6473 << 0x70 // @127A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_127F: // Incoming jump from 0x103F, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 // Incoming jump from 0x1242, if !(msg.value < stack[-1]) // Inputs[1] { @1283 stack[-5] } 127F 5B JUMPDEST 1280 60 PUSH1 0x01 1282 5B JUMPDEST 1283 85 DUP6 1284 81 DUP2 1285 11 GT 1286 61 PUSH2 0x12ae 1289 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1280 stack[0] = 0x01 } // Block ends with conditional jump to 0x12ae, if 0x01 > stack[-5] label_128A: // Incoming jump from 0x1289, if not 0x01 > stack[-5] // Inputs[3] // { // @128D msg.sender // @1291 stack[-1] // @1292 stack[-3] // } 128A 61 PUSH2 0x129c 128D 33 CALLER 128E 61 PUSH2 0x1297 1291 83 DUP4 1292 86 DUP7 1293 61 PUSH2 0x2a10 1296 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @128A stack[0] = 0x129c // @128D stack[1] = msg.sender // @128E stack[2] = 0x1297 // @1291 stack[3] = stack[-1] // @1292 stack[4] = stack[-3] // } // Block ends with call to 0x2a10, returns to 0x1297 label_1297: // Incoming return from call to 0x2A10 at 0x1296 // Incoming return from call to 0x2A10 at 0x13A0 1297 5B JUMPDEST 1298 61 PUSH2 0x1bd3 129B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1bd3 129C 5B JUMPDEST 129D 80 DUP1 129E 61 PUSH2 0x12a6 12A1 81 DUP2 12A2 61 PUSH2 0x2a47 12A5 56 *JUMP 12A6 5B JUMPDEST 12A7 91 SWAP2 12A8 50 POP 12A9 50 POP 12AA 61 PUSH2 0x1282 12AD 56 *JUMP label_12AE: // Incoming jump from 0x1289, if 0x01 > stack[-5] // Inputs[1] { @12B5 stack[-7] } 12AE 5B JUMPDEST 12AF 50 POP 12B0 50 POP 12B1 50 POP 12B2 50 POP 12B3 50 POP 12B4 50 POP 12B5 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_12B6: // Incoming jump from 0x0612 // Inputs[2] // { // @12B9 storage[0x0a] // @12C9 msg.sender // } 12B6 5B JUMPDEST 12B7 60 PUSH1 0x0a 12B9 54 SLOAD 12BA 60 PUSH1 0x01 12BC 60 PUSH1 0x01 12BE 60 PUSH1 0xa0 12C0 1B SHL 12C1 03 SUB 12C2 61 PUSH2 0x0100 12C5 90 SWAP1 12C6 91 SWAP2 12C7 04 DIV 12C8 16 AND 12C9 33 CALLER 12CA 14 EQ 12CB 61 PUSH2 0x12e6 12CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12e6, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_12CF: // Incoming jump from 0x12CE, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12D1 memory[0x40:0x60] } 12CF 60 PUSH1 0x40 12D1 51 MLOAD 12D2 62 PUSH3 0x461bcd 12D6 60 PUSH1 0xe5 12D8 1B SHL 12D9 81 DUP2 12DA 52 MSTORE 12DB 60 PUSH1 0x04 12DD 01 ADD 12DE 61 PUSH2 0x0836 12E1 90 SWAP1 12E2 61 PUSH2 0x2934 12E5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12E1 stack[0] = 0x0836 // @12E1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_12E6: // Incoming jump from 0x12CE, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12EE storage[0x08] } 12E6 5B JUMPDEST 12E7 60 PUSH1 0x00 12E9 61 PUSH2 0x12f1 12EC 60 PUSH1 0x08 12EE 54 SLOAD 12EF 90 SWAP1 12F0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12E7 stack[0] = 0x00 // @12EF stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x12f1 label_12F1: // Incoming jump from 0x12F0 // Inputs[3] // { // @12F2 stack[-2] // @12F2 stack[-1] // @12F6 stack[-4] // } 12F1 5B JUMPDEST 12F2 90 SWAP1 12F3 50 POP 12F4 60 PUSH1 0x00 12F6 83 DUP4 12F7 11 GT 12F8 61 PUSH2 0x1335 12FB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @12F2 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1335, if stack[-4] > 0x00 label_12FC: // Incoming jump from 0x12FB, if not stack[-4] > 0x00 // Inputs[1] { @12FE memory[0x40:0x60] } 12FC 60 PUSH1 0x40 12FE 51 MLOAD 12FF 62 PUSH3 0x461bcd 1303 60 PUSH1 0xe5 1305 1B SHL 1306 81 DUP2 1307 52 MSTORE 1308 60 PUSH1 0x20 130A 60 PUSH1 0x04 130C 82 DUP3 130D 01 ADD 130E 52 MSTORE 130F 60 PUSH1 0x0f 1311 60 PUSH1 0x24 1313 82 DUP3 1314 01 ADD 1315 52 MSTORE 1316 6E PUSH15 0x06d696e7420616d6f756e74203e203 1326 60 PUSH1 0x8c 1328 1B SHL 1329 60 PUSH1 0x44 132B 82 DUP3 132C 01 ADD 132D 52 MSTORE 132E 60 PUSH1 0x64 1330 01 ADD 1331 61 PUSH2 0x0836 1334 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1307 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @130E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1315 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @132D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x06d696e7420616d6f756e74203e203 << 0x8c // @1330 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_1335: // Incoming jump from 0x12FB, if stack[-4] > 0x00 // Inputs[3] // { // @1338 storage[0x0e] // @133C stack[-3] // @133D stack[-1] // } 1335 5B JUMPDEST 1336 60 PUSH1 0x0e 1338 54 SLOAD 1339 61 PUSH2 0x1342 133C 84 DUP5 133D 83 DUP4 133E 61 PUSH2 0x2a10 1341 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1338 stack[0] = storage[0x0e] // @1339 stack[1] = 0x1342 // @133C stack[2] = stack[-3] // @133D stack[3] = stack[-1] // } // Block ends with call to 0x2a10, returns to 0x1342 label_1342: // Incoming return from call to 0x2A10 at 0x1341 // Inputs[2] // { // @1343 stack[-1] // @1343 stack[-2] // } 1342 5B JUMPDEST 1343 11 GT 1344 15 ISZERO 1345 61 PUSH2 0x1389 1348 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1389, if !(stack[-1] > stack[-2]) label_1349: // Incoming jump from 0x1348, if not !(stack[-1] > stack[-2]) // Inputs[1] { @134B memory[0x40:0x60] } 1349 60 PUSH1 0x40 134B 51 MLOAD 134C 62 PUSH3 0x461bcd 1350 60 PUSH1 0xe5 1352 1B SHL 1353 81 DUP2 1354 52 MSTORE 1355 60 PUSH1 0x20 1357 60 PUSH1 0x04 1359 82 DUP3 135A 01 ADD 135B 52 MSTORE 135C 60 PUSH1 0x16 135E 60 PUSH1 0x24 1360 82 DUP3 1361 01 ADD 1362 52 MSTORE 1363 75 PUSH22 0x1b585e08139195081b1a5b5a5d08195e18d959591959 137A 60 PUSH1 0x52 137C 1B SHL 137D 60 PUSH1 0x44 137F 82 DUP3 1380 01 ADD 1381 52 MSTORE 1382 60 PUSH1 0x64 1384 01 ADD 1385 61 PUSH2 0x0836 1388 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1354 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @135B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1362 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @1381 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b585e08139195081b1a5b5a5d08195e18d959591959 << 0x52 // @1384 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_1389: // Incoming jump from 0x1348, if !(stack[-1] > stack[-2]) // Inputs[1] { @138D stack[-3] } 1389 5B JUMPDEST 138A 60 PUSH1 0x01 138C 5B JUMPDEST 138D 83 DUP4 138E 81 DUP2 138F 11 GT 1390 61 PUSH2 0x0f1c 1393 57 *JUMPI // Stack delta = +1 // Outputs[1] { @138A stack[0] = 0x01 } // Block ends with conditional jump to 0x0f1c, if 0x01 > stack[-3] label_1394: // Incoming jump from 0x1393, if not 0x01 > stack[-3] // Inputs[3] // { // @1397 stack[-3] // @139B stack[-1] // @139C stack[-2] // } 1394 61 PUSH2 0x13a1 1397 83 DUP4 1398 61 PUSH2 0x1297 139B 83 DUP4 139C 85 DUP6 139D 61 PUSH2 0x2a10 13A0 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1394 stack[0] = 0x13a1 // @1397 stack[1] = stack[-3] // @1398 stack[2] = 0x1297 // @139B stack[3] = stack[-1] // @139C stack[4] = stack[-2] // } // Block ends with call to 0x2a10, returns to 0x1297 13A1 5B JUMPDEST 13A2 80 DUP1 13A3 61 PUSH2 0x13ab 13A6 81 DUP2 13A7 61 PUSH2 0x2a47 13AA 56 *JUMP 13AB 5B JUMPDEST 13AC 91 SWAP2 13AD 50 POP 13AE 50 POP 13AF 61 PUSH2 0x138c 13B2 56 *JUMP label_13B3: // Incoming jump from 0x0632 // Inputs[1] { @13B6 storage[0x0a] } 13B3 5B JUMPDEST 13B4 60 PUSH1 0x0a 13B6 54 SLOAD 13B7 60 PUSH1 0x60 13B9 90 SWAP1 13BA 60 PUSH1 0x01 13BC 60 PUSH1 0xa8 13BE 1B SHL 13BF 90 SWAP1 13C0 04 DIV 13C1 60 PUSH1 0xff 13C3 16 AND 13C4 61 PUSH2 0x1459 13C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13B9 stack[0] = 0x60 } // Block ends with conditional jump to 0x1459, if 0xff & storage[0x0a] / (0x01 << 0xa8) label_13C8: // Incoming jump from 0x13C7, if not 0xff & storage[0x0a] / (0x01 << 0xa8) // Inputs[1] { @13CB storage[0x0b] } 13C8 60 PUSH1 0x0b 13CA 80 DUP1 13CB 54 SLOAD 13CC 61 PUSH2 0x13d4 13CF 90 SWAP1 13D0 61 PUSH2 0x28f9 13D3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13C8 stack[0] = 0x0b // @13CF stack[1] = 0x13d4 // @13CF stack[2] = storage[0x0b] // } // Block ends with call to 0x28f9, returns to 0x13D4 label_13D4: // Incoming return from call to 0x28F9 at 0x13D3 // Inputs[4] // { // @13D5 stack[-1] // @13E4 memory[0x40:0x60] // @13EC stack[-2] // @13F7 storage[stack[-2]] // } 13D4 5B JUMPDEST 13D5 80 DUP1 13D6 60 PUSH1 0x1f 13D8 01 ADD 13D9 60 PUSH1 0x20 13DB 80 DUP1 13DC 91 SWAP2 13DD 04 DIV 13DE 02 MUL 13DF 60 PUSH1 0x20 13E1 01 ADD 13E2 60 PUSH1 0x40 13E4 51 MLOAD 13E5 90 SWAP1 13E6 81 DUP2 13E7 01 ADD 13E8 60 PUSH1 0x40 13EA 52 MSTORE 13EB 80 DUP1 13EC 92 SWAP3 13ED 91 SWAP2 13EE 90 SWAP1 13EF 81 DUP2 13F0 81 DUP2 13F1 52 MSTORE 13F2 60 PUSH1 0x20 13F4 01 ADD 13F5 82 DUP3 13F6 80 DUP1 13F7 54 SLOAD 13F8 61 PUSH2 0x1400 13FB 90 SWAP1 13FC 61 PUSH2 0x28f9 13FF 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @13EA memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @13EC stack[-2] = memory[0x40:0x60] // @13ED stack[-1] = stack[-2] // @13EE stack[0] = stack[-1] // @13F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @13F4 stack[1] = 0x20 + memory[0x40:0x60] // @13F5 stack[2] = stack[-2] // @13FB stack[4] = storage[stack[-2]] // @13FB stack[3] = 0x1400 // } // Block ends with call to 0x28f9, returns to 0x1400 label_1400: // Incoming return from call to 0x28F9 at 0x13FF // Inputs[1] { @1401 stack[-1] } 1400 5B JUMPDEST 1401 80 DUP1 1402 15 ISZERO 1403 61 PUSH2 0x144d 1406 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x144d, if !stack[-1] label_1407: // Incoming jump from 0x1406, if not !stack[-1] // Inputs[1] { @1407 stack[-1] } 1407 80 DUP1 1408 60 PUSH1 0x1f 140A 10 LT 140B 61 PUSH2 0x1422 140E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1422, if 0x1f < stack[-1] label_140F: // Incoming jump from 0x140E, if not 0x1f < stack[-1] // Inputs[4] // { // @1413 stack[-2] // @1414 storage[stack[-2]] // @1417 stack[-3] // @1419 stack[-1] // } 140F 61 PUSH2 0x0100 1412 80 DUP1 1413 83 DUP4 1414 54 SLOAD 1415 04 DIV 1416 02 MUL 1417 83 DUP4 1418 52 MSTORE 1419 91 SWAP2 141A 60 PUSH1 0x20 141C 01 ADD 141D 91 SWAP2 141E 61 PUSH2 0x144d 1421 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1418 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @141D stack[-1] = stack[-1] // @141D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x144d label_1422: // Incoming jump from 0x140E, if 0x1f < stack[-1] // Inputs[5] // { // @1423 stack[-3] // @1424 stack[-1] // @1426 stack[-2] // @142E memory[0x00:0x20] // @1432 storage[keccak256(memory[0x00:0x20])] // } 1422 5B JUMPDEST 1423 82 DUP3 1424 01 ADD 1425 91 SWAP2 1426 90 SWAP1 1427 60 PUSH1 0x00 1429 52 MSTORE 142A 60 PUSH1 0x20 142C 60 PUSH1 0x00 142E 20 SHA3 142F 90 SWAP1 1430 5B JUMPDEST 1431 81 DUP2 1432 54 SLOAD 1433 81 DUP2 1434 52 MSTORE 1435 90 SWAP1 1436 60 PUSH1 0x01 1438 01 ADD 1439 90 SWAP1 143A 60 PUSH1 0x20 143C 01 ADD 143D 80 DUP1 143E 83 DUP4 143F 11 GT 1440 61 PUSH2 0x1430 1443 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1425 stack[-3] = stack[-3] + stack[-1] // @1429 memory[0x00:0x20] = stack[-2] // @1434 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1439 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @143C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1430, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1444: // Incoming jump from 0x1443, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1443, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1444 stack[-3] // @1445 stack[-1] // } 1444 82 DUP3 1445 90 SWAP1 1446 03 SUB 1447 60 PUSH1 0x1f 1449 16 AND 144A 82 DUP3 144B 01 ADD 144C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @144C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @144C stack[-1] = stack[-3] // } // Block continues label_144D: // Incoming jump from 0x1421 // Incoming jump from 0x144C // Incoming jump from 0x1406, if !stack[-1] // Inputs[4] // { // @1453 stack[-6] // @1453 stack[-7] // @1455 stack[-9] // @1456 stack[-8] // } 144D 5B JUMPDEST 144E 50 POP 144F 50 POP 1450 50 POP 1451 50 POP 1452 50 POP 1453 90 SWAP1 1454 50 POP 1455 91 SWAP2 1456 90 SWAP1 1457 50 POP 1458 56 *JUMP // Stack delta = -8 // Outputs[1] { @1455 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_1459: // Incoming jump from 0x13C7, if 0xff & storage[0x0a] / (0x01 << 0xa8) // Inputs[1] { @145F stack[-2] } 1459 5B JUMPDEST 145A 60 PUSH1 0x00 145C 61 PUSH2 0x1464 145F 83 DUP4 1460 61 PUSH2 0x1bed 1463 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @145A stack[0] = 0x00 // @145C stack[1] = 0x1464 // @145F stack[2] = stack[-2] // } // Block ends with call to 0x1bed, returns to 0x1464 label_1464: // Incoming jump from 0x28F4, if msg.data[stack[-2]:stack[-2] + 0x20] < 0x03 // Incoming return from call to 0x252F at 0x256D // Incoming return from call to 0x25C8 at 0x25F2 // Incoming return from call to 0x24D0 at 0x2502 // Incoming jump from 0x1C95 // Incoming return from call to 0x2587 at 0x275C // Incoming return from call to 0x1BED at 0x1463 // Incoming return from call to 0x1BED at 0x1463 // Inputs[3] // { // @1465 stack[-1] // @1465 stack[-5] // @1466 stack[-4] // } 1464 5B JUMPDEST 1465 93 SWAP4 1466 92 SWAP3 1467 50 POP 1468 50 POP 1469 50 POP 146A 56 *JUMP // Stack delta = -4 // Outputs[1] { @1465 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_146B: // Incoming jump from 0x2599, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x25D3, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @146C stack[-1] // @146C stack[-3] // @146D stack[-2] // } 146B 5B JUMPDEST 146C 91 SWAP2 146D 90 SWAP1 146E 50 POP 146F 56 *JUMP // Stack delta = -2 // Outputs[1] { @146C stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1470: // Incoming jump from 0x067E // Inputs[2] // { // @1473 storage[0x0a] // @1483 msg.sender // } 1470 5B JUMPDEST 1471 60 PUSH1 0x0a 1473 54 SLOAD 1474 60 PUSH1 0x01 1476 60 PUSH1 0x01 1478 60 PUSH1 0xa0 147A 1B SHL 147B 03 SUB 147C 61 PUSH2 0x0100 147F 90 SWAP1 1480 91 SWAP2 1481 04 DIV 1482 16 AND 1483 33 CALLER 1484 14 EQ 1485 61 PUSH2 0x14a0 1488 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14a0, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_1489: // Incoming jump from 0x1488, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @148B memory[0x40:0x60] } 1489 60 PUSH1 0x40 148B 51 MLOAD 148C 62 PUSH3 0x461bcd 1490 60 PUSH1 0xe5 1492 1B SHL 1493 81 DUP2 1494 52 MSTORE 1495 60 PUSH1 0x04 1497 01 ADD 1498 61 PUSH2 0x0836 149B 90 SWAP1 149C 61 PUSH2 0x2934 149F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1494 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @149B stack[0] = 0x0836 // @149B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_14A0: // Incoming jump from 0x1488, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @14A3 stack[-1] // @14A4 stack[-2] // } 14A0 5B JUMPDEST 14A1 60 PUSH1 0x12 14A3 55 SSTORE 14A4 56 *JUMP // Stack delta = -2 // Outputs[1] { @14A3 storage[0x12] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_14A5: // Incoming jump from 0x06FD // Inputs[2] // { // @14A8 storage[0x0a] // @14B8 msg.sender // } 14A5 5B JUMPDEST 14A6 60 PUSH1 0x0a 14A8 54 SLOAD 14A9 60 PUSH1 0x01 14AB 60 PUSH1 0x01 14AD 60 PUSH1 0xa0 14AF 1B SHL 14B0 03 SUB 14B1 61 PUSH2 0x0100 14B4 90 SWAP1 14B5 91 SWAP2 14B6 04 DIV 14B7 16 AND 14B8 33 CALLER 14B9 14 EQ 14BA 61 PUSH2 0x14d5 14BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14d5, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_14BE: // Incoming jump from 0x14BD, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14C0 memory[0x40:0x60] } 14BE 60 PUSH1 0x40 14C0 51 MLOAD 14C1 62 PUSH3 0x461bcd 14C5 60 PUSH1 0xe5 14C7 1B SHL 14C8 81 DUP2 14C9 52 MSTORE 14CA 60 PUSH1 0x04 14CC 01 ADD 14CD 61 PUSH2 0x0836 14D0 90 SWAP1 14D1 61 PUSH2 0x2934 14D4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14D0 stack[0] = 0x0836 // @14D0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_14D5: // Incoming jump from 0x14BD, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14DE stack[-1] } 14D5 5B JUMPDEST 14D6 60 PUSH1 0x01 14D8 60 PUSH1 0x01 14DA 60 PUSH1 0xa0 14DC 1B SHL 14DD 03 SUB 14DE 81 DUP2 14DF 16 AND 14E0 61 PUSH2 0x153a 14E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x153a, if stack[-1] & (0x01 << 0xa0) - 0x01 label_14E4: // Incoming jump from 0x14E3, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14E6 memory[0x40:0x60] } 14E4 60 PUSH1 0x40 14E6 51 MLOAD 14E7 62 PUSH3 0x461bcd 14EB 60 PUSH1 0xe5 14ED 1B SHL 14EE 81 DUP2 14EF 52 MSTORE 14F0 60 PUSH1 0x20 14F2 60 PUSH1 0x04 14F4 82 DUP3 14F5 01 ADD 14F6 52 MSTORE 14F7 60 PUSH1 0x26 14F9 60 PUSH1 0x24 14FB 82 DUP3 14FC 01 ADD 14FD 52 MSTORE 14FE 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 151F 60 PUSH1 0x44 1521 82 DUP3 1522 01 ADD 1523 52 MSTORE 1524 65 PUSH6 0x646472657373 152B 60 PUSH1 0xd0 152D 1B SHL 152E 60 PUSH1 0x64 1530 82 DUP3 1531 01 ADD 1532 52 MSTORE 1533 60 PUSH1 0x84 1535 01 ADD 1536 61 PUSH2 0x0836 1539 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @14EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14F6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14FD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1523 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1532 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1535 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_153A: // Incoming jump from 0x14E3, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @153E stack[-1] } 153A 5B JUMPDEST 153B 61 PUSH2 0x09e3 153E 81 DUP2 153F 61 PUSH2 0x1a61 1542 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @153B stack[0] = 0x09e3 // @153E stack[1] = stack[-1] // } // Block ends with call to 0x1a61, returns to 0x09E3 label_1543: // Incoming jump from 0x071D // Inputs[2] // { // @1546 storage[0x0a] // @1556 msg.sender // } 1543 5B JUMPDEST 1544 60 PUSH1 0x0a 1546 54 SLOAD 1547 60 PUSH1 0x01 1549 60 PUSH1 0x01 154B 60 PUSH1 0xa0 154D 1B SHL 154E 03 SUB 154F 61 PUSH2 0x0100 1552 90 SWAP1 1553 91 SWAP2 1554 04 DIV 1555 16 AND 1556 33 CALLER 1557 14 EQ 1558 61 PUSH2 0x1573 155B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1573, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 label_155C: // Incoming jump from 0x155B, if not msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @155E memory[0x40:0x60] } 155C 60 PUSH1 0x40 155E 51 MLOAD 155F 62 PUSH3 0x461bcd 1563 60 PUSH1 0xe5 1565 1B SHL 1566 81 DUP2 1567 52 MSTORE 1568 60 PUSH1 0x04 156A 01 ADD 156B 61 PUSH2 0x0836 156E 90 SWAP1 156F 61 PUSH2 0x2934 1572 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1567 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @156E stack[0] = 0x0836 // @156E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2934, returns to 0x0836 label_1573: // Incoming jump from 0x155B, if msg.sender == storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1577 storage[0x11] // @1578 stack[-1] // } 1573 5B JUMPDEST 1574 60 PUSH1 0x11 1576 80 DUP1 1577 54 SLOAD 1578 82 DUP3 1579 91 SWAP2 157A 90 SWAP1 157B 60 PUSH1 0xff 157D 19 NOT 157E 16 AND 157F 60 PUSH1 0x01 1581 83 DUP4 1582 60 PUSH1 0x02 1584 81 DUP2 1585 11 GT 1586 15 ISZERO 1587 61 PUSH2 0x1592 158A 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1579 stack[0] = stack[-1] // @157A stack[1] = 0x11 // @157E stack[2] = ~0xff & storage[0x11] // @157F stack[3] = 0x01 // @1581 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x1592, if !(stack[-1] > 0x02) label_158B: // Incoming jump from 0x158A, if not !(stack[-1] > 0x02) 158B 61 PUSH2 0x1592 158E 61 PUSH2 0x2704 1591 56 *JUMP // Stack delta = +1 // Outputs[1] { @158B stack[0] = 0x1592 } // Block ends with unconditional jump to 0x2704 label_1592: // Incoming jump from 0x158A, if !(stack[-1] > 0x02) // Inputs[5] // { // @1593 stack[-2] // @1593 stack[-1] // @1594 stack[-3] // @1595 stack[-4] // @1599 stack[-7] // } 1592 5B JUMPDEST 1593 02 MUL 1594 17 OR 1595 90 SWAP1 1596 55 SSTORE 1597 50 POP 1598 50 POP 1599 56 *JUMP // Stack delta = -7 // Outputs[1] { @1596 storage[stack[-4]] = stack[-1] * stack[-2] | stack[-3] } // Block ends with unconditional jump to stack[-7] label_159A: // Incoming call from 0x0728, returns to 0x0729 // Inputs[1] { @15A6 stack[-1] } 159A 5B JUMPDEST 159B 60 PUSH1 0x00 159D 60 PUSH1 0x01 159F 60 PUSH1 0x01 15A1 60 PUSH1 0xe0 15A3 1B SHL 15A4 03 SUB 15A5 19 NOT 15A6 82 DUP3 15A7 16 AND 15A8 63 PUSH4 0x780e9d63 15AD 60 PUSH1 0xe0 15AF 1B SHL 15B0 14 EQ 15B1 80 DUP1 15B2 61 PUSH2 0x0729 15B5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @159B stack[0] = 0x00 // @15B0 stack[1] = 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0729, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_15B6: // Incoming jump from 0x15B5, if not 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @15BA stack[-3] } 15B6 50 POP 15B7 61 PUSH2 0x0729 15BA 82 DUP3 15BB 61 PUSH2 0x1cc7 15BE 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @15B7 stack[-1] = 0x0729 // @15BA stack[0] = stack[-3] // } // Block ends with call to 0x1cc7, returns to 0x0729 label_15BF: // Incoming call from 0x096B, returns to 0x096C // Inputs[4] // { // @15C2 stack[-1] // @15CD memory[0x00:0x40] // @15CF storage[keccak256(memory[0x00:0x40])] // @15E2 stack[-2] // } 15BF 5B JUMPDEST 15C0 60 PUSH1 0x00 15C2 81 DUP2 15C3 81 DUP2 15C4 52 MSTORE 15C5 60 PUSH1 0x04 15C7 60 PUSH1 0x20 15C9 52 MSTORE 15CA 60 PUSH1 0x40 15CC 90 SWAP1 15CD 20 SHA3 15CE 80 DUP1 15CF 54 SLOAD 15D0 60 PUSH1 0x01 15D2 60 PUSH1 0x01 15D4 60 PUSH1 0xa0 15D6 1B SHL 15D7 03 SUB 15D8 19 NOT 15D9 16 AND 15DA 60 PUSH1 0x01 15DC 60 PUSH1 0x01 15DE 60 PUSH1 0xa0 15E0 1B SHL 15E1 03 SUB 15E2 84 DUP5 15E3 16 AND 15E4 90 SWAP1 15E5 81 DUP2 15E6 17 OR 15E7 90 SWAP1 15E8 91 SWAP2 15E9 55 SSTORE 15EA 81 DUP2 15EB 90 SWAP1 15EC 61 PUSH2 0x15f4 15EF 82 DUP3 15F0 61 PUSH2 0x0d29 15F3 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @15C4 memory[0x00:0x20] = stack[-1] // @15C9 memory[0x20:0x40] = 0x04 // @15E9 storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @15EB stack[0] = stack[-1] // @15EB stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @15EC stack[2] = 0x15f4 // @15EF stack[3] = stack[-1] // } // Block ends with call to 0x0d29, returns to 0x15F4 label_15F4: // Incoming return from call to 0x0D29 at 0x15F3 // Inputs[7] // { // @15FD stack[-1] // @1621 memory[0x40:0x60] // @1624 memory[0x40:0x60] // @1629 stack[-3] // @1629 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1629 stack[-2] // @162C stack[-6] // } 15F4 5B JUMPDEST 15F5 60 PUSH1 0x01 15F7 60 PUSH1 0x01 15F9 60 PUSH1 0xa0 15FB 1B SHL 15FC 03 SUB 15FD 16 AND 15FE 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 161F 60 PUSH1 0x40 1621 51 MLOAD 1622 60 PUSH1 0x40 1624 51 MLOAD 1625 80 DUP1 1626 91 SWAP2 1627 03 SUB 1628 90 SWAP1 1629 A4 LOG4 162A 50 POP 162B 50 POP 162C 56 *JUMP // Stack delta = -6 // Outputs[1] { @1629 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_162D: // Incoming call from 0x09E2, returns to 0x09E3 // Inputs[1] { @1630 storage[0x0a] } 162D 5B JUMPDEST 162E 60 PUSH1 0x0a 1630 54 SLOAD 1631 60 PUSH1 0xff 1633 16 AND 1634 61 PUSH2 0x1676 1637 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1676, if 0xff & storage[0x0a] label_1638: // Incoming jump from 0x1637, if not 0xff & storage[0x0a] // Inputs[1] { @163A memory[0x40:0x60] } 1638 60 PUSH1 0x40 163A 51 MLOAD 163B 62 PUSH3 0x461bcd 163F 60 PUSH1 0xe5 1641 1B SHL 1642 81 DUP2 1643 52 MSTORE 1644 60 PUSH1 0x20 1646 60 PUSH1 0x04 1648 82 DUP3 1649 01 ADD 164A 52 MSTORE 164B 60 PUSH1 0x14 164D 60 PUSH1 0x24 164F 82 DUP3 1650 01 ADD 1651 52 MSTORE 1652 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 1667 60 PUSH1 0x62 1669 1B SHL 166A 60 PUSH1 0x44 166C 82 DUP3 166D 01 ADD 166E 52 MSTORE 166F 60 PUSH1 0x64 1671 01 ADD 1672 61 PUSH2 0x0836 1675 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1643 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @164A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1651 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @166E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881b9bdd081c185d5cd959 << 0x62 // @1671 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_1676: // Incoming jump from 0x1637, if 0xff & storage[0x0a] // Inputs[6] // { // @167A storage[0x0a] // @16A2 msg.sender // @16A6 memory[0x40:0x60] // @16B9 memory[0x40:0x60] // @16BE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @16BF stack[-1] // } 1676 5B JUMPDEST 1677 60 PUSH1 0x0a 1679 80 DUP1 167A 54 SLOAD 167B 60 PUSH1 0xff 167D 19 NOT 167E 16 AND 167F 90 SWAP1 1680 55 SSTORE 1681 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 16A2 33 CALLER 16A3 5B JUMPDEST 16A4 60 PUSH1 0x40 16A6 51 MLOAD 16A7 60 PUSH1 0x01 16A9 60 PUSH1 0x01 16AB 60 PUSH1 0xa0 16AD 1B SHL 16AE 03 SUB 16AF 90 SWAP1 16B0 91 SWAP2 16B1 16 AND 16B2 81 DUP2 16B3 52 MSTORE 16B4 60 PUSH1 0x20 16B6 01 ADD 16B7 60 PUSH1 0x40 16B9 51 MLOAD 16BA 80 DUP1 16BB 91 SWAP2 16BC 03 SUB 16BD 90 SWAP1 16BE A1 LOG1 16BF 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1680 storage[0x0a] = ~0xff & storage[0x0a] // @16B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender & (0x01 << 0xa0) - 0x01 // @16BE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa]); // } // Block ends with unconditional jump to stack[-1] label_16C0: // Incoming call from 0x09ED, returns to 0x09E3 // Inputs[1] { @16C3 storage[0x0a] } 16C0 5B JUMPDEST 16C1 60 PUSH1 0x0a 16C3 54 SLOAD 16C4 60 PUSH1 0xff 16C6 16 AND 16C7 15 ISZERO 16C8 61 PUSH2 0x16e3 16CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16e3, if !(0xff & storage[0x0a]) label_16CC: // Incoming jump from 0x16CB, if not !(0xff & storage[0x0a]) // Inputs[1] { @16CE memory[0x40:0x60] } 16CC 60 PUSH1 0x40 16CE 51 MLOAD 16CF 62 PUSH3 0x461bcd 16D3 60 PUSH1 0xe5 16D5 1B SHL 16D6 81 DUP2 16D7 52 MSTORE 16D8 60 PUSH1 0x04 16DA 01 ADD 16DB 61 PUSH2 0x0836 16DE 90 SWAP1 16DF 61 PUSH2 0x29d0 16E2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16DE stack[0] = 0x0836 // @16DE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29d0, returns to 0x0836 label_16E3: // Incoming jump from 0x16CB, if !(0xff & storage[0x0a]) // Inputs[2] // { // @16E7 storage[0x0a] // @1715 msg.sender // } 16E3 5B JUMPDEST 16E4 60 PUSH1 0x0a 16E6 80 DUP1 16E7 54 SLOAD 16E8 60 PUSH1 0xff 16EA 19 NOT 16EB 16 AND 16EC 60 PUSH1 0x01 16EE 17 OR 16EF 90 SWAP1 16F0 55 SSTORE 16F1 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 1712 61 PUSH2 0x16a3 1715 33 CALLER 1716 90 SWAP1 1717 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16F0 storage[0x0a] = 0x01 | (~0xff & storage[0x0a]) // @16F1 stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @1716 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x16a3 label_1718: // Incoming jump from 0x09F8 // Incoming call from 0x0EF3, returns to 0x0EF4 // Inputs[3] // { // @171B stack[-1] // @1726 memory[0x00:0x40] // @1727 storage[keccak256(memory[0x00:0x40])] // } 1718 5B JUMPDEST 1719 60 PUSH1 0x00 171B 81 DUP2 171C 81 DUP2 171D 52 MSTORE 171E 60 PUSH1 0x02 1720 60 PUSH1 0x20 1722 52 MSTORE 1723 60 PUSH1 0x40 1725 81 DUP2 1726 20 SHA3 1727 54 SLOAD 1728 60 PUSH1 0x01 172A 60 PUSH1 0x01 172C 60 PUSH1 0xa0 172E 1B SHL 172F 03 SUB 1730 16 AND 1731 61 PUSH2 0x1791 1734 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1719 stack[0] = 0x00 // @171D memory[0x00:0x20] = stack[-1] // @1722 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x1791, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1735: // Incoming jump from 0x1734, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1737 memory[0x40:0x60] } 1735 60 PUSH1 0x40 1737 51 MLOAD 1738 62 PUSH3 0x461bcd 173C 60 PUSH1 0xe5 173E 1B SHL 173F 81 DUP2 1740 52 MSTORE 1741 60 PUSH1 0x20 1743 60 PUSH1 0x04 1745 82 DUP3 1746 01 ADD 1747 52 MSTORE 1748 60 PUSH1 0x2c 174A 60 PUSH1 0x24 174C 82 DUP3 174D 01 ADD 174E 52 MSTORE 174F 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 1770 60 PUSH1 0x44 1772 82 DUP3 1773 01 ADD 1774 52 MSTORE 1775 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 1782 60 PUSH1 0xa1 1784 1B SHL 1785 60 PUSH1 0x64 1787 82 DUP3 1788 01 ADD 1789 52 MSTORE 178A 60 PUSH1 0x84 178C 01 ADD 178D 61 PUSH2 0x0836 1790 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1740 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1747 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @174E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @1774 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @1789 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @178C stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_1791: // Incoming jump from 0x1734, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1797 stack[-2] } 1791 5B JUMPDEST 1792 60 PUSH1 0x00 1794 61 PUSH2 0x179c 1797 83 DUP4 1798 61 PUSH2 0x0d29 179B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1792 stack[0] = 0x00 // @1794 stack[1] = 0x179c // @1797 stack[2] = stack[-2] // } // Block ends with call to 0x0d29, returns to 0x179C label_179C: // Incoming return from call to 0x0D29 at 0x179B // Inputs[3] // { // @179D stack[-1] // @179D stack[-2] // @17A9 stack[-5] // } 179C 5B JUMPDEST 179D 90 SWAP1 179E 50 POP 179F 80 DUP1 17A0 60 PUSH1 0x01 17A2 60 PUSH1 0x01 17A4 60 PUSH1 0xa0 17A6 1B SHL 17A7 03 SUB 17A8 16 AND 17A9 84 DUP5 17AA 60 PUSH1 0x01 17AC 60 PUSH1 0x01 17AE 60 PUSH1 0xa0 17B0 1B SHL 17B1 03 SUB 17B2 16 AND 17B3 14 EQ 17B4 80 DUP1 17B5 61 PUSH2 0x17d7 17B8 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @179D stack[-2] = stack[-1] // @17B3 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x17d7, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_17B9: // Incoming jump from 0x17B8, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @17BA stack[-5] // @17C7 stack[-4] // } 17B9 50 POP 17BA 83 DUP4 17BB 60 PUSH1 0x01 17BD 60 PUSH1 0x01 17BF 60 PUSH1 0xa0 17C1 1B SHL 17C2 03 SUB 17C3 16 AND 17C4 61 PUSH2 0x17cc 17C7 84 DUP5 17C8 61 PUSH2 0x07c1 17CB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17C3 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @17C4 stack[0] = 0x17cc // @17C7 stack[1] = stack[-4] // } // Block ends with call to 0x07c1, returns to 0x17CC label_17CC: // Incoming return from call to 0x07C1 at 0x17CB // Inputs[2] // { // @17D5 stack[-1] // @17D6 stack[-2] // } 17CC 5B JUMPDEST 17CD 60 PUSH1 0x01 17CF 60 PUSH1 0x01 17D1 60 PUSH1 0xa0 17D3 1B SHL 17D4 03 SUB 17D5 16 AND 17D6 14 EQ // Stack delta = -1 // Outputs[1] { @17D6 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_17D7: // Incoming jump from 0x17B8, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x17D6 // Inputs[1] { @17D8 stack[-1] } 17D7 5B JUMPDEST 17D8 80 DUP1 17D9 61 PUSH2 0x1807 17DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1807, if stack[-1] label_17DD: // Incoming jump from 0x17DC, if not stack[-1] // Inputs[5] // { // @17E7 stack[-2] // @17F9 memory[0x00:0x40] // @17FB stack[-5] // @1802 memory[0x00:0x40] // @1803 storage[keccak256(memory[0x00:0x40])] // } 17DD 50 POP 17DE 60 PUSH1 0x01 17E0 60 PUSH1 0x01 17E2 60 PUSH1 0xa0 17E4 1B SHL 17E5 03 SUB 17E6 80 DUP1 17E7 82 DUP3 17E8 16 AND 17E9 60 PUSH1 0x00 17EB 90 SWAP1 17EC 81 DUP2 17ED 52 MSTORE 17EE 60 PUSH1 0x05 17F0 60 PUSH1 0x20 17F2 90 SWAP1 17F3 81 DUP2 17F4 52 MSTORE 17F5 60 PUSH1 0x40 17F7 80 DUP1 17F8 83 DUP4 17F9 20 SHA3 17FA 93 SWAP4 17FB 88 DUP9 17FC 16 AND 17FD 83 DUP4 17FE 52 MSTORE 17FF 92 SWAP3 1800 90 SWAP1 1801 52 MSTORE 1802 20 SHA3 1803 54 SLOAD 1804 60 PUSH1 0xff 1806 16 AND // Stack delta = +0 // Outputs[5] // { // @17ED memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @17F4 memory[0x20:0x40] = 0x05 // @17FE memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1801 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1806 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_1807: // Incoming jump from 0x1FCE, if !stack[-5] // Incoming jump from 0x1806 // Incoming jump from 0x1FCE, if !stack[-7] // Incoming return from call to 0x2645 at 0x2703 // Incoming jump from 0x17DC, if stack[-1] // Incoming jump from 0x1FCE, if !stack[-7] // Inputs[3] // { // @1808 stack[-1] // @1808 stack[-6] // @1809 stack[-5] // } 1807 5B JUMPDEST 1808 94 SWAP5 1809 93 SWAP4 180A 50 POP 180B 50 POP 180C 50 POP 180D 50 POP 180E 56 *JUMP // Stack delta = -5 // Outputs[1] { @1808 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_180F: // Incoming jump from 0x1B94 // Inputs[2] // { // @1810 stack[-3] // @181D stack[-1] // } 180F 5B JUMPDEST 1810 82 DUP3 1811 60 PUSH1 0x01 1813 60 PUSH1 0x01 1815 60 PUSH1 0xa0 1817 1B SHL 1818 03 SUB 1819 16 AND 181A 61 PUSH2 0x1822 181D 82 DUP3 181E 61 PUSH2 0x0d29 1821 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1819 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @181A stack[1] = 0x1822 // @181D stack[2] = stack[-1] // } // Block ends with call to 0x0d29, returns to 0x1822 label_1822: // Incoming return from call to 0x0D29 at 0x1821 // Inputs[2] // { // @182B stack[-1] // @182C stack[-2] // } 1822 5B JUMPDEST 1823 60 PUSH1 0x01 1825 60 PUSH1 0x01 1827 60 PUSH1 0xa0 1829 1B SHL 182A 03 SUB 182B 16 AND 182C 14 EQ 182D 61 PUSH2 0x188a 1830 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x188a, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1831: // Incoming jump from 0x1830, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1833 memory[0x40:0x60] } 1831 60 PUSH1 0x40 1833 51 MLOAD 1834 62 PUSH3 0x461bcd 1838 60 PUSH1 0xe5 183A 1B SHL 183B 81 DUP2 183C 52 MSTORE 183D 60 PUSH1 0x20 183F 60 PUSH1 0x04 1841 82 DUP3 1842 01 ADD 1843 52 MSTORE 1844 60 PUSH1 0x29 1846 60 PUSH1 0x24 1848 82 DUP3 1849 01 ADD 184A 52 MSTORE 184B 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 186C 60 PUSH1 0x44 186E 82 DUP3 186F 01 ADD 1870 52 MSTORE 1871 68 PUSH9 0x39903737ba1037bbb7 187B 60 PUSH1 0xb9 187D 1B SHL 187E 60 PUSH1 0x64 1880 82 DUP3 1881 01 ADD 1882 52 MSTORE 1883 60 PUSH1 0x84 1885 01 ADD 1886 61 PUSH2 0x0836 1889 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @183C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1843 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @184A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @1870 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 // @1882 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39903737ba1037bbb7 << 0xb9 // @1885 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_188A: // Incoming jump from 0x1830, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1893 stack[-2] } 188A 5B JUMPDEST 188B 60 PUSH1 0x01 188D 60 PUSH1 0x01 188F 60 PUSH1 0xa0 1891 1B SHL 1892 03 SUB 1893 82 DUP3 1894 16 AND 1895 61 PUSH2 0x18ec 1898 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18ec, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1899: // Incoming jump from 0x1898, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @189B memory[0x40:0x60] } 1899 60 PUSH1 0x40 189B 51 MLOAD 189C 62 PUSH3 0x461bcd 18A0 60 PUSH1 0xe5 18A2 1B SHL 18A3 81 DUP2 18A4 52 MSTORE 18A5 60 PUSH1 0x20 18A7 60 PUSH1 0x04 18A9 82 DUP3 18AA 01 ADD 18AB 52 MSTORE 18AC 60 PUSH1 0x24 18AE 80 DUP1 18AF 82 DUP3 18B0 01 ADD 18B1 52 MSTORE 18B2 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 18D3 60 PUSH1 0x44 18D5 82 DUP3 18D6 01 ADD 18D7 52 MSTORE 18D8 63 PUSH4 0x72657373 18DD 60 PUSH1 0xe0 18DF 1B SHL 18E0 60 PUSH1 0x64 18E2 82 DUP3 18E3 01 ADD 18E4 52 MSTORE 18E5 60 PUSH1 0x84 18E7 01 ADD 18E8 61 PUSH2 0x0836 18EB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @18A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18AB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18B1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @18D7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @18E4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72657373 << 0xe0 // @18E7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_18EC: // Incoming jump from 0x1898, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @18F0 stack[-3] // @18F1 stack[-2] // @18F2 stack[-1] // } 18EC 5B JUMPDEST 18ED 61 PUSH2 0x18f7 18F0 83 DUP4 18F1 83 DUP4 18F2 83 DUP4 18F3 61 PUSH2 0x1d17 18F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18ED stack[0] = 0x18f7 // @18F0 stack[1] = stack[-3] // @18F1 stack[2] = stack[-2] // @18F2 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1d17 18F7 5B JUMPDEST 18F8 61 PUSH2 0x1902 18FB 60 PUSH1 0x00 18FD 82 DUP3 18FE 61 PUSH2 0x15bf 1901 56 *JUMP 1902 5B JUMPDEST 1903 60 PUSH1 0x01 1905 60 PUSH1 0x01 1907 60 PUSH1 0xa0 1909 1B SHL 190A 03 SUB 190B 83 DUP4 190C 16 AND 190D 60 PUSH1 0x00 190F 90 SWAP1 1910 81 DUP2 1911 52 MSTORE 1912 60 PUSH1 0x03 1914 60 PUSH1 0x20 1916 52 MSTORE 1917 60 PUSH1 0x40 1919 81 DUP2 191A 20 SHA3 191B 80 DUP1 191C 54 SLOAD 191D 60 PUSH1 0x01 191F 92 SWAP3 1920 90 SWAP1 1921 61 PUSH2 0x192b 1924 90 SWAP1 1925 84 DUP5 1926 90 SWAP1 1927 61 PUSH2 0x2a62 192A 56 *JUMP 192B 5B JUMPDEST 192C 90 SWAP1 192D 91 SWAP2 192E 55 SSTORE 192F 50 POP 1930 50 POP 1931 60 PUSH1 0x01 1933 60 PUSH1 0x01 1935 60 PUSH1 0xa0 1937 1B SHL 1938 03 SUB 1939 82 DUP3 193A 16 AND 193B 60 PUSH1 0x00 193D 90 SWAP1 193E 81 DUP2 193F 52 MSTORE 1940 60 PUSH1 0x03 1942 60 PUSH1 0x20 1944 52 MSTORE 1945 60 PUSH1 0x40 1947 81 DUP2 1948 20 SHA3 1949 80 DUP1 194A 54 SLOAD 194B 60 PUSH1 0x01 194D 92 SWAP3 194E 90 SWAP1 194F 61 PUSH2 0x1959 1952 90 SWAP1 1953 84 DUP5 1954 90 SWAP1 1955 61 PUSH2 0x2a10 1958 56 *JUMP 1959 5B JUMPDEST 195A 90 SWAP1 195B 91 SWAP2 195C 55 SSTORE 195D 50 POP 195E 50 POP 195F 60 PUSH1 0x00 1961 81 DUP2 1962 81 DUP2 1963 52 MSTORE 1964 60 PUSH1 0x02 1966 60 PUSH1 0x20 1968 52 MSTORE 1969 60 PUSH1 0x40 196B 80 DUP1 196C 82 DUP3 196D 20 SHA3 196E 80 DUP1 196F 54 SLOAD 1970 60 PUSH1 0x01 1972 60 PUSH1 0x01 1974 60 PUSH1 0xa0 1976 1B SHL 1977 03 SUB 1978 19 NOT 1979 16 AND 197A 60 PUSH1 0x01 197C 60 PUSH1 0x01 197E 60 PUSH1 0xa0 1980 1B SHL 1981 03 SUB 1982 86 DUP7 1983 81 DUP2 1984 16 AND 1985 91 SWAP2 1986 82 DUP3 1987 17 OR 1988 90 SWAP1 1989 92 SWAP3 198A 55 SSTORE 198B 91 SWAP2 198C 51 MLOAD 198D 84 DUP5 198E 93 SWAP4 198F 91 SWAP2 1990 87 DUP8 1991 16 AND 1992 91 SWAP2 1993 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 19B4 91 SWAP2 19B5 A4 LOG4 19B6 50 POP 19B7 50 POP 19B8 50 POP 19B9 56 *JUMP label_19BA: // Incoming jump from 0x0C4E // Inputs[1] { @19C0 stack[-1] } 19BA 5B JUMPDEST 19BB 60 PUSH1 0x00 19BD 61 PUSH2 0x19c5 19C0 82 DUP3 19C1 61 PUSH2 0x0d29 19C4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19BB stack[0] = 0x00 // @19BD stack[1] = 0x19c5 // @19C0 stack[2] = stack[-1] // } // Block ends with call to 0x0d29, returns to 0x19C5 label_19C5: // Incoming return from call to 0x0D29 at 0x19C4 // Inputs[3] // { // @19C6 stack[-2] // @19C6 stack[-1] // @19CE stack[-3] // } 19C5 5B JUMPDEST 19C6 90 SWAP1 19C7 50 POP 19C8 61 PUSH2 0x19d3 19CB 81 DUP2 19CC 60 PUSH1 0x00 19CE 84 DUP5 19CF 61 PUSH2 0x1d17 19D2 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @19C6 stack[-2] = stack[-1] // @19C8 stack[-1] = 0x19d3 // @19CB stack[0] = stack[-1] // @19CC stack[1] = 0x00 // @19CE stack[2] = stack[-3] // } // Block ends with unconditional jump to 0x1d17 19D3 5B JUMPDEST 19D4 61 PUSH2 0x19de 19D7 60 PUSH1 0x00 19D9 83 DUP4 19DA 61 PUSH2 0x15bf 19DD 56 *JUMP 19DE 5B JUMPDEST 19DF 60 PUSH1 0x01 19E1 60 PUSH1 0x01 19E3 60 PUSH1 0xa0 19E5 1B SHL 19E6 03 SUB 19E7 81 DUP2 19E8 16 AND 19E9 60 PUSH1 0x00 19EB 90 SWAP1 19EC 81 DUP2 19ED 52 MSTORE 19EE 60 PUSH1 0x03 19F0 60 PUSH1 0x20 19F2 52 MSTORE 19F3 60 PUSH1 0x40 19F5 81 DUP2 19F6 20 SHA3 19F7 80 DUP1 19F8 54 SLOAD 19F9 60 PUSH1 0x01 19FB 92 SWAP3 19FC 90 SWAP1 19FD 61 PUSH2 0x1a07 1A00 90 SWAP1 1A01 84 DUP5 1A02 90 SWAP1 1A03 61 PUSH2 0x2a62 1A06 56 *JUMP 1A07 5B JUMPDEST 1A08 90 SWAP1 1A09 91 SWAP2 1A0A 55 SSTORE 1A0B 50 POP 1A0C 50 POP 1A0D 60 PUSH1 0x00 1A0F 82 DUP3 1A10 81 DUP2 1A11 52 MSTORE 1A12 60 PUSH1 0x02 1A14 60 PUSH1 0x20 1A16 52 MSTORE 1A17 60 PUSH1 0x40 1A19 80 DUP1 1A1A 82 DUP3 1A1B 20 SHA3 1A1C 80 DUP1 1A1D 54 SLOAD 1A1E 60 PUSH1 0x01 1A20 60 PUSH1 0x01 1A22 60 PUSH1 0xa0 1A24 1B SHL 1A25 03 SUB 1A26 19 NOT 1A27 16 AND 1A28 90 SWAP1 1A29 55 SSTORE 1A2A 51 MLOAD 1A2B 83 DUP4 1A2C 91 SWAP2 1A2D 90 SWAP1 1A2E 60 PUSH1 0x01 1A30 60 PUSH1 0x01 1A32 60 PUSH1 0xa0 1A34 1B SHL 1A35 03 SUB 1A36 84 DUP5 1A37 16 AND 1A38 90 SWAP1 1A39 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1A5A 90 SWAP1 1A5B 83 DUP4 1A5C 90 SWAP1 1A5D A4 LOG4 1A5E 50 POP 1A5F 50 POP 1A60 56 *JUMP label_1A61: // Incoming call from 0x1542, returns to 0x09E3 // Incoming call from 0x0ECD, returns to 0x0ECE // Inputs[5] // { // @1A65 storage[0x0a] // @1A6E stack[-1] // @1A89 memory[0x40:0x60] // @1AB7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1ABA stack[-2] // } 1A61 5B JUMPDEST 1A62 60 PUSH1 0x0a 1A64 80 DUP1 1A65 54 SLOAD 1A66 60 PUSH1 0x01 1A68 60 PUSH1 0x01 1A6A 60 PUSH1 0xa0 1A6C 1B SHL 1A6D 03 SUB 1A6E 83 DUP4 1A6F 81 DUP2 1A70 16 AND 1A71 61 PUSH2 0x0100 1A74 81 DUP2 1A75 81 DUP2 1A76 02 MUL 1A77 61 PUSH2 0x0100 1A7A 60 PUSH1 0x01 1A7C 60 PUSH1 0xa8 1A7E 1B SHL 1A7F 03 SUB 1A80 19 NOT 1A81 85 DUP6 1A82 16 AND 1A83 17 OR 1A84 90 SWAP1 1A85 94 SWAP5 1A86 55 SSTORE 1A87 60 PUSH1 0x40 1A89 51 MLOAD 1A8A 93 SWAP4 1A8B 90 SWAP1 1A8C 92 SWAP3 1A8D 04 DIV 1A8E 16 AND 1A8F 91 SWAP2 1A90 82 DUP3 1A91 90 SWAP1 1A92 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1AB3 90 SWAP1 1AB4 60 PUSH1 0x00 1AB6 90 SWAP1 1AB7 A3 LOG3 1AB8 50 POP 1AB9 50 POP 1ABA 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1A86 storage[0x0a] = (storage[0x0a] & ~((0x01 << 0xa8) - 0x0100)) | 0x0100 * (stack[-1] & (0x01 << 0xa0) - 0x01) // @1AB7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0a] / 0x0100 & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 1ABB 5B JUMPDEST 1ABC 81 DUP2 1ABD 60 PUSH1 0x01 1ABF 60 PUSH1 0x01 1AC1 60 PUSH1 0xa0 1AC3 1B SHL 1AC4 03 SUB 1AC5 16 AND 1AC6 83 DUP4 1AC7 60 PUSH1 0x01 1AC9 60 PUSH1 0x01 1ACB 60 PUSH1 0xa0 1ACD 1B SHL 1ACE 03 SUB 1ACF 16 AND 1AD0 14 EQ 1AD1 15 ISZERO 1AD2 61 PUSH2 0x1b1d 1AD5 57 *JUMPI 1AD6 60 PUSH1 0x40 1AD8 51 MLOAD 1AD9 62 PUSH3 0x461bcd 1ADD 60 PUSH1 0xe5 1ADF 1B SHL 1AE0 81 DUP2 1AE1 52 MSTORE 1AE2 60 PUSH1 0x20 1AE4 60 PUSH1 0x04 1AE6 82 DUP3 1AE7 01 ADD 1AE8 52 MSTORE 1AE9 60 PUSH1 0x19 1AEB 60 PUSH1 0x24 1AED 82 DUP3 1AEE 01 ADD 1AEF 52 MSTORE 1AF0 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 1B11 60 PUSH1 0x44 1B13 82 DUP3 1B14 01 ADD 1B15 52 MSTORE 1B16 60 PUSH1 0x64 1B18 01 ADD 1B19 61 PUSH2 0x0836 1B1C 56 *JUMP 1B1D 5B JUMPDEST 1B1E 60 PUSH1 0x01 1B20 60 PUSH1 0x01 1B22 60 PUSH1 0xa0 1B24 1B SHL 1B25 03 SUB 1B26 83 DUP4 1B27 81 DUP2 1B28 16 AND 1B29 60 PUSH1 0x00 1B2B 81 DUP2 1B2C 81 DUP2 1B2D 52 MSTORE 1B2E 60 PUSH1 0x05 1B30 60 PUSH1 0x20 1B32 90 SWAP1 1B33 81 DUP2 1B34 52 MSTORE 1B35 60 PUSH1 0x40 1B37 80 DUP1 1B38 83 DUP4 1B39 20 SHA3 1B3A 94 SWAP5 1B3B 87 DUP8 1B3C 16 AND 1B3D 80 DUP1 1B3E 84 DUP5 1B3F 52 MSTORE 1B40 94 SWAP5 1B41 82 DUP3 1B42 52 MSTORE 1B43 91 SWAP2 1B44 82 DUP3 1B45 90 SWAP1 1B46 20 SHA3 1B47 80 DUP1 1B48 54 SLOAD 1B49 60 PUSH1 0xff 1B4B 19 NOT 1B4C 16 AND 1B4D 86 DUP7 1B4E 15 ISZERO 1B4F 15 ISZERO 1B50 90 SWAP1 1B51 81 DUP2 1B52 17 OR 1B53 90 SWAP1 1B54 91 SWAP2 1B55 55 SSTORE 1B56 91 SWAP2 1B57 51 MLOAD 1B58 91 SWAP2 1B59 82 DUP3 1B5A 52 MSTORE 1B5B 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1B7C 91 SWAP2 1B7D 01 ADD 1B7E 60 PUSH1 0x40 1B80 51 MLOAD 1B81 80 DUP1 1B82 91 SWAP2 1B83 03 SUB 1B84 90 SWAP1 1B85 A3 LOG3 1B86 50 POP 1B87 50 POP 1B88 50 POP 1B89 56 *JUMP label_1B8A: // Incoming jump from 0x0F1B // Inputs[3] // { // @1B8E stack[-4] // @1B8F stack[-3] // @1B90 stack[-2] // } 1B8A 5B JUMPDEST 1B8B 61 PUSH2 0x1b95 1B8E 84 DUP5 1B8F 84 DUP5 1B90 84 DUP5 1B91 61 PUSH2 0x180f 1B94 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B8B stack[0] = 0x1b95 // @1B8E stack[1] = stack[-4] // @1B8F stack[2] = stack[-3] // @1B90 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x180f 1B95 5B JUMPDEST 1B96 61 PUSH2 0x1ba1 1B99 84 DUP5 1B9A 84 DUP5 1B9B 84 DUP5 1B9C 84 DUP5 1B9D 61 PUSH2 0x1d45 1BA0 56 *JUMP 1BA1 5B JUMPDEST 1BA2 61 PUSH2 0x0f1c 1BA5 57 *JUMPI 1BA6 60 PUSH1 0x40 1BA8 51 MLOAD 1BA9 62 PUSH3 0x461bcd 1BAD 60 PUSH1 0xe5 1BAF 1B SHL 1BB0 81 DUP2 1BB1 52 MSTORE 1BB2 60 PUSH1 0x04 1BB4 01 ADD 1BB5 61 PUSH2 0x0836 1BB8 90 SWAP1 1BB9 61 PUSH2 0x2a79 1BBC 56 *JUMP label_1BBD: // Incoming call from 0x1188, returns to 0x1189 // Inputs[3] // { // @1BC0 stack[-2] // @1BC4 stack[-3] // @1BC5 stack[-1] // } 1BBD 5B JUMPDEST 1BBE 60 PUSH1 0x00 1BC0 82 DUP3 1BC1 61 PUSH2 0x1bca 1BC4 85 DUP6 1BC5 84 DUP5 1BC6 61 PUSH2 0x1e43 1BC9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1BBE stack[0] = 0x00 // @1BC0 stack[1] = stack[-2] // @1BC1 stack[2] = 0x1bca // @1BC4 stack[3] = stack[-3] // @1BC5 stack[4] = stack[-1] // } // Block ends with call to 0x1e43, returns to 0x1BCA label_1BCA: // Incoming return from call to 0x1E43 at 0x1BC9 // Inputs[4] // { // @1BCB stack[-2] // @1BCB stack[-1] // @1BCC stack[-7] // @1BCD stack[-6] // } 1BCA 5B JUMPDEST 1BCB 14 EQ 1BCC 94 SWAP5 1BCD 93 SWAP4 1BCE 50 POP 1BCF 50 POP 1BD0 50 POP 1BD1 50 POP 1BD2 56 *JUMP // Stack delta = -6 // Outputs[1] { @1BCC stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1BD3: // Incoming jump from 0x129B // Inputs[3] // { // @1BD7 stack[-2] // @1BD8 stack[-1] // @1BDB memory[0x40:0x60] // } 1BD3 5B JUMPDEST 1BD4 61 PUSH2 0x0d25 1BD7 82 DUP3 1BD8 82 DUP3 1BD9 60 PUSH1 0x40 1BDB 51 MLOAD 1BDC 80 DUP1 1BDD 60 PUSH1 0x20 1BDF 01 ADD 1BE0 60 PUSH1 0x40 1BE2 52 MSTORE 1BE3 80 DUP1 1BE4 60 PUSH1 0x00 1BE6 81 DUP2 1BE7 52 MSTORE 1BE8 50 POP 1BE9 61 PUSH2 0x1eef 1BEC 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1BD4 stack[0] = 0x0d25 // @1BD7 stack[1] = stack[-2] // @1BD8 stack[2] = stack[-1] // @1BDB stack[3] = memory[0x40:0x60] // @1BE2 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1BE7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1eef label_1BED: // Incoming call from 0x1463, returns to 0x1464 // Inputs[3] // { // @1BF0 stack[-1] // @1BFB memory[0x00:0x40] // @1BFC storage[keccak256(memory[0x00:0x40])] // } 1BED 5B JUMPDEST 1BEE 60 PUSH1 0x00 1BF0 81 DUP2 1BF1 81 DUP2 1BF2 52 MSTORE 1BF3 60 PUSH1 0x02 1BF5 60 PUSH1 0x20 1BF7 52 MSTORE 1BF8 60 PUSH1 0x40 1BFA 90 SWAP1 1BFB 20 SHA3 1BFC 54 SLOAD 1BFD 60 PUSH1 0x60 1BFF 90 SWAP1 1C00 60 PUSH1 0x01 1C02 60 PUSH1 0x01 1C04 60 PUSH1 0xa0 1C06 1B SHL 1C07 03 SUB 1C08 16 AND 1C09 61 PUSH2 0x1c6c 1C0C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1BF2 memory[0x00:0x20] = stack[-1] // @1BF7 memory[0x20:0x40] = 0x02 // @1BFF stack[0] = 0x60 // } // Block ends with conditional jump to 0x1c6c, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1C0D: // Incoming jump from 0x1C0C, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1C0F memory[0x40:0x60] } 1C0D 60 PUSH1 0x40 1C0F 51 MLOAD 1C10 62 PUSH3 0x461bcd 1C14 60 PUSH1 0xe5 1C16 1B SHL 1C17 81 DUP2 1C18 52 MSTORE 1C19 60 PUSH1 0x20 1C1B 60 PUSH1 0x04 1C1D 82 DUP3 1C1E 01 ADD 1C1F 52 MSTORE 1C20 60 PUSH1 0x2f 1C22 60 PUSH1 0x24 1C24 82 DUP3 1C25 01 ADD 1C26 52 MSTORE 1C27 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 1C48 60 PUSH1 0x44 1C4A 82 DUP3 1C4B 01 ADD 1C4C 52 MSTORE 1C4D 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 1C5D 60 PUSH1 0x89 1C5F 1B SHL 1C60 60 PUSH1 0x64 1C62 82 DUP3 1C63 01 ADD 1C64 52 MSTORE 1C65 60 PUSH1 0x84 1C67 01 ADD 1C68 61 PUSH2 0x0836 1C6B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1C18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1C1F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1C26 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @1C4C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @1C64 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @1C67 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_1C6C: // Incoming jump from 0x1C0C, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] 1C6C 5B JUMPDEST 1C6D 60 PUSH1 0x00 1C6F 61 PUSH2 0x1c76 1C72 61 PUSH2 0x1f22 1C75 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C6D stack[0] = 0x00 // @1C6F stack[1] = 0x1c76 // } // Block ends with call to 0x1f22, returns to 0x1C76 label_1C76: // Incoming return from call to 0x1F22 at 0x1C75 // Inputs[3] // { // @1C77 stack[-2] // @1C77 stack[-1] // @1C7C memory[stack[-1]:stack[-1] + 0x20] // } 1C76 5B JUMPDEST 1C77 90 SWAP1 1C78 50 POP 1C79 60 PUSH1 0x00 1C7B 81 DUP2 1C7C 51 MLOAD 1C7D 11 GT 1C7E 61 PUSH2 0x1c96 1C81 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1C77 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1c96, if memory[stack[-1]:stack[-1] + 0x20] > 0x00 label_1C82: // Incoming jump from 0x1C81, if not memory[stack[-1]:stack[-1] + 0x20] > 0x00 // Inputs[1] { @1C84 memory[0x40:0x60] } 1C82 60 PUSH1 0x40 1C84 51 MLOAD 1C85 80 DUP1 1C86 60 PUSH1 0x20 1C88 01 ADD 1C89 60 PUSH1 0x40 1C8B 52 MSTORE 1C8C 80 DUP1 1C8D 60 PUSH1 0x00 1C8F 81 DUP2 1C90 52 MSTORE 1C91 50 POP 1C92 61 PUSH2 0x1464 1C95 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1C84 stack[0] = memory[0x40:0x60] // @1C8B memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1C90 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1464 label_1C96: // Incoming jump from 0x1C81, if memory[stack[-1]:stack[-1] + 0x20] > 0x00 // Inputs[2] // { // @1C97 stack[-1] // @1C9B stack[-3] // } 1C96 5B JUMPDEST 1C97 80 DUP1 1C98 61 PUSH2 0x1ca0 1C9B 84 DUP5 1C9C 61 PUSH2 0x1f31 1C9F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C97 stack[0] = stack[-1] // @1C98 stack[1] = 0x1ca0 // @1C9B stack[2] = stack[-3] // } // Block ends with call to 0x1f31, returns to 0x1CA0 label_1CA0: // Incoming return from call to 0x1F31 at 0x1C9F // Inputs[3] // { // @1CA3 memory[0x40:0x60] // @1CAA stack[-2] // @1CAB stack[-1] // } 1CA0 5B JUMPDEST 1CA1 60 PUSH1 0x40 1CA3 51 MLOAD 1CA4 60 PUSH1 0x20 1CA6 01 ADD 1CA7 61 PUSH2 0x1cb1 1CAA 92 SWAP3 1CAB 91 SWAP2 1CAC 90 SWAP1 1CAD 61 PUSH2 0x2acb 1CB0 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1CAA stack[-2] = 0x1cb1 // @1CAB stack[-1] = stack[-2] // @1CAC stack[1] = 0x20 + memory[0x40:0x60] // @1CAC stack[0] = stack[-1] // } // Block ends with call to 0x2acb, returns to 0x1CB1 label_1CB1: // Incoming return from call to 0x2ACB at 0x1CB0 // Inputs[4] // { // @1CB4 memory[0x40:0x60] // @1CB8 stack[-1] // @1CC1 stack[-5] // @1CC2 stack[-4] // } 1CB1 5B JUMPDEST 1CB2 60 PUSH1 0x40 1CB4 51 MLOAD 1CB5 60 PUSH1 0x20 1CB7 81 DUP2 1CB8 83 DUP4 1CB9 03 SUB 1CBA 03 SUB 1CBB 81 DUP2 1CBC 52 MSTORE 1CBD 90 SWAP1 1CBE 60 PUSH1 0x40 1CC0 52 MSTORE 1CC1 93 SWAP4 1CC2 92 SWAP3 1CC3 50 POP 1CC4 50 POP 1CC5 50 POP 1CC6 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1CBC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @1CC0 memory[0x40:0x60] = stack[-1] // @1CC1 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-5] label_1CC7: // Incoming call from 0x15BE, returns to 0x0729 // Inputs[1] { @1CD3 stack[-1] } 1CC7 5B JUMPDEST 1CC8 60 PUSH1 0x00 1CCA 60 PUSH1 0x01 1CCC 60 PUSH1 0x01 1CCE 60 PUSH1 0xe0 1CD0 1B SHL 1CD1 03 SUB 1CD2 19 NOT 1CD3 82 DUP3 1CD4 16 AND 1CD5 63 PUSH4 0x80ac58cd 1CDA 60 PUSH1 0xe0 1CDC 1B SHL 1CDD 14 EQ 1CDE 80 DUP1 1CDF 61 PUSH2 0x1cf8 1CE2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1CC8 stack[0] = 0x00 // @1CDD stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x1cf8, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1CE3: // Incoming jump from 0x1CE2, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1CED stack[-3] } 1CE3 50 POP 1CE4 60 PUSH1 0x01 1CE6 60 PUSH1 0x01 1CE8 60 PUSH1 0xe0 1CEA 1B SHL 1CEB 03 SUB 1CEC 19 NOT 1CED 82 DUP3 1CEE 16 AND 1CEF 63 PUSH4 0x5b5e139f 1CF4 60 PUSH1 0xe0 1CF6 1B SHL 1CF7 14 EQ 1CF8 5B JUMPDEST 1CF9 80 DUP1 1CFA 61 PUSH2 0x0729 1CFD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1CF7 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0729, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_1CFE: // Incoming jump from 0x1CFD, if not stack[-1] // Incoming jump from 0x1CFD, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1D10 stack[-3] } 1CFE 50 POP 1CFF 63 PUSH4 0x01ffc9a7 1D04 60 PUSH1 0xe0 1D06 1B SHL 1D07 60 PUSH1 0x01 1D09 60 PUSH1 0x01 1D0B 60 PUSH1 0xe0 1D0D 1B SHL 1D0E 03 SUB 1D0F 19 NOT 1D10 83 DUP4 1D11 16 AND 1D12 14 EQ 1D13 61 PUSH2 0x0729 1D16 56 *JUMP // Stack delta = +0 // Outputs[1] { @1D12 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x0729 label_1D17: // Incoming jump from 0x19D2 // Incoming jump from 0x2167 // Incoming jump from 0x18F6 // Inputs[1] { @1D1A storage[0x0a] } 1D17 5B JUMPDEST 1D18 60 PUSH1 0x0a 1D1A 54 SLOAD 1D1B 60 PUSH1 0xff 1D1D 16 AND 1D1E 15 ISZERO 1D1F 61 PUSH2 0x1d3a 1D22 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d3a, if !(0xff & storage[0x0a]) label_1D23: // Incoming jump from 0x1D22, if not !(0xff & storage[0x0a]) // Inputs[1] { @1D25 memory[0x40:0x60] } 1D23 60 PUSH1 0x40 1D25 51 MLOAD 1D26 62 PUSH3 0x461bcd 1D2A 60 PUSH1 0xe5 1D2C 1B SHL 1D2D 81 DUP2 1D2E 52 MSTORE 1D2F 60 PUSH1 0x04 1D31 01 ADD 1D32 61 PUSH2 0x0836 1D35 90 SWAP1 1D36 61 PUSH2 0x29d0 1D39 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D35 stack[0] = 0x0836 // @1D35 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29d0, returns to 0x0836 label_1D3A: // Incoming jump from 0x1D22, if !(0xff & storage[0x0a]) // Inputs[3] // { // @1D3E stack[-3] // @1D3F stack[-2] // @1D40 stack[-1] // } 1D3A 5B JUMPDEST 1D3B 61 PUSH2 0x096c 1D3E 83 DUP4 1D3F 83 DUP4 1D40 83 DUP4 1D41 61 PUSH2 0x202f 1D44 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D3B stack[0] = 0x096c // @1D3E stack[1] = stack[-3] // @1D3F stack[2] = stack[-2] // @1D40 stack[3] = stack[-1] // } // Block ends with call to 0x202f, returns to 0x096C 1D45 5B JUMPDEST 1D46 60 PUSH1 0x00 1D48 60 PUSH1 0x01 1D4A 60 PUSH1 0x01 1D4C 60 PUSH1 0xa0 1D4E 1B SHL 1D4F 03 SUB 1D50 84 DUP5 1D51 16 AND 1D52 3B EXTCODESIZE 1D53 15 ISZERO 1D54 61 PUSH2 0x1e38 1D57 57 *JUMPI 1D58 60 PUSH1 0x40 1D5A 51 MLOAD 1D5B 63 PUSH4 0x0a85bd01 1D60 60 PUSH1 0xe1 1D62 1B SHL 1D63 81 DUP2 1D64 52 MSTORE 1D65 60 PUSH1 0x01 1D67 60 PUSH1 0x01 1D69 60 PUSH1 0xa0 1D6B 1B SHL 1D6C 03 SUB 1D6D 85 DUP6 1D6E 16 AND 1D6F 90 SWAP1 1D70 63 PUSH4 0x150b7a02 1D75 90 SWAP1 1D76 61 PUSH2 0x1d89 1D79 90 SWAP1 1D7A 33 CALLER 1D7B 90 SWAP1 1D7C 89 DUP10 1D7D 90 SWAP1 1D7E 88 DUP9 1D7F 90 SWAP1 1D80 88 DUP9 1D81 90 SWAP1 1D82 60 PUSH1 0x04 1D84 01 ADD 1D85 61 PUSH2 0x2afa 1D88 56 *JUMP 1D89 5B JUMPDEST 1D8A 60 PUSH1 0x20 1D8C 60 PUSH1 0x40 1D8E 51 MLOAD 1D8F 80 DUP1 1D90 83 DUP4 1D91 03 SUB 1D92 81 DUP2 1D93 60 PUSH1 0x00 1D95 87 DUP8 1D96 5A GAS 1D97 F1 CALL 1D98 92 SWAP3 1D99 50 POP 1D9A 50 POP 1D9B 50 POP 1D9C 80 DUP1 1D9D 15 ISZERO 1D9E 61 PUSH2 0x1dc4 1DA1 57 *JUMPI 1DA2 50 POP 1DA3 60 PUSH1 0x40 1DA5 80 DUP1 1DA6 51 MLOAD 1DA7 60 PUSH1 0x1f 1DA9 3D RETURNDATASIZE 1DAA 90 SWAP1 1DAB 81 DUP2 1DAC 01 ADD 1DAD 60 PUSH1 0x1f 1DAF 19 NOT 1DB0 16 AND 1DB1 82 DUP3 1DB2 01 ADD 1DB3 90 SWAP1 1DB4 92 SWAP3 1DB5 52 MSTORE 1DB6 61 PUSH2 0x1dc1 1DB9 91 SWAP2 1DBA 81 DUP2 1DBB 01 ADD 1DBC 90 SWAP1 1DBD 61 PUSH2 0x2b37 1DC0 56 *JUMP 1DC1 5B JUMPDEST 1DC2 60 PUSH1 0x01 1DC4 5B JUMPDEST 1DC5 61 PUSH2 0x1e1e 1DC8 57 *JUMPI 1DC9 3D RETURNDATASIZE 1DCA 80 DUP1 1DCB 80 DUP1 1DCC 15 ISZERO 1DCD 61 PUSH2 0x1df2 1DD0 57 *JUMPI 1DD1 60 PUSH1 0x40 1DD3 51 MLOAD 1DD4 91 SWAP2 1DD5 50 POP 1DD6 60 PUSH1 0x1f 1DD8 19 NOT 1DD9 60 PUSH1 0x3f 1DDB 3D RETURNDATASIZE 1DDC 01 ADD 1DDD 16 AND 1DDE 82 DUP3 1DDF 01 ADD 1DE0 60 PUSH1 0x40 1DE2 52 MSTORE 1DE3 3D RETURNDATASIZE 1DE4 82 DUP3 1DE5 52 MSTORE 1DE6 3D RETURNDATASIZE 1DE7 60 PUSH1 0x00 1DE9 60 PUSH1 0x20 1DEB 84 DUP5 1DEC 01 ADD 1DED 3E RETURNDATACOPY 1DEE 61 PUSH2 0x1df7 1DF1 56 *JUMP 1DF2 5B JUMPDEST 1DF3 60 PUSH1 0x60 1DF5 91 SWAP2 1DF6 50 POP 1DF7 5B JUMPDEST 1DF8 50 POP 1DF9 80 DUP1 1DFA 51 MLOAD 1DFB 61 PUSH2 0x1e16 1DFE 57 *JUMPI 1DFF 60 PUSH1 0x40 1E01 51 MLOAD 1E02 62 PUSH3 0x461bcd 1E06 60 PUSH1 0xe5 1E08 1B SHL 1E09 81 DUP2 1E0A 52 MSTORE 1E0B 60 PUSH1 0x04 1E0D 01 ADD 1E0E 61 PUSH2 0x0836 1E11 90 SWAP1 1E12 61 PUSH2 0x2a79 1E15 56 *JUMP 1E16 5B JUMPDEST 1E17 80 DUP1 1E18 51 MLOAD 1E19 81 DUP2 1E1A 60 PUSH1 0x20 1E1C 01 ADD 1E1D FD *REVERT 1E1E 5B JUMPDEST 1E1F 60 PUSH1 0x01 1E21 60 PUSH1 0x01 1E23 60 PUSH1 0xe0 1E25 1B SHL 1E26 03 SUB 1E27 19 NOT 1E28 16 AND 1E29 63 PUSH4 0x0a85bd01 1E2E 60 PUSH1 0xe1 1E30 1B SHL 1E31 14 EQ 1E32 90 SWAP1 1E33 50 POP 1E34 61 PUSH2 0x1807 1E37 56 *JUMP 1E38 5B JUMPDEST 1E39 50 POP 1E3A 60 PUSH1 0x01 1E3C 94 SWAP5 1E3D 93 SWAP4 1E3E 50 POP 1E3F 50 POP 1E40 50 POP 1E41 50 POP 1E42 56 *JUMP label_1E43: // Incoming call from 0x1BC9, returns to 0x1BCA // Inputs[3] // { // @1E46 stack[-1] // @1E49 stack[-2] // @1E4A memory[stack[-2]:stack[-2] + 0x20] // } 1E43 5B JUMPDEST 1E44 60 PUSH1 0x00 1E46 81 DUP2 1E47 81 DUP2 1E48 5B JUMPDEST 1E49 84 DUP5 1E4A 51 MLOAD 1E4B 81 DUP2 1E4C 10 LT 1E4D 15 ISZERO 1E4E 61 PUSH2 0x1ee7 1E51 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1E44 stack[0] = 0x00 // @1E46 stack[1] = stack[-1] // @1E47 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ee7, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1E52: // Incoming jump from 0x1E51, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1E51, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1E54 stack[-5] // @1E55 stack[-1] // @1E57 memory[stack[-5]:stack[-5] + 0x20] // } 1E52 60 PUSH1 0x00 1E54 85 DUP6 1E55 82 DUP3 1E56 81 DUP2 1E57 51 MLOAD 1E58 81 DUP2 1E59 10 LT 1E5A 61 PUSH2 0x1e65 1E5D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1E52 stack[0] = 0x00 // @1E54 stack[1] = stack[-5] // @1E55 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1e65, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1E5E: // Incoming jump from 0x1E5D, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 1E5E 61 PUSH2 0x1e65 1E61 61 PUSH2 0x29ba 1E64 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E5E stack[0] = 0x1e65 } // Block ends with unconditional jump to 0x29ba label_1E65: // Incoming jump from 0x1E5D, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @1E68 stack[-1] // @1E6C stack[-2] // @1E6D memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1E6E stack[-3] // @1E71 stack[-5] // } 1E65 5B JUMPDEST 1E66 60 PUSH1 0x20 1E68 02 MUL 1E69 60 PUSH1 0x20 1E6B 01 ADD 1E6C 01 ADD 1E6D 51 MLOAD 1E6E 90 SWAP1 1E6F 50 POP 1E70 80 DUP1 1E71 83 DUP4 1E72 11 GT 1E73 61 PUSH2 0x1ea7 1E76 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1E6E stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x1ea7, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_1E77: // Incoming jump from 0x1E76, if not stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[6] // { // @1E7A memory[0x40:0x60] // @1E7F stack[-3] // @1E85 stack[-1] // @1E8D memory[0x40:0x60] // @1E9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1EA0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 1E77 60 PUSH1 0x40 1E79 80 DUP1 1E7A 51 MLOAD 1E7B 60 PUSH1 0x20 1E7D 81 DUP2 1E7E 01 ADD 1E7F 85 DUP6 1E80 90 SWAP1 1E81 52 MSTORE 1E82 90 SWAP1 1E83 81 DUP2 1E84 01 ADD 1E85 82 DUP3 1E86 90 SWAP1 1E87 52 MSTORE 1E88 60 PUSH1 0x60 1E8A 01 ADD 1E8B 60 PUSH1 0x40 1E8D 51 MLOAD 1E8E 60 PUSH1 0x20 1E90 81 DUP2 1E91 83 DUP4 1E92 03 SUB 1E93 03 SUB 1E94 81 DUP2 1E95 52 MSTORE 1E96 90 SWAP1 1E97 60 PUSH1 0x40 1E99 52 MSTORE 1E9A 80 DUP1 1E9B 51 MLOAD 1E9C 90 SWAP1 1E9D 60 PUSH1 0x20 1E9F 01 ADD 1EA0 20 SHA3 1EA1 92 SWAP3 1EA2 50 POP 1EA3 61 PUSH2 0x1ed4 1EA6 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @1E81 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] // @1E87 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-1] // @1E95 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x60 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @1E99 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @1EA1 stack[-3] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to 0x1ed4 label_1EA7: // Incoming jump from 0x1E76, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[7] // { // @1EAB memory[0x40:0x60] // @1EB0 stack[-1] // @1EB6 stack[-3] // @1EBE memory[0x40:0x60] // @1ECC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1ED1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1ED6 stack[-2] // } 1EA7 5B JUMPDEST 1EA8 60 PUSH1 0x40 1EAA 80 DUP1 1EAB 51 MLOAD 1EAC 60 PUSH1 0x20 1EAE 81 DUP2 1EAF 01 ADD 1EB0 83 DUP4 1EB1 90 SWAP1 1EB2 52 MSTORE 1EB3 90 SWAP1 1EB4 81 DUP2 1EB5 01 ADD 1EB6 84 DUP5 1EB7 90 SWAP1 1EB8 52 MSTORE 1EB9 60 PUSH1 0x60 1EBB 01 ADD 1EBC 60 PUSH1 0x40 1EBE 51 MLOAD 1EBF 60 PUSH1 0x20 1EC1 81 DUP2 1EC2 83 DUP4 1EC3 03 SUB 1EC4 03 SUB 1EC5 81 DUP2 1EC6 52 MSTORE 1EC7 90 SWAP1 1EC8 60 PUSH1 0x40 1ECA 52 MSTORE 1ECB 80 DUP1 1ECC 51 MLOAD 1ECD 90 SWAP1 1ECE 60 PUSH1 0x20 1ED0 01 ADD 1ED1 20 SHA3 1ED2 92 SWAP3 1ED3 50 POP 1ED4 5B JUMPDEST 1ED5 50 POP 1ED6 80 DUP1 1ED7 61 PUSH2 0x1edf 1EDA 81 DUP2 1EDB 61 PUSH2 0x2a47 1EDE 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1EB2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @1EB8 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-3] // @1EC6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x60 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @1ECA memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @1ED2 stack[-3] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1ED6 stack[-1] = stack[-2] // @1ED7 stack[0] = 0x1edf // @1EDA stack[1] = stack[-2] // } // Block ends with call to 0x2a47, returns to 0x1EDF label_1EDF: // Incoming return from call to 0x2A47 at 0x1EDE // Incoming return from call to 0x2A47 at 0x1EDE // Inputs[2] // { // @1EE0 stack[-1] // @1EE0 stack[-3] // } 1EDF 5B JUMPDEST 1EE0 91 SWAP2 1EE1 50 POP 1EE2 50 POP 1EE3 61 PUSH2 0x1e48 1EE6 56 *JUMP // Stack delta = -2 // Outputs[1] { @1EE0 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1e48 label_1EE7: // Incoming jump from 0x1E51, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1E51, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1EE9 stack[-6] // @1EE9 stack[-2] // @1EEA stack[-5] // } 1EE7 5B JUMPDEST 1EE8 50 POP 1EE9 93 SWAP4 1EEA 92 SWAP3 1EEB 50 POP 1EEC 50 POP 1EED 50 POP 1EEE 56 *JUMP // Stack delta = -5 // Outputs[1] { @1EE9 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1EEF: // Incoming jump from 0x1BEC // Inputs[2] // { // @1EF3 stack[-3] // @1EF4 stack[-2] // } 1EEF 5B JUMPDEST 1EF0 61 PUSH2 0x1ef9 1EF3 83 DUP4 1EF4 83 DUP4 1EF5 61 PUSH2 0x20a1 1EF8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1EF0 stack[0] = 0x1ef9 // @1EF3 stack[1] = stack[-3] // @1EF4 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x20a1 1EF9 5B JUMPDEST 1EFA 61 PUSH2 0x1f06 1EFD 60 PUSH1 0x00 1EFF 84 DUP5 1F00 84 DUP5 1F01 84 DUP5 1F02 61 PUSH2 0x1d45 1F05 56 *JUMP 1F06 5B JUMPDEST 1F07 61 PUSH2 0x096c 1F0A 57 *JUMPI 1F0B 60 PUSH1 0x40 1F0D 51 MLOAD 1F0E 62 PUSH3 0x461bcd 1F12 60 PUSH1 0xe5 1F14 1B SHL 1F15 81 DUP2 1F16 52 MSTORE 1F17 60 PUSH1 0x04 1F19 01 ADD 1F1A 61 PUSH2 0x0836 1F1D 90 SWAP1 1F1E 61 PUSH2 0x2a79 1F21 56 *JUMP label_1F22: // Incoming call from 0x1C75, returns to 0x1C76 // Inputs[1] { @1F28 storage[0x0b] } 1F22 5B JUMPDEST 1F23 60 PUSH1 0x60 1F25 60 PUSH1 0x0b 1F27 80 DUP1 1F28 54 SLOAD 1F29 61 PUSH2 0x073e 1F2C 90 SWAP1 1F2D 61 PUSH2 0x28f9 1F30 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F23 stack[0] = 0x60 // @1F25 stack[1] = 0x0b // @1F2C stack[2] = 0x073e // @1F2C stack[3] = storage[0x0b] // } // Block ends with call to 0x28f9, returns to 0x073E label_1F31: // Incoming call from 0x1C9F, returns to 0x1CA0 // Inputs[1] { @1F34 stack[-1] } 1F31 5B JUMPDEST 1F32 60 PUSH1 0x60 1F34 81 DUP2 1F35 61 PUSH2 0x1f55 1F38 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F32 stack[0] = 0x60 } // Block ends with conditional jump to 0x1f55, if stack[-1] label_1F39: // Incoming jump from 0x1F38, if not stack[-1] // Inputs[2] // { // @1F3E memory[0x40:0x60] // @1F53 stack[-3] // } 1F39 50 POP 1F3A 50 POP 1F3B 60 PUSH1 0x40 1F3D 80 DUP1 1F3E 51 MLOAD 1F3F 80 DUP1 1F40 82 DUP3 1F41 01 ADD 1F42 90 SWAP1 1F43 91 SWAP2 1F44 52 MSTORE 1F45 60 PUSH1 0x01 1F47 81 DUP2 1F48 52 MSTORE 1F49 60 PUSH1 0x03 1F4B 60 PUSH1 0xfc 1F4D 1B SHL 1F4E 60 PUSH1 0x20 1F50 82 DUP3 1F51 01 ADD 1F52 52 MSTORE 1F53 90 SWAP1 1F54 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1F44 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1F48 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1F52 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @1F53 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1F55: // Incoming jump from 0x1F38, if stack[-1] // Inputs[1] { @1F56 stack[-2] } 1F55 5B JUMPDEST 1F56 81 DUP2 1F57 60 PUSH1 0x00 1F59 5B JUMPDEST 1F5A 81 DUP2 1F5B 15 ISZERO 1F5C 61 PUSH2 0x1f7f 1F5F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F56 stack[0] = stack[-2] // @1F57 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1f7f, if !stack[-2] label_1F60: // Incoming jump from 0x1F5F, if not !stack[-2] // Incoming jump from 0x1F5F, if not !stack[-2] // Inputs[1] { @1F60 stack[-1] } 1F60 80 DUP1 1F61 61 PUSH2 0x1f69 1F64 81 DUP2 1F65 61 PUSH2 0x2a47 1F68 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F60 stack[0] = stack[-1] // @1F61 stack[1] = 0x1f69 // @1F64 stack[2] = stack[-1] // } // Block ends with call to 0x2a47, returns to 0x1F69 label_1F69: // Incoming return from call to 0x2A47 at 0x1F68 // Inputs[4] // { // @1F6A stack[-3] // @1F6A stack[-1] // @1F6F stack[-2] // @1F73 stack[-4] // } 1F69 5B JUMPDEST 1F6A 91 SWAP2 1F6B 50 POP 1F6C 61 PUSH2 0x1f78 1F6F 90 SWAP1 1F70 50 POP 1F71 60 PUSH1 0x0a 1F73 83 DUP4 1F74 61 PUSH2 0x2b6a 1F77 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1F6A stack[-3] = stack[-1] // @1F6F stack[-2] = 0x1f78 // @1F71 stack[-1] = 0x0a // @1F73 stack[0] = stack[-4] // } // Block ends with call to 0x2b6a, returns to 0x1F78 label_1F78: // Incoming return from call to 0x2B6A at 0x1F77 // Inputs[2] // { // @1F79 stack[-1] // @1F79 stack[-3] // } 1F78 5B JUMPDEST 1F79 91 SWAP2 1F7A 50 POP 1F7B 61 PUSH2 0x1f59 1F7E 56 *JUMP // Stack delta = -1 // Outputs[1] { @1F79 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1f59 label_1F7F: // Incoming jump from 0x1F5F, if !stack[-2] // Incoming jump from 0x1F5F, if !stack[-2] // Inputs[1] { @1F82 stack[-1] } 1F7F 5B JUMPDEST 1F80 60 PUSH1 0x00 1F82 81 DUP2 1F83 67 PUSH8 0xffffffffffffffff 1F8C 81 DUP2 1F8D 11 GT 1F8E 15 ISZERO 1F8F 61 PUSH2 0x1f9a 1F92 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F80 stack[0] = 0x00 // @1F82 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1f9a, if !(stack[-1] > 0xffffffffffffffff) label_1F93: // Incoming jump from 0x1F92, if not !(stack[-1] > 0xffffffffffffffff) 1F93 61 PUSH2 0x1f9a 1F96 61 PUSH2 0x262f 1F99 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F93 stack[0] = 0x1f9a } // Block ends with unconditional jump to 0x262f label_1F9A: // Incoming jump from 0x1F92, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1F9D memory[0x40:0x60] // @1F9E stack[-1] // } 1F9A 5B JUMPDEST 1F9B 60 PUSH1 0x40 1F9D 51 MLOAD 1F9E 90 SWAP1 1F9F 80 DUP1 1FA0 82 DUP3 1FA1 52 MSTORE 1FA2 80 DUP1 1FA3 60 PUSH1 0x1f 1FA5 01 ADD 1FA6 60 PUSH1 0x1f 1FA8 19 NOT 1FA9 16 AND 1FAA 60 PUSH1 0x20 1FAC 01 ADD 1FAD 82 DUP3 1FAE 01 ADD 1FAF 60 PUSH1 0x40 1FB1 52 MSTORE 1FB2 80 DUP1 1FB3 15 ISZERO 1FB4 61 PUSH2 0x1fc4 1FB7 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1F9E stack[-1] = memory[0x40:0x60] // @1F9E stack[0] = stack[-1] // @1FA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1FB1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1fc4, if !stack[-1] label_1FB8: // Incoming jump from 0x1FB7, if not !stack[-1] // Inputs[6] // { // @1FBA stack[-2] // @1FBC stack[-1] // @1FBE msg.data.length // @1FC0 msg.data[msg.data.length:msg.data.length + stack[-1]] // @1FC6 stack[-3] // @1FC9 stack[-7] // } 1FB8 60 PUSH1 0x20 1FBA 82 DUP3 1FBB 01 ADD 1FBC 81 DUP2 1FBD 80 DUP1 1FBE 36 CALLDATASIZE 1FBF 83 DUP4 1FC0 37 CALLDATACOPY 1FC1 01 ADD 1FC2 90 SWAP1 1FC3 50 POP 1FC4 5B JUMPDEST 1FC5 50 POP 1FC6 90 SWAP1 1FC7 50 POP 1FC8 5B JUMPDEST 1FC9 84 DUP5 1FCA 15 ISZERO 1FCB 61 PUSH2 0x1807 1FCE 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1FC0 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1FC6 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x1807, if !stack[-7] label_1FCF: // Incoming jump from 0x1FCE, if not !stack[-5] // Incoming jump from 0x1FCE, if not !stack[-7] // Incoming jump from 0x1FCE, if not !stack[-7] // Inputs[1] { @1FD4 stack[-2] } 1FCF 61 PUSH2 0x1fd9 1FD2 60 PUSH1 0x01 1FD4 83 DUP4 1FD5 61 PUSH2 0x2a62 1FD8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FCF stack[0] = 0x1fd9 // @1FD2 stack[1] = 0x01 // @1FD4 stack[2] = stack[-2] // } // Block ends with call to 0x2a62, returns to 0x1FD9 label_1FD9: // Incoming return from call to 0x2A62 at 0x1FD8 // Inputs[3] // { // @1FDA stack[-1] // @1FDA stack[-3] // @1FE1 stack[-6] // } 1FD9 5B JUMPDEST 1FDA 91 SWAP2 1FDB 50 POP 1FDC 61 PUSH2 0x1fe6 1FDF 60 PUSH1 0x0a 1FE1 86 DUP7 1FE2 61 PUSH2 0x2b7e 1FE5 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1FDA stack[-3] = stack[-1] // @1FDC stack[-1] = 0x1fe6 // @1FDF stack[0] = 0x0a // @1FE1 stack[1] = stack[-6] // } // Block ends with call to 0x2b7e, returns to 0x1FE6 label_1FE6: // Incoming return from call to 0x2B7E at 0x1FE5 // Inputs[1] { @1FEA stack[-1] } 1FE6 5B JUMPDEST 1FE7 61 PUSH2 0x1ff1 1FEA 90 SWAP1 1FEB 60 PUSH1 0x30 1FED 61 PUSH2 0x2a10 1FF0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1FEA stack[0] = stack[-1] // @1FEA stack[-1] = 0x1ff1 // @1FEB stack[1] = 0x30 // } // Block ends with call to 0x2a10, returns to 0x1FF1 label_1FF1: // Incoming return from call to 0x2A10 at 0x1FF0 // Inputs[4] // { // @1FF4 stack[-1] // @1FF5 stack[-2] // @1FF6 stack[-3] // @1FF8 memory[stack[-2]:stack[-2] + 0x20] // } 1FF1 5B JUMPDEST 1FF2 60 PUSH1 0xf8 1FF4 1B SHL 1FF5 81 DUP2 1FF6 83 DUP4 1FF7 81 DUP2 1FF8 51 MLOAD 1FF9 81 DUP2 1FFA 10 LT 1FFB 61 PUSH2 0x2006 1FFE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1FF4 stack[-1] = stack[-1] << 0xf8 // @1FF5 stack[0] = stack[-2] // @1FF6 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x2006, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_1FFF: // Incoming jump from 0x1FFE, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 1FFF 61 PUSH2 0x2006 2002 61 PUSH2 0x29ba 2005 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FFF stack[0] = 0x2006 } // Block ends with unconditional jump to 0x29ba label_2006: // Incoming jump from 0x1FFE, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @2009 stack[-1] // @200A stack[-2] // @200B stack[-3] // @2023 stack[-8] // } 2006 5B JUMPDEST 2007 60 PUSH1 0x20 2009 01 ADD 200A 01 ADD 200B 90 SWAP1 200C 60 PUSH1 0x01 200E 60 PUSH1 0x01 2010 60 PUSH1 0xf8 2012 1B SHL 2013 03 SUB 2014 19 NOT 2015 16 AND 2016 90 SWAP1 2017 81 DUP2 2018 60 PUSH1 0x00 201A 1A BYTE 201B 90 SWAP1 201C 53 MSTORE8 201D 50 POP 201E 61 PUSH2 0x2028 2021 60 PUSH1 0x0a 2023 86 DUP7 2024 61 PUSH2 0x2b6a 2027 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @201C memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @201E stack[-3] = 0x2028 // @2021 stack[-2] = 0x0a // @2023 stack[-1] = stack[-8] // } // Block ends with call to 0x2b6a, returns to 0x2028 label_2028: // Incoming return from call to 0x2B6A at 0x2027 // Inputs[2] // { // @2029 stack[-1] // @2029 stack[-6] // } 2028 5B JUMPDEST 2029 94 SWAP5 202A 50 POP 202B 61 PUSH2 0x1fc8 202E 56 *JUMP // Stack delta = -1 // Outputs[1] { @2029 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1fc8 label_202F: // Incoming call from 0x1D44, returns to 0x096C // Inputs[3] // { // @2033 stack[-3] // @2034 stack[-2] // @2035 stack[-1] // } 202F 5B JUMPDEST 2030 61 PUSH2 0x203a 2033 83 DUP4 2034 83 DUP4 2035 83 DUP4 2036 61 PUSH2 0x21ef 2039 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2030 stack[0] = 0x203a // @2033 stack[1] = stack[-3] // @2034 stack[2] = stack[-2] // @2035 stack[3] = stack[-1] // } // Block ends with call to 0x21ef, returns to 0x203A label_203A: // Incoming return from call to 0x21EF at 0x2039 // Inputs[1] { @203D storage[0x0a] } 203A 5B JUMPDEST 203B 60 PUSH1 0x0a 203D 54 SLOAD 203E 60 PUSH1 0xff 2040 16 AND 2041 15 ISZERO 2042 61 PUSH2 0x096c 2045 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x096c, if !(0xff & storage[0x0a]) label_2046: // Incoming jump from 0x2045, if not !(0xff & storage[0x0a]) // Inputs[1] { @2048 memory[0x40:0x60] } 2046 60 PUSH1 0x40 2048 51 MLOAD 2049 62 PUSH3 0x461bcd 204D 60 PUSH1 0xe5 204F 1B SHL 2050 81 DUP2 2051 52 MSTORE 2052 60 PUSH1 0x20 2054 60 PUSH1 0x04 2056 82 DUP3 2057 01 ADD 2058 52 MSTORE 2059 60 PUSH1 0x2b 205B 60 PUSH1 0x24 205D 82 DUP3 205E 01 ADD 205F 52 MSTORE 2060 7F PUSH32 0x4552433732315061757361626c653a20746f6b656e207472616e736665722077 2081 60 PUSH1 0x44 2083 82 DUP3 2084 01 ADD 2085 52 MSTORE 2086 6A PUSH11 0x1a1a5b19481c185d5cd959 2092 60 PUSH1 0xaa 2094 1B SHL 2095 60 PUSH1 0x64 2097 82 DUP3 2098 01 ADD 2099 52 MSTORE 209A 60 PUSH1 0x84 209C 01 ADD 209D 61 PUSH2 0x0836 20A0 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2051 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2058 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @205F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @2085 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315061757361626c653a20746f6b656e207472616e736665722077 // @2099 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1a1a5b19481c185d5cd959 << 0xaa // @209C stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_20A1: // Incoming jump from 0x1EF8 // Inputs[1] { @20AA stack[-2] } 20A1 5B JUMPDEST 20A2 60 PUSH1 0x01 20A4 60 PUSH1 0x01 20A6 60 PUSH1 0xa0 20A8 1B SHL 20A9 03 SUB 20AA 82 DUP3 20AB 16 AND 20AC 61 PUSH2 0x20f7 20AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20f7, if stack[-2] & (0x01 << 0xa0) - 0x01 label_20B0: // Incoming jump from 0x20AF, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @20B2 memory[0x40:0x60] } 20B0 60 PUSH1 0x40 20B2 51 MLOAD 20B3 62 PUSH3 0x461bcd 20B7 60 PUSH1 0xe5 20B9 1B SHL 20BA 81 DUP2 20BB 52 MSTORE 20BC 60 PUSH1 0x20 20BE 60 PUSH1 0x04 20C0 82 DUP3 20C1 01 ADD 20C2 81 DUP2 20C3 90 SWAP1 20C4 52 MSTORE 20C5 60 PUSH1 0x24 20C7 82 DUP3 20C8 01 ADD 20C9 52 MSTORE 20CA 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 20EB 60 PUSH1 0x44 20ED 82 DUP3 20EE 01 ADD 20EF 52 MSTORE 20F0 60 PUSH1 0x64 20F2 01 ADD 20F3 61 PUSH2 0x0836 20F6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @20BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @20C4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @20C9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @20EF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @20F2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_20F7: // Incoming jump from 0x20AF, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @20FA stack[-1] // @2105 memory[0x00:0x40] // @2106 storage[keccak256(memory[0x00:0x40])] // } 20F7 5B JUMPDEST 20F8 60 PUSH1 0x00 20FA 81 DUP2 20FB 81 DUP2 20FC 52 MSTORE 20FD 60 PUSH1 0x02 20FF 60 PUSH1 0x20 2101 52 MSTORE 2102 60 PUSH1 0x40 2104 90 SWAP1 2105 20 SHA3 2106 54 SLOAD 2107 60 PUSH1 0x01 2109 60 PUSH1 0x01 210B 60 PUSH1 0xa0 210D 1B SHL 210E 03 SUB 210F 16 AND 2110 15 ISZERO 2111 61 PUSH2 0x215c 2114 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @20FC memory[0x00:0x20] = stack[-1] // @2101 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x215c, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_2115: // Incoming jump from 0x2114, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @2117 memory[0x40:0x60] } 2115 60 PUSH1 0x40 2117 51 MLOAD 2118 62 PUSH3 0x461bcd 211C 60 PUSH1 0xe5 211E 1B SHL 211F 81 DUP2 2120 52 MSTORE 2121 60 PUSH1 0x20 2123 60 PUSH1 0x04 2125 82 DUP3 2126 01 ADD 2127 52 MSTORE 2128 60 PUSH1 0x1c 212A 60 PUSH1 0x24 212C 82 DUP3 212D 01 ADD 212E 52 MSTORE 212F 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 2150 60 PUSH1 0x44 2152 82 DUP3 2153 01 ADD 2154 52 MSTORE 2155 60 PUSH1 0x64 2157 01 ADD 2158 61 PUSH2 0x0836 215B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2120 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2127 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @212E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @2154 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @2157 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0836 label_215C: // Incoming jump from 0x2114, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @2162 stack[-2] // @2163 stack[-1] // } 215C 5B JUMPDEST 215D 61 PUSH2 0x2168 2160 60 PUSH1 0x00 2162 83 DUP4 2163 83 DUP4 2164 61 PUSH2 0x1d17 2167 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @215D stack[0] = 0x2168 // @2160 stack[1] = 0x00 // @2162 stack[2] = stack[-2] // @2163 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1d17 2168 5B JUMPDEST 2169 60 PUSH1 0x01 216B 60 PUSH1 0x01 216D 60 PUSH1 0xa0 216F 1B SHL 2170 03 SUB 2171 82 DUP3 2172 16 AND 2173 60 PUSH1 0x00 2175 90 SWAP1 2176 81 DUP2 2177 52 MSTORE 2178 60 PUSH1 0x03 217A 60 PUSH1 0x20 217C 52 MSTORE 217D 60 PUSH1 0x40 217F 81 DUP2 2180 20 SHA3 2181 80 DUP1 2182 54 SLOAD 2183 60 PUSH1 0x01 2185 92 SWAP3 2186 90 SWAP1 2187 61 PUSH2 0x2191 218A 90 SWAP1 218B 84 DUP5 218C 90 SWAP1 218D 61 PUSH2 0x2a10 2190 56 *JUMP 2191 5B JUMPDEST 2192 90 SWAP1 2193 91 SWAP2 2194 55 SSTORE 2195 50 POP 2196 50 POP 2197 60 PUSH1 0x00 2199 81 DUP2 219A 81 DUP2 219B 52 MSTORE 219C 60 PUSH1 0x02 219E 60 PUSH1 0x20 21A0 52 MSTORE 21A1 60 PUSH1 0x40 21A3 80 DUP1 21A4 82 DUP3 21A5 20 SHA3 21A6 80 DUP1 21A7 54 SLOAD 21A8 60 PUSH1 0x01 21AA 60 PUSH1 0x01 21AC 60 PUSH1 0xa0 21AE 1B SHL 21AF 03 SUB 21B0 19 NOT 21B1 16 AND 21B2 60 PUSH1 0x01 21B4 60 PUSH1 0x01 21B6 60 PUSH1 0xa0 21B8 1B SHL 21B9 03 SUB 21BA 86 DUP7 21BB 16 AND 21BC 90 SWAP1 21BD 81 DUP2 21BE 17 OR 21BF 90 SWAP1 21C0 91 SWAP2 21C1 55 SSTORE 21C2 90 SWAP1 21C3 51 MLOAD 21C4 83 DUP4 21C5 92 SWAP3 21C6 90 SWAP1 21C7 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 21E8 90 SWAP1 21E9 82 DUP3 21EA 90 SWAP1 21EB A4 LOG4 21EC 50 POP 21ED 50 POP 21EE 56 *JUMP label_21EF: // Incoming call from 0x2039, returns to 0x203A // Inputs[1] { @21F8 stack[-3] } 21EF 5B JUMPDEST 21F0 60 PUSH1 0x01 21F2 60 PUSH1 0x01 21F4 60 PUSH1 0xa0 21F6 1B SHL 21F7 03 SUB 21F8 83 DUP4 21F9 16 AND 21FA 61 PUSH2 0x224a 21FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x224a, if stack[-3] & (0x01 << 0xa0) - 0x01 label_21FE: // Incoming jump from 0x21FD, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2201 stack[-1] // @2205 storage[0x08] // @2213 memory[0x00:0x40] // } 21FE 61 PUSH2 0x2245 2201 81 DUP2 2202 60 PUSH1 0x08 2204 80 DUP1 2205 54 SLOAD 2206 60 PUSH1 0x00 2208 83 DUP4 2209 81 DUP2 220A 52 MSTORE 220B 60 PUSH1 0x09 220D 60 PUSH1 0x20 220F 52 MSTORE 2210 60 PUSH1 0x40 2212 81 DUP2 2213 20 SHA3 2214 82 DUP3 2215 90 SWAP1 2216 55 SSTORE 2217 60 PUSH1 0x01 2219 82 DUP3 221A 01 ADD 221B 83 DUP4 221C 55 SSTORE 221D 91 SWAP2 221E 90 SWAP1 221F 91 SWAP2 2220 52 MSTORE 2221 7F PUSH32 0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 2242 01 ADD 2243 55 SSTORE 2244 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @220A memory[0x00:0x20] = stack[-1] // @220F memory[0x20:0x40] = 0x09 // @2216 storage[keccak256(memory[0x00:0x40])] = storage[0x08] // @221C storage[0x08] = storage[0x08] + 0x01 // @2220 memory[0x00:0x20] = 0x08 // @2243 storage[0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 + storage[0x08]] = stack[-1] // } // Block ends with unconditional jump to 0x2245 label_2245: // Incoming jump from 0x2244 2245 5B JUMPDEST 2246 61 PUSH2 0x226d 2249 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x226d label_224A: // Incoming jump from 0x21FD, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @224B stack[-2] // @2255 stack[-3] // } 224A 5B JUMPDEST 224B 81 DUP2 224C 60 PUSH1 0x01 224E 60 PUSH1 0x01 2250 60 PUSH1 0xa0 2252 1B SHL 2253 03 SUB 2254 16 AND 2255 83 DUP4 2256 60 PUSH1 0x01 2258 60 PUSH1 0x01 225A 60 PUSH1 0xa0 225C 1B SHL 225D 03 SUB 225E 16 AND 225F 14 EQ 2260 61 PUSH2 0x226d 2263 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x226d, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] label_2264: // Incoming jump from 0x2263, if not (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[2] // { // @2267 stack[-3] // @2268 stack[-1] // } 2264 61 PUSH2 0x226d 2267 83 DUP4 2268 82 DUP3 2269 61 PUSH2 0x22a7 226C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2264 stack[0] = 0x226d // @2267 stack[1] = stack[-3] // @2268 stack[2] = stack[-1] // } // Block ends with call to 0x22a7, returns to 0x226D label_226D: // Incoming jump from 0x2249 // Incoming jump from 0x2263, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Incoming return from call to 0x22A7 at 0x226C // Inputs[1] { @2276 stack[-2] } 226D 5B JUMPDEST 226E 60 PUSH1 0x01 2270 60 PUSH1 0x01 2272 60 PUSH1 0xa0 2274 1B SHL 2275 03 SUB 2276 82 DUP3 2277 16 AND 2278 61 PUSH2 0x2284 227B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2284, if stack[-2] & (0x01 << 0xa0) - 0x01 label_227C: // Incoming jump from 0x227B, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @227F stack[-1] } 227C 61 PUSH2 0x096c 227F 81 DUP2 2280 61 PUSH2 0x2344 2283 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @227C stack[0] = 0x096c // @227F stack[1] = stack[-1] // } // Block ends with call to 0x2344, returns to 0x096C label_2284: // Incoming jump from 0x227B, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @2285 stack[-3] // @228F stack[-2] // } 2284 5B JUMPDEST 2285 82 DUP3 2286 60 PUSH1 0x01 2288 60 PUSH1 0x01 228A 60 PUSH1 0xa0 228C 1B SHL 228D 03 SUB 228E 16 AND 228F 82 DUP3 2290 60 PUSH1 0x01 2292 60 PUSH1 0x01 2294 60 PUSH1 0xa0 2296 1B SHL 2297 03 SUB 2298 16 AND 2299 14 EQ 229A 61 PUSH2 0x096c 229D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x096c, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] label_229E: // Incoming jump from 0x229D, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @22A1 stack[-2] // @22A2 stack[-1] // } 229E 61 PUSH2 0x096c 22A1 82 DUP3 22A2 82 DUP3 22A3 61 PUSH2 0x23f3 22A6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @229E stack[0] = 0x096c // @22A1 stack[1] = stack[-2] // @22A2 stack[2] = stack[-1] // } // Block ends with call to 0x23f3, returns to 0x096C label_22A7: // Incoming call from 0x226C, returns to 0x226D // Inputs[1] { @22AF stack[-2] } 22A7 5B JUMPDEST 22A8 60 PUSH1 0x00 22AA 60 PUSH1 0x01 22AC 61 PUSH2 0x22b4 22AF 84 DUP5 22B0 61 PUSH2 0x0e0d 22B3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22A8 stack[0] = 0x00 // @22AA stack[1] = 0x01 // @22AC stack[2] = 0x22b4 // @22AF stack[3] = stack[-2] // } // Block ends with call to 0x0e0d, returns to 0x22B4 label_22B4: // Incoming return from call to 0x0E0D at 0x22B3 // Inputs[2] // { // @22B8 stack[-2] // @22B9 stack[-1] // } 22B4 5B JUMPDEST 22B5 61 PUSH2 0x22be 22B8 91 SWAP2 22B9 90 SWAP1 22BA 61 PUSH2 0x2a62 22BD 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @22B8 stack[-2] = 0x22be // @22B9 stack[-1] = stack[-2] // @22B9 stack[0] = stack[-1] // } // Block ends with call to 0x2a62, returns to 0x22BE label_22BE: // Incoming return from call to 0x2A62 at 0x22BD // Inputs[5] // { // @22C1 stack[-3] // @22CC memory[0x00:0x40] // @22CD storage[keccak256(memory[0x00:0x40])] // @22CE stack[-1] // @22CF stack[-2] // } 22BE 5B JUMPDEST 22BF 60 PUSH1 0x00 22C1 83 DUP4 22C2 81 DUP2 22C3 52 MSTORE 22C4 60 PUSH1 0x07 22C6 60 PUSH1 0x20 22C8 52 MSTORE 22C9 60 PUSH1 0x40 22CB 90 SWAP1 22CC 20 SHA3 22CD 54 SLOAD 22CE 90 SWAP1 22CF 91 SWAP2 22D0 50 POP 22D1 80 DUP1 22D2 82 DUP3 22D3 14 EQ 22D4 61 PUSH2 0x2311 22D7 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @22C3 memory[0x00:0x20] = stack[-3] // @22C8 memory[0x20:0x40] = 0x07 // @22CE stack[-1] = storage[keccak256(memory[0x00:0x40])] // @22CF stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x2311, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_22D8: // Incoming jump from 0x22D7, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[13] // { // @22E0 stack[-4] // @22F2 memory[0x00:0x40] // @22F3 stack[-2] // @22FA memory[0x00:0x40] // @22FB storage[keccak256(memory[0x00:0x40])] // @22FC stack[-1] // @2301 memory[0x00:0x40] // @230D memory[0x00:0x40] // @2315 stack[-3] // @2323 memory[0x00:0x40] // @233A memory[0x00:0x40] // @2341 memory[0x00:0x40] // @2343 stack[-5] // } 22D8 60 PUSH1 0x01 22DA 60 PUSH1 0x01 22DC 60 PUSH1 0xa0 22DE 1B SHL 22DF 03 SUB 22E0 84 DUP5 22E1 16 AND 22E2 60 PUSH1 0x00 22E4 90 SWAP1 22E5 81 DUP2 22E6 52 MSTORE 22E7 60 PUSH1 0x06 22E9 60 PUSH1 0x20 22EB 90 SWAP1 22EC 81 DUP2 22ED 52 MSTORE 22EE 60 PUSH1 0x40 22F0 80 DUP1 22F1 83 DUP4 22F2 20 SHA3 22F3 85 DUP6 22F4 84 DUP5 22F5 52 MSTORE 22F6 82 DUP3 22F7 52 MSTORE 22F8 80 DUP1 22F9 83 DUP4 22FA 20 SHA3 22FB 54 SLOAD 22FC 84 DUP5 22FD 84 DUP5 22FE 52 MSTORE 22FF 81 DUP2 2300 84 DUP5 2301 20 SHA3 2302 81 DUP2 2303 90 SWAP1 2304 55 SSTORE 2305 83 DUP4 2306 52 MSTORE 2307 60 PUSH1 0x07 2309 90 SWAP1 230A 91 SWAP2 230B 52 MSTORE 230C 90 SWAP1 230D 20 SHA3 230E 81 DUP2 230F 90 SWAP1 2310 55 SSTORE 2311 5B JUMPDEST 2312 50 POP 2313 60 PUSH1 0x00 2315 91 SWAP2 2316 82 DUP3 2317 52 MSTORE 2318 60 PUSH1 0x07 231A 60 PUSH1 0x20 231C 90 SWAP1 231D 81 DUP2 231E 52 MSTORE 231F 60 PUSH1 0x40 2321 80 DUP1 2322 84 DUP5 2323 20 SHA3 2324 84 DUP5 2325 90 SWAP1 2326 55 SSTORE 2327 60 PUSH1 0x01 2329 60 PUSH1 0x01 232B 60 PUSH1 0xa0 232D 1B SHL 232E 03 SUB 232F 90 SWAP1 2330 94 SWAP5 2331 16 AND 2332 83 DUP4 2333 52 MSTORE 2334 60 PUSH1 0x06 2336 81 DUP2 2337 52 MSTORE 2338 83 DUP4 2339 83 DUP4 233A 20 SHA3 233B 91 SWAP2 233C 83 DUP4 233D 52 MSTORE 233E 52 MSTORE 233F 90 SWAP1 2340 81 DUP2 2341 20 SHA3 2342 55 SSTORE 2343 56 *JUMP // Stack delta = -5 // Outputs[17] // { // @22E6 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @22ED memory[0x20:0x40] = 0x06 // @22F5 memory[0x00:0x20] = stack[-2] // @22F7 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @22FE memory[0x00:0x20] = stack[-1] // @2304 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @2306 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @230B memory[0x20:0x40] = 0x07 // @2310 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2317 memory[0x00:0x20] = stack[-3] // @231E memory[0x20:0x40] = 0x07 // @2326 storage[keccak256(memory[0x00:0x40])] = 0x00 // @2333 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2337 memory[0x20:0x40] = 0x06 // @233D memory[0x00:0x20] = stack[-2] // @233E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2342 storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_2344: // Incoming call from 0x2283, returns to 0x096C // Inputs[1] { @2347 storage[0x08] } 2344 5B JUMPDEST 2345 60 PUSH1 0x08 2347 54 SLOAD 2348 60 PUSH1 0x00 234A 90 SWAP1 234B 61 PUSH2 0x2356 234E 90 SWAP1 234F 60 PUSH1 0x01 2351 90 SWAP1 2352 61 PUSH2 0x2a62 2355 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @234A stack[0] = 0x00 // @234E stack[1] = 0x2356 // @2351 stack[2] = 0x01 // @2351 stack[3] = storage[0x08] // } // Block ends with call to 0x2a62, returns to 0x2356 label_2356: // Incoming return from call to 0x2A62 at 0x2355 // Inputs[6] // { // @2359 stack[-3] // @2364 memory[0x00:0x40] // @2365 storage[keccak256(memory[0x00:0x40])] // @2369 storage[0x08] // @236A stack[-1] // @236B stack[-2] // } 2356 5B JUMPDEST 2357 60 PUSH1 0x00 2359 83 DUP4 235A 81 DUP2 235B 52 MSTORE 235C 60 PUSH1 0x09 235E 60 PUSH1 0x20 2360 52 MSTORE 2361 60 PUSH1 0x40 2363 81 DUP2 2364 20 SHA3 2365 54 SLOAD 2366 60 PUSH1 0x08 2368 80 DUP1 2369 54 SLOAD 236A 93 SWAP4 236B 94 SWAP5 236C 50 POP 236D 90 SWAP1 236E 92 SWAP3 236F 84 DUP5 2370 90 SWAP1 2371 81 DUP2 2372 10 LT 2373 61 PUSH2 0x237e 2376 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @2357 stack[0] = 0x00 // @235B memory[0x00:0x20] = stack[-3] // @2360 memory[0x20:0x40] = 0x09 // @236B stack[-2] = stack[-1] // @236D stack[1] = 0x08 // @236E stack[-1] = storage[keccak256(memory[0x00:0x40])] // @2370 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x237e, if stack[-1] < storage[0x08] label_2377: // Incoming jump from 0x2376, if not stack[-1] < storage[0x08] 2377 61 PUSH2 0x237e 237A 61 PUSH2 0x29ba 237D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2377 stack[0] = 0x237e } // Block ends with unconditional jump to 0x29ba label_237E: // Incoming jump from 0x2376, if stack[-1] < storage[0x08] // Inputs[7] // { // @237F stack[-1] // @237F stack[-2] // @2387 memory[0x00:0x20] // @2389 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @238A stack[-3] // @238F stack[-4] // @2391 storage[0x08] // } 237E 5B JUMPDEST 237F 90 SWAP1 2380 60 PUSH1 0x00 2382 52 MSTORE 2383 60 PUSH1 0x20 2385 60 PUSH1 0x00 2387 20 SHA3 2388 01 ADD 2389 54 SLOAD 238A 90 SWAP1 238B 50 POP 238C 80 DUP1 238D 60 PUSH1 0x08 238F 83 DUP4 2390 81 DUP2 2391 54 SLOAD 2392 81 DUP2 2393 10 LT 2394 61 PUSH2 0x239f 2397 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2382 memory[0x00:0x20] = stack[-2] // @238A stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @238C stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @238D stack[-1] = 0x08 // @238F stack[0] = stack[-4] // } // Block ends with conditional jump to 0x239f, if stack[-4] < storage[0x08] label_2398: // Incoming jump from 0x2397, if not stack[-4] < storage[0x08] 2398 61 PUSH2 0x239f 239B 61 PUSH2 0x29ba 239E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2398 stack[0] = 0x239f } // Block ends with unconditional jump to 0x29ba label_239F: // Incoming jump from 0x2397, if stack[-4] < storage[0x08] // Inputs[10] // { // @23A2 stack[-2] // @23A9 memory[0x00:0x20] // @23AB stack[-1] // @23AD stack[-3] // @23B1 stack[-4] // @23BD memory[0x00:0x40] // @23BE stack[-5] // @23C1 stack[-7] // @23C5 memory[0x00:0x40] // @23CA storage[0x08] // } 239F 5B JUMPDEST 23A0 60 PUSH1 0x00 23A2 91 SWAP2 23A3 82 DUP3 23A4 52 MSTORE 23A5 60 PUSH1 0x20 23A7 80 DUP1 23A8 83 DUP4 23A9 20 SHA3 23AA 90 SWAP1 23AB 91 SWAP2 23AC 01 ADD 23AD 92 SWAP3 23AE 90 SWAP1 23AF 92 SWAP3 23B0 55 SSTORE 23B1 82 DUP3 23B2 81 DUP2 23B3 52 MSTORE 23B4 60 PUSH1 0x09 23B6 90 SWAP1 23B7 91 SWAP2 23B8 52 MSTORE 23B9 60 PUSH1 0x40 23BB 80 DUP1 23BC 82 DUP3 23BD 20 SHA3 23BE 84 DUP5 23BF 90 SWAP1 23C0 55 SSTORE 23C1 85 DUP6 23C2 82 DUP3 23C3 52 MSTORE 23C4 81 DUP2 23C5 20 SHA3 23C6 55 SSTORE 23C7 60 PUSH1 0x08 23C9 80 DUP1 23CA 54 SLOAD 23CB 80 DUP1 23CC 61 PUSH2 0x23d7 23CF 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @23A4 memory[0x00:0x20] = stack[-2] // @23B0 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @23B3 memory[0x00:0x20] = stack[-4] // @23B8 memory[0x20:0x40] = 0x09 // @23C0 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @23C3 memory[0x00:0x20] = stack[-7] // @23C6 storage[keccak256(memory[0x00:0x40])] = 0x00 // @23C7 stack[-3] = 0x08 // @23CA stack[-2] = storage[0x08] // } // Block ends with conditional jump to 0x23d7, if storage[0x08] label_23D0: // Incoming jump from 0x23CF, if not storage[0x08] 23D0 61 PUSH2 0x23d7 23D3 61 PUSH2 0x2b92 23D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @23D0 stack[0] = 0x23d7 } // Block ends with unconditional jump to 0x2b92 label_23D7: // Incoming jump from 0x23CF, if storage[0x08] // Inputs[4] // { // @23DA stack[-1] // @23DC stack[-2] // @23E6 memory[0x00:0x20] // @23F2 stack[-7] // } 23D7 5B JUMPDEST 23D8 60 PUSH1 0x01 23DA 90 SWAP1 23DB 03 SUB 23DC 81 DUP2 23DD 81 DUP2 23DE 90 SWAP1 23DF 60 PUSH1 0x00 23E1 52 MSTORE 23E2 60 PUSH1 0x20 23E4 60 PUSH1 0x00 23E6 20 SHA3 23E7 01 ADD 23E8 60 PUSH1 0x00 23EA 90 SWAP1 23EB 55 SSTORE 23EC 90 SWAP1 23ED 55 SSTORE 23EE 50 POP 23EF 50 POP 23F0 50 POP 23F1 50 POP 23F2 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @23E1 memory[0x00:0x20] = stack[-2] // @23EB storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @23ED storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_23F3: // Incoming call from 0x22A6, returns to 0x096C // Inputs[1] { @23F9 stack[-2] } 23F3 5B JUMPDEST 23F4 60 PUSH1 0x00 23F6 61 PUSH2 0x23fe 23F9 83 DUP4 23FA 61 PUSH2 0x0e0d 23FD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23F4 stack[0] = 0x00 // @23F6 stack[1] = 0x23fe // @23F9 stack[2] = stack[-2] // } // Block ends with call to 0x0e0d, returns to 0x23FE label_23FE: // Incoming return from call to 0x0E0D at 0x23FD // Inputs[8] // { // @2407 stack[-1] // @2408 stack[-4] // @241A memory[0x00:0x40] // @2422 memory[0x00:0x40] // @2423 stack[-3] // @242E stack[-2] // @2430 memory[0x00:0x40] // @2436 stack[-5] // } 23FE 5B JUMPDEST 23FF 60 PUSH1 0x01 2401 60 PUSH1 0x01 2403 60 PUSH1 0xa0 2405 1B SHL 2406 03 SUB 2407 90 SWAP1 2408 93 SWAP4 2409 16 AND 240A 60 PUSH1 0x00 240C 90 SWAP1 240D 81 DUP2 240E 52 MSTORE 240F 60 PUSH1 0x06 2411 60 PUSH1 0x20 2413 90 SWAP1 2414 81 DUP2 2415 52 MSTORE 2416 60 PUSH1 0x40 2418 80 DUP1 2419 83 DUP4 241A 20 SHA3 241B 86 DUP7 241C 84 DUP5 241D 52 MSTORE 241E 82 DUP3 241F 52 MSTORE 2420 80 DUP1 2421 83 DUP4 2422 20 SHA3 2423 85 DUP6 2424 90 SWAP1 2425 55 SSTORE 2426 93 SWAP4 2427 82 DUP3 2428 52 MSTORE 2429 60 PUSH1 0x07 242B 90 SWAP1 242C 52 MSTORE 242D 91 SWAP2 242E 90 SWAP1 242F 91 SWAP2 2430 20 SHA3 2431 91 SWAP2 2432 90 SWAP1 2433 91 SWAP2 2434 55 SSTORE 2435 50 POP 2436 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @240E memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2415 memory[0x20:0x40] = 0x06 // @241D memory[0x00:0x20] = stack[-1] // @241F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2425 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @2428 memory[0x00:0x20] = stack[-3] // @242C memory[0x20:0x40] = 0x07 // @2434 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_2437: // Incoming jump from 0x0D24 // Inputs[2] // { // @2438 stack[-3] // @243A storage[stack[-3]] // } 2437 5B JUMPDEST 2438 82 DUP3 2439 80 DUP1 243A 54 SLOAD 243B 61 PUSH2 0x2443 243E 90 SWAP1 243F 61 PUSH2 0x28f9 2442 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2438 stack[0] = stack[-3] // @243E stack[1] = 0x2443 // @243E stack[2] = storage[stack[-3]] // } // Block ends with call to 0x28f9, returns to 0x2443 label_2443: // Incoming return from call to 0x28F9 at 0x2442 // Inputs[5] // { // @2444 stack[-2] // @2444 stack[-1] // @244C memory[0x00:0x20] // @2457 stack[-4] // @2458 stack[-3] // } 2443 5B JUMPDEST 2444 90 SWAP1 2445 60 PUSH1 0x00 2447 52 MSTORE 2448 60 PUSH1 0x20 244A 60 PUSH1 0x00 244C 20 SHA3 244D 90 SWAP1 244E 60 PUSH1 0x1f 2450 01 ADD 2451 60 PUSH1 0x20 2453 90 SWAP1 2454 04 DIV 2455 81 DUP2 2456 01 ADD 2457 92 SWAP3 2458 82 DUP3 2459 61 PUSH2 0x2465 245C 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2447 memory[0x00:0x20] = stack[-2] // @244D stack[-2] = keccak256(memory[0x00:0x20]) // @2457 stack[-1] = stack[-4] // @2457 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x2465, if stack[-3] label_245D: // Incoming jump from 0x245C, if not stack[-3] // Inputs[1] { @245F stack[-5] } 245D 60 PUSH1 0x00 245F 85 DUP6 2460 55 SSTORE 2461 61 PUSH2 0x24ab 2464 56 *JUMP // Stack delta = +0 // Outputs[1] { @2460 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x24ab label_2465: // Incoming jump from 0x245C, if stack[-3] // Inputs[1] { @2466 stack[-3] } 2465 5B JUMPDEST 2466 82 DUP3 2467 60 PUSH1 0x1f 2469 10 LT 246A 61 PUSH2 0x247e 246D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x247e, if 0x1f < stack[-3] label_246E: // Incoming jump from 0x246D, if not 0x1f < stack[-3] // Inputs[4] // { // @246E stack[-1] // @246F memory[stack[-1]:stack[-1] + 0x20] // @2474 stack[-3] // @2478 stack[-5] // } 246E 80 DUP1 246F 51 MLOAD 2470 60 PUSH1 0xff 2472 19 NOT 2473 16 AND 2474 83 DUP4 2475 80 DUP1 2476 01 ADD 2477 17 OR 2478 85 DUP6 2479 55 SSTORE 247A 61 PUSH2 0x24ab 247D 56 *JUMP // Stack delta = +0 // Outputs[1] { @2479 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x24ab label_247E: // Incoming jump from 0x246D, if 0x1f < stack[-3] // Inputs[2] // { // @247F stack[-3] // @2485 stack[-5] // } 247E 5B JUMPDEST 247F 82 DUP3 2480 80 DUP1 2481 01 ADD 2482 60 PUSH1 0x01 2484 01 ADD 2485 85 DUP6 2486 55 SSTORE 2487 82 DUP3 2488 15 ISZERO 2489 61 PUSH2 0x24ab 248C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2486 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x24ab, if !stack[-3] label_248D: // Incoming jump from 0x248C, if not !stack[-3] // Inputs[2] // { // @248D stack[-1] // @248D stack[-3] // } 248D 91 SWAP2 248E 82 DUP3 248F 01 ADD 2490 5B JUMPDEST 2491 82 DUP3 2492 81 DUP2 2493 11 GT 2494 15 ISZERO 2495 61 PUSH2 0x24ab 2498 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @248D stack[-3] = stack[-1] // @248F stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x24ab, if !(stack[-1] + stack[-3] > stack[-1]) label_2499: // Incoming jump from 0x2498, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2498, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @2499 stack[-3] // @249A memory[stack[-3]:stack[-3] + 0x20] // @249B stack[-2] // @249D stack[-1] // } 2499 82 DUP3 249A 51 MLOAD 249B 82 DUP3 249C 55 SSTORE 249D 91 SWAP2 249E 60 PUSH1 0x20 24A0 01 ADD 24A1 91 SWAP2 24A2 90 SWAP1 24A3 60 PUSH1 0x01 24A5 01 ADD 24A6 90 SWAP1 24A7 61 PUSH2 0x2490 24AA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @249C storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @24A1 stack[-3] = 0x20 + stack[-3] // @24A6 stack[-2] = 0x01 + stack[-2] // @24A6 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x2490 label_24AB: // Incoming jump from 0x248C, if !stack[-3] // Incoming jump from 0x2464 // Incoming jump from 0x2498, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2498, if !(stack[-1] > stack[-3]) // Incoming jump from 0x247D // Inputs[2] // { // @24B0 stack[-4] // @24B1 stack[-3] // } 24AB 5B JUMPDEST 24AC 50 POP 24AD 61 PUSH2 0x24b7 24B0 92 SWAP3 24B1 91 SWAP2 24B2 50 POP 24B3 61 PUSH2 0x24bb 24B6 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @24B0 stack[-4] = 0x24b7 // @24B1 stack[-3] = stack[-4] // } // Block ends with call to 0x24bb, returns to 0x24B7 label_24B7: // Incoming jump from 0x24C4, if !(stack[-2] > stack[-1]) // Incoming jump from 0x24C4, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x24BB at 0x24B6 // Inputs[2] // { // @24B9 stack[-3] // @24B9 stack[-2] // } 24B7 5B JUMPDEST 24B8 50 POP 24B9 90 SWAP1 24BA 56 *JUMP // Stack delta = -2 // Outputs[1] { @24B9 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_24BB: // Incoming call from 0x24B6, returns to 0x24B7 // Inputs[2] // { // @24BD stack[-1] // @24BE stack[-2] // } 24BB 5B JUMPDEST 24BC 5B JUMPDEST 24BD 80 DUP1 24BE 82 DUP3 24BF 11 GT 24C0 15 ISZERO 24C1 61 PUSH2 0x24b7 24C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x24b7, if !(stack[-2] > stack[-1]) label_24C5: // Incoming jump from 0x24C4, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x24C4, if not !(stack[-2] > stack[-1]) // Inputs[1] { @24C7 stack[-1] } 24C5 60 PUSH1 0x00 24C7 81 DUP2 24C8 55 SSTORE 24C9 60 PUSH1 0x01 24CB 01 ADD 24CC 61 PUSH2 0x24bc 24CF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @24C8 storage[stack[-1]] = 0x00 // @24CB stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x24bc label_24D0: // Incoming call from 0x2502, returns to 0x1464 // Inputs[1] { @24DA stack[-1] } 24D0 5B JUMPDEST 24D1 60 PUSH1 0x01 24D3 60 PUSH1 0x01 24D5 60 PUSH1 0xe0 24D7 1B SHL 24D8 03 SUB 24D9 19 NOT 24DA 81 DUP2 24DB 16 AND 24DC 81 DUP2 24DD 14 EQ 24DE 61 PUSH2 0x09e3 24E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09e3, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_24E2: // Incoming jump from 0x24E1, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @24E5 memory[0x00:0x00] } 24E2 60 PUSH1 0x00 24E4 80 DUP1 24E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @24E5 revert(memory[0x00:0x00]); } // Block terminates label_24E6: // Incoming call from 0x025A, returns to 0x025B // Inputs[2] // { // @24EB stack[-1] // @24EC stack[-2] // } 24E6 5B JUMPDEST 24E7 60 PUSH1 0x00 24E9 60 PUSH1 0x20 24EB 82 DUP3 24EC 84 DUP5 24ED 03 SUB 24EE 12 SLT 24EF 15 ISZERO 24F0 61 PUSH2 0x24f8 24F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24E7 stack[0] = 0x00 } // Block ends with conditional jump to 0x24f8, if !(stack[-2] - stack[-1] i< 0x20) label_24F4: // Incoming jump from 0x24F3, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @24F7 memory[0x00:0x00] } 24F4 60 PUSH1 0x00 24F6 80 DUP1 24F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @24F7 revert(memory[0x00:0x00]); } // Block terminates label_24F8: // Incoming jump from 0x24F3, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @24F9 stack[-2] // @24FA msg.data[stack[-2]:stack[-2] + 0x20] // } 24F8 5B JUMPDEST 24F9 81 DUP2 24FA 35 CALLDATALOAD 24FB 61 PUSH2 0x1464 24FE 81 DUP2 24FF 61 PUSH2 0x24d0 2502 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24FA stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @24FB stack[1] = 0x1464 // @24FE stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x24d0, returns to 0x1464 label_2503: // Incoming call from 0x2ADC, returns to 0x2ADD // Incoming call from 0x2AF0, returns to 0x2AF1 // Incoming call from 0x2546, returns to 0x2547 // Inputs[1] { @2507 stack[-3] } 2503 5B JUMPDEST 2504 60 PUSH1 0x00 2506 5B JUMPDEST 2507 83 DUP4 2508 81 DUP2 2509 10 LT 250A 15 ISZERO 250B 61 PUSH2 0x251e 250E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2504 stack[0] = 0x00 } // Block ends with conditional jump to 0x251e, if !(0x00 < stack[-3]) label_250F: // Incoming jump from 0x250E, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x250E, if not !(0x00 < stack[-3]) // Inputs[4] // { // @250F stack[-2] // @2510 stack[-1] // @2512 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2513 stack[-3] // } 250F 81 DUP2 2510 81 DUP2 2511 01 ADD 2512 51 MLOAD 2513 83 DUP4 2514 82 DUP3 2515 01 ADD 2516 52 MSTORE 2517 60 PUSH1 0x20 2519 01 ADD 251A 61 PUSH2 0x2506 251D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2516 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2519 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2506 label_251E: // Incoming jump from 0x250E, if !(stack[-1] < stack[-4]) // Incoming jump from 0x250E, if !(0x00 < stack[-3]) // Inputs[2] // { // @251F stack[-4] // @2520 stack[-1] // } 251E 5B JUMPDEST 251F 83 DUP4 2520 81 DUP2 2521 11 GT 2522 15 ISZERO 2523 61 PUSH2 0x0f1c 2526 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f1c, if !(stack[-1] > stack[-4]) label_2527: // Incoming jump from 0x2526, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @252B stack[-4] // @252C stack[-3] // @252E stack[-5] // } 2527 50 POP 2528 50 POP 2529 60 PUSH1 0x00 252B 91 SWAP2 252C 01 ADD 252D 52 MSTORE 252E 56 *JUMP // Stack delta = -5 // Outputs[1] { @252D memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_252F: // Incoming call from 0x256D, returns to 0x1464 // Inputs[3] // { // @2532 stack[-1] // @2533 memory[stack[-1]:stack[-1] + 0x20] // @2535 stack[-2] // } 252F 5B JUMPDEST 2530 60 PUSH1 0x00 2532 81 DUP2 2533 51 MLOAD 2534 80 DUP1 2535 84 DUP5 2536 52 MSTORE 2537 61 PUSH2 0x2547 253A 81 DUP2 253B 60 PUSH1 0x20 253D 86 DUP7 253E 01 ADD 253F 60 PUSH1 0x20 2541 86 DUP7 2542 01 ADD 2543 61 PUSH2 0x2503 2546 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2530 stack[0] = 0x00 // @2533 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2536 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2537 stack[2] = 0x2547 // @253A stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @253E stack[4] = stack[-2] + 0x20 // @2542 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2503, returns to 0x2547 label_2547: // Incoming return from call to 0x2503 at 0x2546 // Inputs[4] // { // @254A stack[-1] // @254F stack[-4] // @2550 stack[-2] // @2556 stack[-5] // } 2547 5B JUMPDEST 2548 60 PUSH1 0x1f 254A 01 ADD 254B 60 PUSH1 0x1f 254D 19 NOT 254E 16 AND 254F 92 SWAP3 2550 90 SWAP1 2551 92 SWAP3 2552 01 ADD 2553 60 PUSH1 0x20 2555 01 ADD 2556 92 SWAP3 2557 91 SWAP2 2558 50 POP 2559 50 POP 255A 56 *JUMP // Stack delta = -4 // Outputs[1] { @2556 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_255B: // Incoming jump from 0x0296 // Inputs[2] // { // @255E stack[-1] // @2569 stack[-2] // } 255B 5B JUMPDEST 255C 60 PUSH1 0x20 255E 81 DUP2 255F 52 MSTORE 2560 60 PUSH1 0x00 2562 61 PUSH2 0x1464 2565 60 PUSH1 0x20 2567 83 DUP4 2568 01 ADD 2569 84 DUP5 256A 61 PUSH2 0x252f 256D 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @255F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2560 stack[0] = 0x00 // @2562 stack[1] = 0x1464 // @2568 stack[2] = stack[-1] + 0x20 // @2569 stack[3] = stack[-2] // } // Block ends with call to 0x252f, returns to 0x1464 label_256E: // Incoming call from 0x030B, returns to 0x030C // Incoming call from 0x0422, returns to 0x0423 // Incoming call from 0x04BB, returns to 0x04BC // Incoming call from 0x0679, returns to 0x067A // Incoming call from 0x0442, returns to 0x0443 // Incoming call from 0x0502, returns to 0x0503 // Incoming call from 0x062D, returns to 0x062E // Incoming call from 0x02B1, returns to 0x02B2 // Inputs[2] // { // @2573 stack[-1] // @2574 stack[-2] // } 256E 5B JUMPDEST 256F 60 PUSH1 0x00 2571 60 PUSH1 0x20 2573 82 DUP3 2574 84 DUP5 2575 03 SUB 2576 12 SLT 2577 15 ISZERO 2578 61 PUSH2 0x2580 257B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @256F stack[0] = 0x00 } // Block ends with conditional jump to 0x2580, if !(stack[-2] - stack[-1] i< 0x20) label_257C: // Incoming jump from 0x257B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @257F memory[0x00:0x00] } 257C 60 PUSH1 0x00 257E 80 DUP1 257F FD *REVERT // Stack delta = +0 // Outputs[1] { @257F revert(memory[0x00:0x00]); } // Block terminates label_2580: // Incoming jump from 0x257B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @2582 msg.data[stack[-2]:stack[-2] + 0x20] // @2582 stack[-2] // @2583 stack[-4] // @2584 stack[-3] // } 2580 5B JUMPDEST 2581 50 POP 2582 35 CALLDATALOAD 2583 91 SWAP2 2584 90 SWAP1 2585 50 POP 2586 56 *JUMP // Stack delta = -3 // Outputs[1] { @2583 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2587: // Incoming call from 0x28C9, returns to 0x28CA // Incoming call from 0x2610, returns to 0x2611 // Incoming call from 0x28D7, returns to 0x2787 // Incoming call from 0x261E, returns to 0x261F // Incoming call from 0x25B9, returns to 0x25BA // Incoming call from 0x28AD, returns to 0x2787 // Incoming call from 0x2778, returns to 0x2779 // Incoming call from 0x27BC, returns to 0x27BD // Incoming call from 0x275C, returns to 0x1464 // Incoming call from 0x27AE, returns to 0x27AF // Inputs[2] // { // @2588 stack[-1] // @2589 msg.data[stack[-1]:stack[-1] + 0x20] // } 2587 5B JUMPDEST 2588 80 DUP1 2589 35 CALLDATALOAD 258A 60 PUSH1 0x01 258C 60 PUSH1 0x01 258E 60 PUSH1 0xa0 2590 1B SHL 2591 03 SUB 2592 81 DUP2 2593 16 AND 2594 81 DUP2 2595 14 EQ 2596 61 PUSH2 0x146b 2599 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2589 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x146b, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_259A: // Incoming jump from 0x2599, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @259D memory[0x00:0x00] } 259A 60 PUSH1 0x00 259C 80 DUP1 259D FD *REVERT // Stack delta = +0 // Outputs[1] { @259D revert(memory[0x00:0x00]); } // Block terminates label_259E: // Incoming call from 0x02E9, returns to 0x02EA // Incoming call from 0x03DA, returns to 0x03DB // Inputs[2] // { // @25A4 stack[-1] // @25A5 stack[-2] // } 259E 5B JUMPDEST 259F 60 PUSH1 0x00 25A1 80 DUP1 25A2 60 PUSH1 0x40 25A4 83 DUP4 25A5 85 DUP6 25A6 03 SUB 25A7 12 SLT 25A8 15 ISZERO 25A9 61 PUSH2 0x25b1 25AC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @259F stack[0] = 0x00 // @25A1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x25b1, if !(stack[-2] - stack[-1] i< 0x40) label_25AD: // Incoming jump from 0x25AC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25B0 memory[0x00:0x00] } 25AD 60 PUSH1 0x00 25AF 80 DUP1 25B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @25B0 revert(memory[0x00:0x00]); } // Block terminates label_25B1: // Incoming jump from 0x25AC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25B5 stack[-3] } 25B1 5B JUMPDEST 25B2 61 PUSH2 0x25ba 25B5 83 DUP4 25B6 61 PUSH2 0x2587 25B9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @25B2 stack[0] = 0x25ba // @25B5 stack[1] = stack[-3] // } // Block ends with call to 0x2587, returns to 0x25BA label_25BA: // Incoming return from call to 0x2587 at 0x25B9 // Inputs[5] // { // @25BB stack[-6] // @25BB stack[-1] // @25BE stack[-4] // @25C2 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @25C3 stack[-5] // } 25BA 5B JUMPDEST 25BB 94 SWAP5 25BC 60 PUSH1 0x20 25BE 93 SWAP4 25BF 90 SWAP1 25C0 93 SWAP4 25C1 01 ADD 25C2 35 CALLDATALOAD 25C3 93 SWAP4 25C4 50 POP 25C5 50 POP 25C6 50 POP 25C7 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @25BB stack[-6] = stack[-1] // @25C3 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_25C8: // Incoming call from 0x2786, returns to 0x2787 // Incoming call from 0x25F2, returns to 0x1464 // Inputs[2] // { // @25C9 stack[-1] // @25CA msg.data[stack[-1]:stack[-1] + 0x20] // } 25C8 5B JUMPDEST 25C9 80 DUP1 25CA 35 CALLDATALOAD 25CB 80 DUP1 25CC 15 ISZERO 25CD 15 ISZERO 25CE 81 DUP2 25CF 14 EQ 25D0 61 PUSH2 0x146b 25D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25CA stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x146b, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_25D4: // Incoming jump from 0x25D3, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @25D7 memory[0x00:0x00] } 25D4 60 PUSH1 0x00 25D6 80 DUP1 25D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @25D7 revert(memory[0x00:0x00]); } // Block terminates label_25D8: // Incoming call from 0x034F, returns to 0x0350 // Incoming call from 0x03BA, returns to 0x03BB // Inputs[2] // { // @25DD stack[-1] // @25DE stack[-2] // } 25D8 5B JUMPDEST 25D9 60 PUSH1 0x00 25DB 60 PUSH1 0x20 25DD 82 DUP3 25DE 84 DUP5 25DF 03 SUB 25E0 12 SLT 25E1 15 ISZERO 25E2 61 PUSH2 0x25ea 25E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25D9 stack[0] = 0x00 } // Block ends with conditional jump to 0x25ea, if !(stack[-2] - stack[-1] i< 0x20) label_25E6: // Incoming jump from 0x25E5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @25E9 memory[0x00:0x00] } 25E6 60 PUSH1 0x00 25E8 80 DUP1 25E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @25E9 revert(memory[0x00:0x00]); } // Block terminates label_25EA: // Incoming jump from 0x25E5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @25EE stack[-2] } 25EA 5B JUMPDEST 25EB 61 PUSH2 0x1464 25EE 82 DUP3 25EF 61 PUSH2 0x25c8 25F2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @25EB stack[0] = 0x1464 // @25EE stack[1] = stack[-2] // } // Block ends with call to 0x25c8, returns to 0x1464 label_25F3: // Incoming call from 0x039A, returns to 0x039B // Incoming call from 0x0402, returns to 0x0403 // Inputs[2] // { // @25FB stack[-1] // @25FC stack[-2] // } 25F3 5B JUMPDEST 25F4 60 PUSH1 0x00 25F6 80 DUP1 25F7 60 PUSH1 0x00 25F9 60 PUSH1 0x60 25FB 84 DUP5 25FC 86 DUP7 25FD 03 SUB 25FE 12 SLT 25FF 15 ISZERO 2600 61 PUSH2 0x2608 2603 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @25F4 stack[0] = 0x00 // @25F6 stack[1] = 0x00 // @25F7 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2608, if !(stack[-2] - stack[-1] i< 0x60) label_2604: // Incoming jump from 0x2603, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2607 memory[0x00:0x00] } 2604 60 PUSH1 0x00 2606 80 DUP1 2607 FD *REVERT // Stack delta = +0 // Outputs[1] { @2607 revert(memory[0x00:0x00]); } // Block terminates label_2608: // Incoming jump from 0x2603, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @260C stack[-4] } 2608 5B JUMPDEST 2609 61 PUSH2 0x2611 260C 84 DUP5 260D 61 PUSH2 0x2587 2610 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2609 stack[0] = 0x2611 // @260C stack[1] = stack[-4] // } // Block ends with call to 0x2587, returns to 0x2611 label_2611: // Incoming return from call to 0x2587 at 0x2610 // Inputs[3] // { // @2612 stack[-4] // @2612 stack[-1] // @2619 stack[-5] // } 2611 5B JUMPDEST 2612 92 SWAP3 2613 50 POP 2614 61 PUSH2 0x261f 2617 60 PUSH1 0x20 2619 85 DUP6 261A 01 ADD 261B 61 PUSH2 0x2587 261E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2612 stack[-4] = stack[-1] // @2614 stack[-1] = 0x261f // @261A stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x2587, returns to 0x261F label_261F: // Incoming return from call to 0x2587 at 0x261E // Inputs[8] // { // @2620 stack[-1] // @2620 stack[-3] // @2624 stack[-5] // @2626 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2627 stack[-2] // @262B stack[-6] // @262D stack[-7] // @262D stack[-4] // } 261F 5B JUMPDEST 2620 91 SWAP2 2621 50 POP 2622 60 PUSH1 0x40 2624 84 DUP5 2625 01 ADD 2626 35 CALLDATALOAD 2627 90 SWAP1 2628 50 POP 2629 92 SWAP3 262A 50 POP 262B 92 SWAP3 262C 50 POP 262D 92 SWAP3 262E 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2629 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @262B stack[-6] = stack[-1] // @262D stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_262F: // Incoming jump from 0x1F99 // Incoming jump from 0x265F // Incoming jump from 0x2687 // Inputs[1] { @2644 memory[0x00:0x24] } 262F 5B JUMPDEST 2630 63 PUSH4 0x4e487b71 2635 60 PUSH1 0xe0 2637 1B SHL 2638 60 PUSH1 0x00 263A 52 MSTORE 263B 60 PUSH1 0x41 263D 60 PUSH1 0x04 263F 52 MSTORE 2640 60 PUSH1 0x24 2642 60 PUSH1 0x00 2644 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @263A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @263F memory[0x04:0x24] = 0x41 // @2644 revert(memory[0x00:0x24]); // } // Block terminates label_2645: // Incoming call from 0x27FF, returns to 0x2800 // Incoming call from 0x2703, returns to 0x1807 // Inputs[1] { @2652 stack[-2] } 2645 5B JUMPDEST 2646 60 PUSH1 0x00 2648 67 PUSH8 0xffffffffffffffff 2651 80 DUP1 2652 84 DUP5 2653 11 GT 2654 15 ISZERO 2655 61 PUSH2 0x2660 2658 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2646 stack[0] = 0x00 // @2648 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2660, if !(stack[-2] > 0xffffffffffffffff) label_2659: // Incoming jump from 0x2658, if not !(stack[-2] > 0xffffffffffffffff) 2659 61 PUSH2 0x2660 265C 61 PUSH2 0x262f 265F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2659 stack[0] = 0x2660 } // Block ends with unconditional jump to 0x262f label_2660: // Incoming jump from 0x2658, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @2663 memory[0x40:0x60] // @2666 stack[-4] // @2675 stack[-1] // } 2660 5B JUMPDEST 2661 60 PUSH1 0x40 2663 51 MLOAD 2664 60 PUSH1 0x1f 2666 85 DUP6 2667 01 ADD 2668 60 PUSH1 0x1f 266A 19 NOT 266B 90 SWAP1 266C 81 DUP2 266D 16 AND 266E 60 PUSH1 0x3f 2670 01 ADD 2671 16 AND 2672 81 DUP2 2673 01 ADD 2674 90 SWAP1 2675 82 DUP3 2676 82 DUP3 2677 11 GT 2678 81 DUP2 2679 83 DUP4 267A 10 LT 267B 17 OR 267C 15 ISZERO 267D 61 PUSH2 0x2688 2680 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2674 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @2674 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x2688, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_2681: // Incoming jump from 0x2680, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 2681 61 PUSH2 0x2688 2684 61 PUSH2 0x262f 2687 56 *JUMP // Stack delta = +1 // Outputs[1] { @2681 stack[0] = 0x2688 } // Block ends with unconditional jump to 0x262f label_2688: // Incoming jump from 0x2680, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @2689 stack[-2] // @268D stack[-1] // @268E stack[-4] // @2690 stack[-6] // @2693 stack[-7] // @2695 stack[-5] // } 2688 5B JUMPDEST 2689 81 DUP2 268A 60 PUSH1 0x40 268C 52 MSTORE 268D 80 DUP1 268E 93 SWAP4 268F 50 POP 2690 85 DUP6 2691 81 DUP2 2692 52 MSTORE 2693 86 DUP7 2694 86 DUP7 2695 86 DUP7 2696 01 ADD 2697 11 GT 2698 15 ISZERO 2699 61 PUSH2 0x26a1 269C 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @268C memory[0x40:0x60] = stack[-2] // @268E stack[-4] = stack[-1] // @2692 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x26a1, if !(stack[-5] + stack[-6] > stack[-7]) label_269D: // Incoming jump from 0x269C, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @26A0 memory[0x00:0x00] } 269D 60 PUSH1 0x00 269F 80 DUP1 26A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @26A0 revert(memory[0x00:0x00]); } // Block terminates label_26A1: // Incoming jump from 0x269C, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @26A2 stack[-6] // @26A3 stack[-5] // @26A6 stack[-1] // @26A8 msg.data[stack[-5]:stack[-5] + stack[-6]] // @26B5 stack[-8] // @26B5 stack[-4] // @26B6 stack[-7] // } 26A1 5B JUMPDEST 26A2 85 DUP6 26A3 85 DUP6 26A4 60 PUSH1 0x20 26A6 83 DUP4 26A7 01 ADD 26A8 37 CALLDATACOPY 26A9 60 PUSH1 0x00 26AB 60 PUSH1 0x20 26AD 87 DUP8 26AE 83 DUP4 26AF 01 ADD 26B0 01 ADD 26B1 52 MSTORE 26B2 50 POP 26B3 50 POP 26B4 50 POP 26B5 93 SWAP4 26B6 92 SWAP3 26B7 50 POP 26B8 50 POP 26B9 50 POP 26BA 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @26A8 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @26B1 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @26B5 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_26BB: // Incoming call from 0x0483, returns to 0x0484 // Inputs[2] // { // @26C0 stack[-1] // @26C1 stack[-2] // } 26BB 5B JUMPDEST 26BC 60 PUSH1 0x00 26BE 60 PUSH1 0x20 26C0 82 DUP3 26C1 84 DUP5 26C2 03 SUB 26C3 12 SLT 26C4 15 ISZERO 26C5 61 PUSH2 0x26cd 26C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26BC stack[0] = 0x00 } // Block ends with conditional jump to 0x26cd, if !(stack[-2] - stack[-1] i< 0x20) label_26C9: // Incoming jump from 0x26C8, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @26CC memory[0x00:0x00] } 26C9 60 PUSH1 0x00 26CB 80 DUP1 26CC FD *REVERT // Stack delta = +0 // Outputs[1] { @26CC revert(memory[0x00:0x00]); } // Block terminates label_26CD: // Incoming jump from 0x26C8, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @26CE stack[-2] // @26CF msg.data[stack[-2]:stack[-2] + 0x20] // } 26CD 5B JUMPDEST 26CE 81 DUP2 26CF 35 CALLDATALOAD 26D0 67 PUSH8 0xffffffffffffffff 26D9 81 DUP2 26DA 11 GT 26DB 15 ISZERO 26DC 61 PUSH2 0x26e4 26DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26CF stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x26e4, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_26E0: // Incoming jump from 0x26DF, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @26E3 memory[0x00:0x00] } 26E0 60 PUSH1 0x00 26E2 80 DUP1 26E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @26E3 revert(memory[0x00:0x00]); } // Block terminates label_26E4: // Incoming jump from 0x26DF, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @26E5 stack[-3] // @26E6 stack[-1] // @26EB stack[-4] // } 26E4 5B JUMPDEST 26E5 82 DUP3 26E6 01 ADD 26E7 60 PUSH1 0x1f 26E9 81 DUP2 26EA 01 ADD 26EB 84 DUP5 26EC 13 SGT 26ED 61 PUSH2 0x26f5 26F0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26E6 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x26f5, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_26F1: // Incoming jump from 0x26F0, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @26F4 memory[0x00:0x00] } 26F1 60 PUSH1 0x00 26F3 80 DUP1 26F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @26F4 revert(memory[0x00:0x00]); } // Block terminates label_26F5: // Incoming jump from 0x26F0, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @26F9 stack[-4] // @26FA stack[-1] // @26FB msg.data[stack[-1]:stack[-1] + 0x20] // } 26F5 5B JUMPDEST 26F6 61 PUSH2 0x1807 26F9 84 DUP5 26FA 82 DUP3 26FB 35 CALLDATALOAD 26FC 60 PUSH1 0x20 26FE 84 DUP5 26FF 01 ADD 2700 61 PUSH2 0x2645 2703 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @26F6 stack[0] = 0x1807 // @26F9 stack[1] = stack[-4] // @26FB stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @26FF stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2645, returns to 0x1807 label_2704: // Incoming jump from 0x1591 // Incoming jump from 0x0F6C // Incoming jump from 0x1108 // Incoming jump from 0x1057 // Inputs[1] { @2719 memory[0x00:0x24] } 2704 5B JUMPDEST 2705 63 PUSH4 0x4e487b71 270A 60 PUSH1 0xe0 270C 1B SHL 270D 60 PUSH1 0x00 270F 52 MSTORE 2710 60 PUSH1 0x21 2712 60 PUSH1 0x04 2714 52 MSTORE 2715 60 PUSH1 0x24 2717 60 PUSH1 0x00 2719 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @270F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2714 memory[0x04:0x24] = 0x21 // @2719 revert(memory[0x00:0x24]); // } // Block terminates label_271A: // Incoming call from 0x04E7, returns to 0x026C // Inputs[2] // { // @271D stack[-1] // @2721 stack[-2] // } 271A 5B JUMPDEST 271B 60 PUSH1 0x20 271D 81 DUP2 271E 01 ADD 271F 60 PUSH1 0x03 2721 83 DUP4 2722 10 LT 2723 61 PUSH2 0x273c 2726 57 *JUMPI // Stack delta = +1 // Outputs[1] { @271E stack[0] = stack[-1] + 0x20 } // Block ends with conditional jump to 0x273c, if stack[-2] < 0x03 label_2727: // Incoming jump from 0x2726, if not stack[-2] < 0x03 // Inputs[1] { @273B memory[0x00:0x24] } 2727 63 PUSH4 0x4e487b71 272C 60 PUSH1 0xe0 272E 1B SHL 272F 60 PUSH1 0x00 2731 52 MSTORE 2732 60 PUSH1 0x21 2734 60 PUSH1 0x04 2736 52 MSTORE 2737 60 PUSH1 0x24 2739 60 PUSH1 0x00 273B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2731 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2736 memory[0x04:0x24] = 0x21 // @273B revert(memory[0x00:0x24]); // } // Block terminates label_273C: // Incoming jump from 0x2726, if stack[-2] < 0x03 // Inputs[4] // { // @273D stack[-3] // @273D stack[-1] // @273E stack[-2] // @2740 stack[-4] // } 273C 5B JUMPDEST 273D 91 SWAP2 273E 90 SWAP1 273F 52 MSTORE 2740 90 SWAP1 2741 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @273F memory[stack[-2]:stack[-2] + 0x20] = stack[-3] // @2740 stack[-4] = stack[-1] // } // Block ends with unconditional jump to stack[-4] label_2742: // Incoming call from 0x0537, returns to 0x0538 // Incoming call from 0x06F8, returns to 0x06F9 // Inputs[2] // { // @2747 stack[-1] // @2748 stack[-2] // } 2742 5B JUMPDEST 2743 60 PUSH1 0x00 2745 60 PUSH1 0x20 2747 82 DUP3 2748 84 DUP5 2749 03 SUB 274A 12 SLT 274B 15 ISZERO 274C 61 PUSH2 0x2754 274F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2743 stack[0] = 0x00 } // Block ends with conditional jump to 0x2754, if !(stack[-2] - stack[-1] i< 0x20) label_2750: // Incoming jump from 0x274F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2753 memory[0x00:0x00] } 2750 60 PUSH1 0x00 2752 80 DUP1 2753 FD *REVERT // Stack delta = +0 // Outputs[1] { @2753 revert(memory[0x00:0x00]); } // Block terminates label_2754: // Incoming jump from 0x274F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2758 stack[-2] } 2754 5B JUMPDEST 2755 61 PUSH2 0x1464 2758 82 DUP3 2759 61 PUSH2 0x2587 275C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2755 stack[0] = 0x1464 // @2758 stack[1] = stack[-2] // } // Block ends with call to 0x2587, returns to 0x1464 label_275D: // Incoming jump from 0x05A4 // Inputs[2] // { // @2763 stack[-1] // @2764 stack[-2] // } 275D 5B JUMPDEST 275E 60 PUSH1 0x00 2760 80 DUP1 2761 60 PUSH1 0x40 2763 83 DUP4 2764 85 DUP6 2765 03 SUB 2766 12 SLT 2767 15 ISZERO 2768 61 PUSH2 0x2770 276B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @275E stack[0] = 0x00 // @2760 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2770, if !(stack[-2] - stack[-1] i< 0x40) label_276C: // Incoming jump from 0x276B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @276F memory[0x00:0x00] } 276C 60 PUSH1 0x00 276E 80 DUP1 276F FD *REVERT // Stack delta = +0 // Outputs[1] { @276F revert(memory[0x00:0x00]); } // Block terminates label_2770: // Incoming jump from 0x276B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2774 stack[-3] } 2770 5B JUMPDEST 2771 61 PUSH2 0x2779 2774 83 DUP4 2775 61 PUSH2 0x2587 2778 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2771 stack[0] = 0x2779 // @2774 stack[1] = stack[-3] // } // Block ends with call to 0x2587, returns to 0x2779 label_2779: // Incoming return from call to 0x2587 at 0x2778 // Inputs[3] // { // @277A stack[-1] // @277A stack[-3] // @2781 stack[-4] // } 2779 5B JUMPDEST 277A 91 SWAP2 277B 50 POP 277C 61 PUSH2 0x2787 277F 60 PUSH1 0x20 2781 84 DUP5 2782 01 ADD 2783 61 PUSH2 0x25c8 2786 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @277A stack[-3] = stack[-1] // @277C stack[-1] = 0x2787 // @2782 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x25c8, returns to 0x2787 label_2787: // Incoming return from call to 0x25C8 at 0x2786 // Incoming return from call to 0x2587 at 0x28D7 // Incoming return from call to 0x2587 at 0x28AD // Inputs[6] // { // @2788 stack[-1] // @2788 stack[-2] // @278A stack[-5] // @278C stack[-6] // @278C stack[-3] // @278D stack[-4] // } 2787 5B JUMPDEST 2788 90 SWAP1 2789 50 POP 278A 92 SWAP3 278B 50 POP 278C 92 SWAP3 278D 90 SWAP1 278E 50 POP 278F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @278A stack[-5] = stack[-1] // @278C stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2790: // Incoming call from 0x05DA, returns to 0x05DB // Inputs[2] // { // @2799 stack[-1] // @279A stack[-2] // } 2790 5B JUMPDEST 2791 60 PUSH1 0x00 2793 80 DUP1 2794 60 PUSH1 0x00 2796 80 DUP1 2797 60 PUSH1 0x80 2799 85 DUP6 279A 87 DUP8 279B 03 SUB 279C 12 SLT 279D 15 ISZERO 279E 61 PUSH2 0x27a6 27A1 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2791 stack[0] = 0x00 // @2793 stack[1] = 0x00 // @2794 stack[2] = 0x00 // @2796 stack[3] = 0x00 // } // Block ends with conditional jump to 0x27a6, if !(stack[-2] - stack[-1] i< 0x80) label_27A2: // Incoming jump from 0x27A1, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @27A5 memory[0x00:0x00] } 27A2 60 PUSH1 0x00 27A4 80 DUP1 27A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @27A5 revert(memory[0x00:0x00]); } // Block terminates label_27A6: // Incoming jump from 0x27A1, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @27AA stack[-5] } 27A6 5B JUMPDEST 27A7 61 PUSH2 0x27af 27AA 85 DUP6 27AB 61 PUSH2 0x2587 27AE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @27A7 stack[0] = 0x27af // @27AA stack[1] = stack[-5] // } // Block ends with call to 0x2587, returns to 0x27AF label_27AF: // Incoming return from call to 0x2587 at 0x27AE // Inputs[3] // { // @27B0 stack[-5] // @27B0 stack[-1] // @27B7 stack[-6] // } 27AF 5B JUMPDEST 27B0 93 SWAP4 27B1 50 POP 27B2 61 PUSH2 0x27bd 27B5 60 PUSH1 0x20 27B7 86 DUP7 27B8 01 ADD 27B9 61 PUSH2 0x2587 27BC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @27B0 stack[-5] = stack[-1] // @27B2 stack[-1] = 0x27bd // @27B8 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x2587, returns to 0x27BD label_27BD: // Incoming return from call to 0x2587 at 0x27BC // Inputs[6] // { // @27BE stack[-4] // @27BE stack[-1] // @27C2 stack[-6] // @27C4 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @27C5 stack[-3] // @27CB msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 27BD 5B JUMPDEST 27BE 92 SWAP3 27BF 50 POP 27C0 60 PUSH1 0x40 27C2 85 DUP6 27C3 01 ADD 27C4 35 CALLDATALOAD 27C5 91 SWAP2 27C6 50 POP 27C7 60 PUSH1 0x60 27C9 85 DUP6 27CA 01 ADD 27CB 35 CALLDATALOAD 27CC 67 PUSH8 0xffffffffffffffff 27D5 81 DUP2 27D6 11 GT 27D7 15 ISZERO 27D8 61 PUSH2 0x27e0 27DB 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @27BE stack[-4] = stack[-1] // @27C5 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @27CB stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x27e0, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_27DC: // Incoming jump from 0x27DB, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @27DF memory[0x00:0x00] } 27DC 60 PUSH1 0x00 27DE 80 DUP1 27DF FD *REVERT // Stack delta = +0 // Outputs[1] { @27DF revert(memory[0x00:0x00]); } // Block terminates label_27E0: // Incoming jump from 0x27DB, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @27E1 stack[-6] // @27E2 stack[-1] // @27E7 stack[-7] // } 27E0 5B JUMPDEST 27E1 85 DUP6 27E2 01 ADD 27E3 60 PUSH1 0x1f 27E5 81 DUP2 27E6 01 ADD 27E7 87 DUP8 27E8 13 SGT 27E9 61 PUSH2 0x27f1 27EC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @27E2 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x27f1, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_27ED: // Incoming jump from 0x27EC, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @27F0 memory[0x00:0x00] } 27ED 60 PUSH1 0x00 27EF 80 DUP1 27F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @27F0 revert(memory[0x00:0x00]); } // Block terminates label_27F1: // Incoming jump from 0x27EC, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @27F5 stack[-7] // @27F6 stack[-1] // @27F7 msg.data[stack[-1]:stack[-1] + 0x20] // } 27F1 5B JUMPDEST 27F2 61 PUSH2 0x2800 27F5 87 DUP8 27F6 82 DUP3 27F7 35 CALLDATALOAD 27F8 60 PUSH1 0x20 27FA 84 DUP5 27FB 01 ADD 27FC 61 PUSH2 0x2645 27FF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @27F2 stack[0] = 0x2800 // @27F5 stack[1] = stack[-7] // @27F7 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @27FB stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2645, returns to 0x2800 label_2800: // Incoming return from call to 0x2645 at 0x27FF // Inputs[8] // { // @2801 stack[-1] // @2801 stack[-3] // @2804 stack[-6] // @2805 stack[-9] // @2806 stack[-5] // @2807 stack[-8] // @2809 stack[-7] // @2809 stack[-4] // } 2800 5B JUMPDEST 2801 91 SWAP2 2802 50 POP 2803 50 POP 2804 92 SWAP3 2805 95 SWAP6 2806 91 SWAP2 2807 94 SWAP5 2808 50 POP 2809 92 SWAP3 280A 50 POP 280B 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2804 stack[-6] = stack[-1] // @2805 stack[-9] = stack[-6] // @2807 stack[-8] = stack[-5] // @2809 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_280C: // Incoming call from 0x05ED, returns to 0x05EE // Inputs[2] // { // @2814 stack[-1] // @2815 stack[-2] // } 280C 5B JUMPDEST 280D 60 PUSH1 0x00 280F 80 DUP1 2810 60 PUSH1 0x00 2812 60 PUSH1 0x40 2814 84 DUP5 2815 86 DUP7 2816 03 SUB 2817 12 SLT 2818 15 ISZERO 2819 61 PUSH2 0x2821 281C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @280D stack[0] = 0x00 // @280F stack[1] = 0x00 // @2810 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2821, if !(stack[-2] - stack[-1] i< 0x40) label_281D: // Incoming jump from 0x281C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2820 memory[0x00:0x00] } 281D 60 PUSH1 0x00 281F 80 DUP1 2820 FD *REVERT // Stack delta = +0 // Outputs[1] { @2820 revert(memory[0x00:0x00]); } // Block terminates label_2821: // Incoming jump from 0x281C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @2822 stack[-4] // @2823 msg.data[stack[-4]:stack[-4] + 0x20] // @2824 stack[-3] // @282A msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2821 5B JUMPDEST 2822 83 DUP4 2823 35 CALLDATALOAD 2824 92 SWAP3 2825 50 POP 2826 60 PUSH1 0x20 2828 84 DUP5 2829 01 ADD 282A 35 CALLDATALOAD 282B 67 PUSH8 0xffffffffffffffff 2834 80 DUP1 2835 82 DUP3 2836 11 GT 2837 15 ISZERO 2838 61 PUSH2 0x2840 283B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2824 stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @282A stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @282B stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2840, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_283C: // Incoming jump from 0x283B, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @283F memory[0x00:0x00] } 283C 60 PUSH1 0x00 283E 80 DUP1 283F FD *REVERT // Stack delta = +0 // Outputs[1] { @283F revert(memory[0x00:0x00]); } // Block terminates label_2840: // Incoming jump from 0x283B, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2841 stack[-2] // @2842 stack[-6] // @2846 stack[-7] // } 2840 5B JUMPDEST 2841 81 DUP2 2842 86 DUP7 2843 01 ADD 2844 91 SWAP2 2845 50 POP 2846 86 DUP7 2847 60 PUSH1 0x1f 2849 83 DUP4 284A 01 ADD 284B 12 SLT 284C 61 PUSH2 0x2854 284F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2844 stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x2854, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_2850: // Incoming jump from 0x284F, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @2853 memory[0x00:0x00] } 2850 60 PUSH1 0x00 2852 80 DUP1 2853 FD *REVERT // Stack delta = +0 // Outputs[1] { @2853 revert(memory[0x00:0x00]); } // Block terminates label_2854: // Incoming jump from 0x284F, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @2855 stack[-2] // @2856 msg.data[stack[-2]:stack[-2] + 0x20] // @2857 stack[-1] // } 2854 5B JUMPDEST 2855 81 DUP2 2856 35 CALLDATALOAD 2857 81 DUP2 2858 81 DUP2 2859 11 GT 285A 15 ISZERO 285B 61 PUSH2 0x2863 285E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2856 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2863, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_285F: // Incoming jump from 0x285E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @2862 memory[0x00:0x00] } 285F 60 PUSH1 0x00 2861 80 DUP1 2862 FD *REVERT // Stack delta = +0 // Outputs[1] { @2862 revert(memory[0x00:0x00]); } // Block terminates label_2863: // Incoming jump from 0x285E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @2864 stack[-8] // @2867 stack[-1] // @286B stack[-3] // } 2863 5B JUMPDEST 2864 87 DUP8 2865 60 PUSH1 0x20 2867 82 DUP3 2868 60 PUSH1 0x05 286A 1B SHL 286B 85 DUP6 286C 01 ADD 286D 01 ADD 286E 11 GT 286F 15 ISZERO 2870 61 PUSH2 0x2878 2873 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2878, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) label_2874: // Incoming jump from 0x2873, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[1] { @2877 memory[0x00:0x00] } 2874 60 PUSH1 0x00 2876 80 DUP1 2877 FD *REVERT // Stack delta = +0 // Outputs[1] { @2877 revert(memory[0x00:0x00]); } // Block terminates label_2878: // Incoming jump from 0x2873, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[8] // { // @287B stack[-3] // @287D stack[-5] // @287F stack[-1] // @2880 stack[-4] // @2885 stack[-7] // @2887 stack[-8] // @2889 stack[-9] // @2889 stack[-6] // } 2878 5B JUMPDEST 2879 60 PUSH1 0x20 287B 83 DUP4 287C 01 ADD 287D 94 SWAP5 287E 50 POP 287F 80 DUP1 2880 93 SWAP4 2881 50 POP 2882 50 POP 2883 50 POP 2884 50 POP 2885 92 SWAP3 2886 50 POP 2887 92 SWAP3 2888 50 POP 2889 92 SWAP3 288A 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @2885 stack[-7] = stack[-1] // @2887 stack[-8] = stack[-3] + 0x20 // @2889 stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] label_288B: // Incoming call from 0x060D, returns to 0x060E // Inputs[2] // { // @2891 stack[-1] // @2892 stack[-2] // } 288B 5B JUMPDEST 288C 60 PUSH1 0x00 288E 80 DUP1 288F 60 PUSH1 0x40 2891 83 DUP4 2892 85 DUP6 2893 03 SUB 2894 12 SLT 2895 15 ISZERO 2896 61 PUSH2 0x289e 2899 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @288C stack[0] = 0x00 // @288E stack[1] = 0x00 // } // Block ends with conditional jump to 0x289e, if !(stack[-2] - stack[-1] i< 0x40) label_289A: // Incoming jump from 0x2899, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @289D memory[0x00:0x00] } 289A 60 PUSH1 0x00 289C 80 DUP1 289D FD *REVERT // Stack delta = +0 // Outputs[1] { @289D revert(memory[0x00:0x00]); } // Block terminates label_289E: // Incoming jump from 0x2899, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @289F stack[-3] // @28A0 msg.data[stack[-3]:stack[-3] + 0x20] // @28A1 stack[-2] // } 289E 5B JUMPDEST 289F 82 DUP3 28A0 35 CALLDATALOAD 28A1 91 SWAP2 28A2 50 POP 28A3 61 PUSH2 0x2787 28A6 60 PUSH1 0x20 28A8 84 DUP5 28A9 01 ADD 28AA 61 PUSH2 0x2587 28AD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @28A1 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @28A3 stack[0] = 0x2787 // @28A9 stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x2587, returns to 0x2787 label_28AE: // Incoming jump from 0x0699 // Inputs[2] // { // @28B4 stack[-1] // @28B5 stack[-2] // } 28AE 5B JUMPDEST 28AF 60 PUSH1 0x00 28B1 80 DUP1 28B2 60 PUSH1 0x40 28B4 83 DUP4 28B5 85 DUP6 28B6 03 SUB 28B7 12 SLT 28B8 15 ISZERO 28B9 61 PUSH2 0x28c1 28BC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28AF stack[0] = 0x00 // @28B1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x28c1, if !(stack[-2] - stack[-1] i< 0x40) label_28BD: // Incoming jump from 0x28BC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28C0 memory[0x00:0x00] } 28BD 60 PUSH1 0x00 28BF 80 DUP1 28C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @28C0 revert(memory[0x00:0x00]); } // Block terminates label_28C1: // Incoming jump from 0x28BC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28C5 stack[-3] } 28C1 5B JUMPDEST 28C2 61 PUSH2 0x28ca 28C5 83 DUP4 28C6 61 PUSH2 0x2587 28C9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @28C2 stack[0] = 0x28ca // @28C5 stack[1] = stack[-3] // } // Block ends with call to 0x2587, returns to 0x28CA label_28CA: // Incoming return from call to 0x2587 at 0x28C9 // Inputs[3] // { // @28CB stack[-1] // @28CB stack[-3] // @28D2 stack[-4] // } 28CA 5B JUMPDEST 28CB 91 SWAP2 28CC 50 POP 28CD 61 PUSH2 0x2787 28D0 60 PUSH1 0x20 28D2 84 DUP5 28D3 01 ADD 28D4 61 PUSH2 0x2587 28D7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @28CB stack[-3] = stack[-1] // @28CD stack[-1] = 0x2787 // @28D3 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x2587, returns to 0x2787 label_28D8: // Incoming call from 0x0718, returns to 0x0719 // Inputs[2] // { // @28DD stack[-1] // @28DE stack[-2] // } 28D8 5B JUMPDEST 28D9 60 PUSH1 0x00 28DB 60 PUSH1 0x20 28DD 82 DUP3 28DE 84 DUP5 28DF 03 SUB 28E0 12 SLT 28E1 15 ISZERO 28E2 61 PUSH2 0x28ea 28E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28D9 stack[0] = 0x00 } // Block ends with conditional jump to 0x28ea, if !(stack[-2] - stack[-1] i< 0x20) label_28E6: // Incoming jump from 0x28E5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @28E9 memory[0x00:0x00] } 28E6 60 PUSH1 0x00 28E8 80 DUP1 28E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @28E9 revert(memory[0x00:0x00]); } // Block terminates label_28EA: // Incoming jump from 0x28E5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @28EB stack[-2] // @28EC msg.data[stack[-2]:stack[-2] + 0x20] // } 28EA 5B JUMPDEST 28EB 81 DUP2 28EC 35 CALLDATALOAD 28ED 60 PUSH1 0x03 28EF 81 DUP2 28F0 10 LT 28F1 61 PUSH2 0x1464 28F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28EC stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1464, if msg.data[stack[-2]:stack[-2] + 0x20] < 0x03 label_28F5: // Incoming jump from 0x28F4, if not msg.data[stack[-2]:stack[-2] + 0x20] < 0x03 // Inputs[1] { @28F8 memory[0x00:0x00] } 28F5 60 PUSH1 0x00 28F7 80 DUP1 28F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @28F8 revert(memory[0x00:0x00]); } // Block terminates label_28F9: // Incoming call from 0x1F30, returns to 0x073E // Incoming call from 0x073D, returns to 0x073E // Incoming call from 0x2442, returns to 0x2443 // Incoming call from 0x13FF, returns to 0x1400 // Incoming call from 0x0769, returns to 0x076A // Incoming call from 0x13D3, returns to 0x13D4 // Incoming call from 0x0EDE, returns to 0x073E // Inputs[1] { @28FC stack[-1] } 28F9 5B JUMPDEST 28FA 60 PUSH1 0x01 28FC 81 DUP2 28FD 81 DUP2 28FE 1C SHR 28FF 90 SWAP1 2900 82 DUP3 2901 16 AND 2902 80 DUP1 2903 61 PUSH2 0x290d 2906 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28FF stack[0] = stack[-1] >> 0x01 // @2901 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x290d, if stack[-1] & 0x01 label_2907: // Incoming jump from 0x2906, if not stack[-1] & 0x01 // Inputs[2] // { // @2909 stack[-2] // @2912 stack[-1] // } 2907 60 PUSH1 0x7f 2909 82 DUP3 290A 16 AND 290B 91 SWAP2 290C 50 POP 290D 5B JUMPDEST 290E 60 PUSH1 0x20 2910 82 DUP3 2911 10 LT 2912 81 DUP2 2913 14 EQ 2914 15 ISZERO 2915 61 PUSH2 0x292e 2918 57 *JUMPI // Stack delta = +0 // Outputs[1] { @290B stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x292e, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2919: // Incoming jump from 0x2918, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2918, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @292D memory[0x00:0x24] } 2919 63 PUSH4 0x4e487b71 291E 60 PUSH1 0xe0 2920 1B SHL 2921 60 PUSH1 0x00 2923 52 MSTORE 2924 60 PUSH1 0x22 2926 60 PUSH1 0x04 2928 52 MSTORE 2929 60 PUSH1 0x24 292B 60 PUSH1 0x00 292D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2923 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2928 memory[0x04:0x24] = 0x22 // @292D revert(memory[0x00:0x24]); // } // Block terminates label_292E: // Incoming jump from 0x2918, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2918, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @2930 stack[-2] // @2930 stack[-4] // @2931 stack[-3] // } 292E 5B JUMPDEST 292F 50 POP 2930 91 SWAP2 2931 90 SWAP1 2932 50 POP 2933 56 *JUMP // Stack delta = -3 // Outputs[1] { @2930 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2934: // Incoming call from 0x0B33, returns to 0x0836 // Incoming call from 0x12E5, returns to 0x0836 // Incoming call from 0x0D11, returns to 0x0836 // Incoming call from 0x09A0, returns to 0x0836 // Incoming call from 0x0EC3, returns to 0x0836 // Incoming call from 0x0A4F, returns to 0x0836 // Incoming call from 0x149F, returns to 0x0836 // Incoming call from 0x09D5, returns to 0x0836 // Incoming call from 0x14D4, returns to 0x0836 // Incoming call from 0x0E07, returns to 0x0836 // Incoming call from 0x1572, returns to 0x0836 // Incoming call from 0x0DCF, returns to 0x0836 // Inputs[2] // { // @2938 stack[-1] // @2967 stack[-2] // } 2934 5B JUMPDEST 2935 60 PUSH1 0x20 2937 80 DUP1 2938 82 DUP3 2939 52 MSTORE 293A 81 DUP2 293B 81 DUP2 293C 01 ADD 293D 52 MSTORE 293E 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 295F 60 PUSH1 0x40 2961 82 DUP3 2962 01 ADD 2963 52 MSTORE 2964 60 PUSH1 0x60 2966 01 ADD 2967 90 SWAP1 2968 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2939 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @293D memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @2963 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2967 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2969: // Incoming call from 0x0F0F, returns to 0x0836 // Inputs[2] // { // @296D stack[-1] // @29B8 stack[-2] // } 2969 5B JUMPDEST 296A 60 PUSH1 0x20 296C 80 DUP1 296D 82 DUP3 296E 52 MSTORE 296F 60 PUSH1 0x31 2971 90 SWAP1 2972 82 DUP3 2973 01 ADD 2974 52 MSTORE 2975 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2996 60 PUSH1 0x40 2998 82 DUP3 2999 01 ADD 299A 52 MSTORE 299B 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 29AD 60 PUSH1 0x7a 29AF 1B SHL 29B0 60 PUSH1 0x60 29B2 82 DUP3 29B3 01 ADD 29B4 52 MSTORE 29B5 60 PUSH1 0x80 29B7 01 ADD 29B8 90 SWAP1 29B9 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @296E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2974 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x31 // @299A memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @29B4 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x1ddb995c881b9bdc88185c1c1c9bdd9959 << 0x7a // @29B8 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_29BA: // Incoming jump from 0x1E64 // Incoming jump from 0x0CCF // Incoming jump from 0x2005 // Incoming jump from 0x237D // Incoming jump from 0x239E // Inputs[1] { @29CF memory[0x00:0x24] } 29BA 5B JUMPDEST 29BB 63 PUSH4 0x4e487b71 29C0 60 PUSH1 0xe0 29C2 1B SHL 29C3 60 PUSH1 0x00 29C5 52 MSTORE 29C6 60 PUSH1 0x32 29C8 60 PUSH1 0x04 29CA 52 MSTORE 29CB 60 PUSH1 0x24 29CD 60 PUSH1 0x00 29CF FD *REVERT // Stack delta = +0 // Outputs[3] // { // @29C5 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @29CA memory[0x04:0x24] = 0x32 // @29CF revert(memory[0x00:0x24]); // } // Block terminates label_29D0: // Incoming call from 0x16E2, returns to 0x0836 // Incoming call from 0x1D39, returns to 0x0836 // Incoming call from 0x0F44, returns to 0x0836 // Inputs[2] // { // @29D4 stack[-1] // @29F8 stack[-2] // } 29D0 5B JUMPDEST 29D1 60 PUSH1 0x20 29D3 80 DUP1 29D4 82 DUP3 29D5 52 MSTORE 29D6 60 PUSH1 0x10 29D8 90 SWAP1 29D9 82 DUP3 29DA 01 ADD 29DB 52 MSTORE 29DC 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 29ED 60 PUSH1 0x82 29EF 1B SHL 29F0 60 PUSH1 0x40 29F2 82 DUP3 29F3 01 ADD 29F4 52 MSTORE 29F5 60 PUSH1 0x60 29F7 01 ADD 29F8 90 SWAP1 29F9 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @29D5 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @29DB memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x10 // @29F4 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @29F8 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_29FA: // Incoming jump from 0x2A22 // Incoming jump from 0x2A73 // Incoming jump from 0x2A41 // Incoming jump from 0x2A5A // Inputs[1] { @2A0F memory[0x00:0x24] } 29FA 5B JUMPDEST 29FB 63 PUSH4 0x4e487b71 2A00 60 PUSH1 0xe0 2A02 1B SHL 2A03 60 PUSH1 0x00 2A05 52 MSTORE 2A06 60 PUSH1 0x11 2A08 60 PUSH1 0x04 2A0A 52 MSTORE 2A0B 60 PUSH1 0x24 2A0D 60 PUSH1 0x00 2A0F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2A05 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2A0A memory[0x04:0x24] = 0x11 // @2A0F revert(memory[0x00:0x24]); // } // Block terminates label_2A10: // Incoming call from 0x1FF0, returns to 0x1FF1 // Incoming call from 0x13A0, returns to 0x1297 // Incoming call from 0x0FCE, returns to 0x0FCF // Incoming call from 0x11DF, returns to 0x11E0 // Incoming call from 0x1296, returns to 0x1297 // Incoming call from 0x1341, returns to 0x1342 // Inputs[2] // { // @2A13 stack[-2] // @2A15 stack[-1] // } 2A10 5B JUMPDEST 2A11 60 PUSH1 0x00 2A13 82 DUP3 2A14 19 NOT 2A15 82 DUP3 2A16 11 GT 2A17 15 ISZERO 2A18 61 PUSH2 0x2a23 2A1B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A11 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a23, if !(stack[-1] > ~stack[-2]) label_2A1C: // Incoming jump from 0x2A1B, if not !(stack[-1] > ~stack[-2]) 2A1C 61 PUSH2 0x2a23 2A1F 61 PUSH2 0x29fa 2A22 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A1C stack[0] = 0x2a23 } // Block ends with unconditional jump to 0x29fa label_2A23: // Incoming jump from 0x2A1B, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2A25 stack[-3] // @2A25 stack[-2] // @2A26 stack[-4] // } 2A23 5B JUMPDEST 2A24 50 POP 2A25 01 ADD 2A26 90 SWAP1 2A27 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A26 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2A28: // Incoming call from 0x123A, returns to 0x123B // Inputs[2] // { // @2A2B stack[-1] // @2A30 stack[-2] // } 2A28 5B JUMPDEST 2A29 60 PUSH1 0x00 2A2B 81 DUP2 2A2C 60 PUSH1 0x00 2A2E 19 NOT 2A2F 04 DIV 2A30 83 DUP4 2A31 11 GT 2A32 82 DUP3 2A33 15 ISZERO 2A34 15 ISZERO 2A35 16 AND 2A36 15 ISZERO 2A37 61 PUSH2 0x2a42 2A3A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A29 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a42, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2A3B: // Incoming jump from 0x2A3A, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2A3B 61 PUSH2 0x2a42 2A3E 61 PUSH2 0x29fa 2A41 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A3B stack[0] = 0x2a42 } // Block ends with unconditional jump to 0x29fa label_2A42: // Incoming jump from 0x2A3A, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2A44 stack[-2] // @2A44 stack[-3] // @2A45 stack[-4] // } 2A42 5B JUMPDEST 2A43 50 POP 2A44 02 MUL 2A45 90 SWAP1 2A46 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A45 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_2A47: // Incoming call from 0x1EDE, returns to 0x1EDF // Incoming call from 0x1F68, returns to 0x1F69 // Incoming call from 0x1EDE, returns to 0x1EDF // Inputs[1] { @2A4D stack[-1] } 2A47 5B JUMPDEST 2A48 60 PUSH1 0x00 2A4A 60 PUSH1 0x00 2A4C 19 NOT 2A4D 82 DUP3 2A4E 14 EQ 2A4F 15 ISZERO 2A50 61 PUSH2 0x2a5b 2A53 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A48 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a5b, if !(stack[-1] == ~0x00) label_2A54: // Incoming jump from 0x2A53, if not !(stack[-1] == ~0x00) 2A54 61 PUSH2 0x2a5b 2A57 61 PUSH2 0x29fa 2A5A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A54 stack[0] = 0x2a5b } // Block ends with unconditional jump to 0x29fa label_2A5B: // Incoming jump from 0x2A53, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2A5F stack[-2] // @2A60 stack[-3] // } 2A5B 5B JUMPDEST 2A5C 50 POP 2A5D 60 PUSH1 0x01 2A5F 01 ADD 2A60 90 SWAP1 2A61 56 *JUMP // Stack delta = -2 // Outputs[1] { @2A60 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2A62: // Incoming call from 0x2355, returns to 0x2356 // Incoming call from 0x22BD, returns to 0x22BE // Incoming call from 0x1FD8, returns to 0x1FD9 // Inputs[2] // { // @2A65 stack[-2] // @2A66 stack[-1] // } 2A62 5B JUMPDEST 2A63 60 PUSH1 0x00 2A65 82 DUP3 2A66 82 DUP3 2A67 10 LT 2A68 15 ISZERO 2A69 61 PUSH2 0x2a74 2A6C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A63 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a74, if !(stack[-1] < stack[-2]) label_2A6D: // Incoming jump from 0x2A6C, if not !(stack[-1] < stack[-2]) 2A6D 61 PUSH2 0x2a74 2A70 61 PUSH2 0x29fa 2A73 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A6D stack[0] = 0x2a74 } // Block ends with unconditional jump to 0x29fa label_2A74: // Incoming jump from 0x2A6C, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @2A76 stack[-2] // @2A76 stack[-3] // @2A77 stack[-4] // } 2A74 5B JUMPDEST 2A75 50 POP 2A76 03 SUB 2A77 90 SWAP1 2A78 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A77 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] 2A79 5B JUMPDEST 2A7A 60 PUSH1 0x20 2A7C 80 DUP1 2A7D 82 DUP3 2A7E 52 MSTORE 2A7F 60 PUSH1 0x32 2A81 90 SWAP1 2A82 82 DUP3 2A83 01 ADD 2A84 52 MSTORE 2A85 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 2AA6 60 PUSH1 0x40 2AA8 82 DUP3 2AA9 01 ADD 2AAA 52 MSTORE 2AAB 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 2ABE 60 PUSH1 0x71 2AC0 1B SHL 2AC1 60 PUSH1 0x60 2AC3 82 DUP3 2AC4 01 ADD 2AC5 52 MSTORE 2AC6 60 PUSH1 0x80 2AC8 01 ADD 2AC9 90 SWAP1 2ACA 56 *JUMP label_2ACB: // Incoming call from 0x1CB0, returns to 0x1CB1 // Inputs[3] // { // @2ACE stack[-3] // @2ACF memory[stack[-3]:stack[-3] + 0x20] // @2AD4 stack[-1] // } 2ACB 5B JUMPDEST 2ACC 60 PUSH1 0x00 2ACE 83 DUP4 2ACF 51 MLOAD 2AD0 61 PUSH2 0x2add 2AD3 81 DUP2 2AD4 84 DUP5 2AD5 60 PUSH1 0x20 2AD7 88 DUP9 2AD8 01 ADD 2AD9 61 PUSH2 0x2503 2ADC 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2ACC stack[0] = 0x00 // @2ACF stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @2AD0 stack[2] = 0x2add // @2AD3 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @2AD4 stack[4] = stack[-1] // @2AD8 stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x2503, returns to 0x2ADD label_2ADD: // Incoming return from call to 0x2503 at 0x2ADC // Inputs[4] // { // @2ADE stack[-4] // @2ADF memory[stack[-4]:stack[-4] + 0x20] // @2AE0 stack[-1] // @2AE1 stack[-3] // } 2ADD 5B JUMPDEST 2ADE 83 DUP4 2ADF 51 MLOAD 2AE0 90 SWAP1 2AE1 83 DUP4 2AE2 01 ADD 2AE3 90 SWAP1 2AE4 61 PUSH2 0x2af1 2AE7 81 DUP2 2AE8 83 DUP4 2AE9 60 PUSH1 0x20 2AEB 88 DUP9 2AEC 01 ADD 2AED 61 PUSH2 0x2503 2AF0 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @2AE3 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @2AE3 stack[-1] = stack[-3] + stack[-1] // @2AE4 stack[1] = 0x2af1 // @2AE7 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @2AE8 stack[3] = stack[-3] + stack[-1] // @2AEC stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x2503, returns to 0x2AF1 label_2AF1: // Incoming return from call to 0x2503 at 0x2AF0 // Inputs[4] // { // @2AF2 stack[-1] // @2AF2 stack[-2] // @2AF3 stack[-7] // @2AF4 stack[-6] // } 2AF1 5B JUMPDEST 2AF2 01 ADD 2AF3 94 SWAP5 2AF4 93 SWAP4 2AF5 50 POP 2AF6 50 POP 2AF7 50 POP 2AF8 50 POP 2AF9 56 *JUMP // Stack delta = -6 // Outputs[1] { @2AF3 stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] 2AFA 5B JUMPDEST 2AFB 60 PUSH1 0x01 2AFD 60 PUSH1 0x01 2AFF 60 PUSH1 0xa0 2B01 1B SHL 2B02 03 SUB 2B03 85 DUP6 2B04 81 DUP2 2B05 16 AND 2B06 82 DUP3 2B07 52 MSTORE 2B08 84 DUP5 2B09 16 AND 2B0A 60 PUSH1 0x20 2B0C 82 DUP3 2B0D 01 ADD 2B0E 52 MSTORE 2B0F 60 PUSH1 0x40 2B11 81 DUP2 2B12 01 ADD 2B13 83 DUP4 2B14 90 SWAP1 2B15 52 MSTORE 2B16 60 PUSH1 0x80 2B18 60 PUSH1 0x60 2B1A 82 DUP3 2B1B 01 ADD 2B1C 81 DUP2 2B1D 90 SWAP1 2B1E 52 MSTORE 2B1F 60 PUSH1 0x00 2B21 90 SWAP1 2B22 61 PUSH2 0x2b2d 2B25 90 SWAP1 2B26 83 DUP4 2B27 01 ADD 2B28 84 DUP5 2B29 61 PUSH2 0x252f 2B2C 56 *JUMP 2B2D 5B JUMPDEST 2B2E 96 SWAP7 2B2F 95 SWAP6 2B30 50 POP 2B31 50 POP 2B32 50 POP 2B33 50 POP 2B34 50 POP 2B35 50 POP 2B36 56 *JUMP 2B37 5B JUMPDEST 2B38 60 PUSH1 0x00 2B3A 60 PUSH1 0x20 2B3C 82 DUP3 2B3D 84 DUP5 2B3E 03 SUB 2B3F 12 SLT 2B40 15 ISZERO 2B41 61 PUSH2 0x2b49 2B44 57 *JUMPI 2B45 60 PUSH1 0x00 2B47 80 DUP1 2B48 FD *REVERT 2B49 5B JUMPDEST 2B4A 81 DUP2 2B4B 51 MLOAD 2B4C 61 PUSH2 0x1464 2B4F 81 DUP2 2B50 61 PUSH2 0x24d0 2B53 56 *JUMP label_2B54: // Incoming jump from 0x2B8C // Incoming jump from 0x2B78 // Inputs[1] { @2B69 memory[0x00:0x24] } 2B54 5B JUMPDEST 2B55 63 PUSH4 0x4e487b71 2B5A 60 PUSH1 0xe0 2B5C 1B SHL 2B5D 60 PUSH1 0x00 2B5F 52 MSTORE 2B60 60 PUSH1 0x12 2B62 60 PUSH1 0x04 2B64 52 MSTORE 2B65 60 PUSH1 0x24 2B67 60 PUSH1 0x00 2B69 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B5F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2B64 memory[0x04:0x24] = 0x12 // @2B69 revert(memory[0x00:0x24]); // } // Block terminates label_2B6A: // Incoming call from 0x2027, returns to 0x2028 // Incoming call from 0x1F77, returns to 0x1F78 // Inputs[1] { @2B6D stack[-2] } 2B6A 5B JUMPDEST 2B6B 60 PUSH1 0x00 2B6D 82 DUP3 2B6E 61 PUSH2 0x2b79 2B71 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B6B stack[0] = 0x00 } // Block ends with conditional jump to 0x2b79, if stack[-2] label_2B72: // Incoming jump from 0x2B71, if not stack[-2] 2B72 61 PUSH2 0x2b79 2B75 61 PUSH2 0x2b54 2B78 56 *JUMP // Stack delta = +1 // Outputs[1] { @2B72 stack[0] = 0x2b79 } // Block ends with unconditional jump to 0x2b54 label_2B79: // Incoming jump from 0x2B71, if stack[-2] // Inputs[3] // { // @2B7B stack[-2] // @2B7B stack[-3] // @2B7C stack[-4] // } 2B79 5B JUMPDEST 2B7A 50 POP 2B7B 04 DIV 2B7C 90 SWAP1 2B7D 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B7C stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2B7E: // Incoming call from 0x1FE5, returns to 0x1FE6 // Inputs[1] { @2B81 stack[-2] } 2B7E 5B JUMPDEST 2B7F 60 PUSH1 0x00 2B81 82 DUP3 2B82 61 PUSH2 0x2b8d 2B85 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B7F stack[0] = 0x00 } // Block ends with conditional jump to 0x2b8d, if stack[-2] label_2B86: // Incoming jump from 0x2B85, if not stack[-2] 2B86 61 PUSH2 0x2b8d 2B89 61 PUSH2 0x2b54 2B8C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2B86 stack[0] = 0x2b8d } // Block ends with unconditional jump to 0x2b54 label_2B8D: // Incoming jump from 0x2B85, if stack[-2] // Inputs[3] // { // @2B8F stack[-2] // @2B8F stack[-3] // @2B90 stack[-4] // } 2B8D 5B JUMPDEST 2B8E 50 POP 2B8F 06 MOD 2B90 90 SWAP1 2B91 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B90 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_2B92: // Incoming jump from 0x23D6 // Inputs[1] { @2BA7 memory[0x00:0x24] } 2B92 5B JUMPDEST 2B93 63 PUSH4 0x4e487b71 2B98 60 PUSH1 0xe0 2B9A 1B SHL 2B9B 60 PUSH1 0x00 2B9D 52 MSTORE 2B9E 60 PUSH1 0x31 2BA0 60 PUSH1 0x04 2BA2 52 MSTORE 2BA3 60 PUSH1 0x24 2BA5 60 PUSH1 0x00 2BA7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B9D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2BA2 memory[0x04:0x24] = 0x31 // @2BA7 revert(memory[0x00:0x24]); // } // Block terminates 2BA8 FE *ASSERT 2BA9 A2 LOG2 2BAA 64 PUSH5 0x6970667358 2BB0 22 22 2BB1 12 SLT 2BB2 20 SHA3 2BB3 4E 4E 2BB4 6C PUSH13 0x736583c4867d6519d486c2a989 2BC2 5F PUSH0 2BC3 4F 4F 2BC4 16 AND 2BC5 ED ED 2BC6 DD DD 2BC7 4F 4F 2BC8 4A 4A 2BC9 2C 2C 2BCA 94 SWAP5 2BCB BE BE 2BCC 89 DUP10 2BCD 30 ADDRESS 2BCE 3D RETURNDATASIZE 2BCF FD *REVERT 2BD0 20 SHA3 2BD1 60 PUSH1 0x59 2BD3 64 PUSH5 0x736f6c6343 2BD9 00 *STOP 2BDA 08 ADDMOD 2BDB 0B SIGNEXTEND 2BDC 00 *STOP 2BDD 33 CALLER