Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x0173 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0173, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x729ad39e 0026 11 GT 0027 61 PUSH2 0x00de 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00de, if 0x729ad39e > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x729ad39e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa2309ff8 0031 11 GT 0032 61 PUSH2 0x0097 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0097, if 0xa2309ff8 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa2309ff8 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xc4ae3168 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xc4ae3168 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xc4ae3168 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xc4ae3168 0047 14 EQ 0048 61 PUSH2 0x0318 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0318, if 0xc4ae3168 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xc4ae3168 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xc87b56dd 0052 14 EQ 0053 61 PUSH2 0x0320 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0320, if 0xc87b56dd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe985e9c5 005D 14 EQ 005E 61 PUSH2 0x0333 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0333, if 0xe985e9c5 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf2fde38b 0068 14 EQ 0069 61 PUSH2 0x036f 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036f, if 0xf2fde38b == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x0040, if 0xc4ae3168 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xa2309ff8 0078 14 EQ 0079 61 PUSH2 0x02f0 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f0, if 0xa2309ff8 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xa2309ff8 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xb187bd26 0083 14 EQ 0084 61 PUSH2 0x02f8 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f8, if 0xb187bd26 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xb187bd26 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xb88d4fde 008E 14 EQ 008F 61 PUSH2 0x0305 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0305, if 0xb88d4fde == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0096 memory[0x00:0x00] } 0093 60 PUSH1 0x00 0095 80 DUP1 0096 FD *REVERT // Stack delta = +0 // Outputs[1] { @0096 revert(memory[0x00:0x00]); } // Block terminates label_0097: // Incoming jump from 0x0035, if 0xa2309ff8 > stack[-1] // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x729ad39e 009E 14 EQ 009F 61 PUSH2 0x027b 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027b, if 0x729ad39e == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x729ad39e == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x8da5cb5b 00A9 14 EQ 00AA 61 PUSH2 0x028e 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028e, if 0x8da5cb5b == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x95652cfa 00B4 14 EQ 00B5 61 PUSH2 0x029f 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029f, if 0x95652cfa == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x95652cfa == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x95d89b41 00BF 14 EQ 00C0 61 PUSH2 0x02b2 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b2, if 0x95d89b41 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x9be367cd 00CA 14 EQ 00CB 61 PUSH2 0x02ba 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ba, if 0x9be367cd == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x9be367cd == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xa22cb465 00D5 14 EQ 00D6 61 PUSH2 0x02dd 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02dd, if 0xa22cb465 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00DD memory[0x00:0x00] } 00DA 60 PUSH1 0x00 00DC 80 DUP1 00DD FD *REVERT // Stack delta = +0 // Outputs[1] { @00DD revert(memory[0x00:0x00]); } // Block terminates label_00DE: // Incoming jump from 0x002A, if 0x729ad39e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00DF stack[-1] } 00DE 5B JUMPDEST 00DF 80 DUP1 00E0 63 PUSH4 0x32cb6b0c 00E5 11 GT 00E6 61 PUSH2 0x0130 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0130, if 0x32cb6b0c > stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x32cb6b0c > stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x32cb6b0c 00F0 14 EQ 00F1 61 PUSH2 0x021e 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021e, if 0x32cb6b0c == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x42842e0e 00FB 14 EQ 00FC 61 PUSH2 0x0227 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0227, if 0x42842e0e == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x42842e0e == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0x4b0bddd2 0106 14 EQ 0107 61 PUSH2 0x023a 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023a, if 0x4b0bddd2 == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x4b0bddd2 == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x6352211e 0111 14 EQ 0112 61 PUSH2 0x024d 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024d, if 0x6352211e == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x6352211e == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0x70a08231 011C 14 EQ 011D 61 PUSH2 0x0260 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0260, if 0x70a08231 == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0x70a08231 == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0x715018a6 0127 14 EQ 0128 61 PUSH2 0x0273 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0273, if 0x715018a6 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0x715018a6 == stack[-1] // Inputs[1] { @012F memory[0x00:0x00] } 012C 60 PUSH1 0x00 012E 80 DUP1 012F FD *REVERT // Stack delta = +0 // Outputs[1] { @012F revert(memory[0x00:0x00]); } // Block terminates label_0130: // Incoming jump from 0x00E9, if 0x32cb6b0c > stack[-1] // Inputs[1] { @0131 stack[-1] } 0130 5B JUMPDEST 0131 80 DUP1 0132 63 PUSH4 0x01ffc9a7 0137 14 EQ 0138 61 PUSH2 0x0178 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0178, if 0x01ffc9a7 == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x06fdde03 0142 14 EQ 0143 61 PUSH2 0x01a0 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a0, if 0x06fdde03 == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x081812fc 014D 14 EQ 014E 61 PUSH2 0x01b5 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b5, if 0x081812fc == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x081812fc == stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0x095ea7b3 0158 14 EQ 0159 61 PUSH2 0x01e0 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e0, if 0x095ea7b3 == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @015D stack[-1] } 015D 80 DUP1 015E 63 PUSH4 0x18160ddd 0163 14 EQ 0164 61 PUSH2 0x01f5 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f5, if 0x18160ddd == stack[-1] label_0168: // Incoming jump from 0x0167, if not 0x18160ddd == stack[-1] // Inputs[1] { @0168 stack[-1] } 0168 80 DUP1 0169 63 PUSH4 0x23b872dd 016E 14 EQ 016F 61 PUSH2 0x020b 0172 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020b, if 0x23b872dd == stack[-1] label_0173: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0172, if not 0x23b872dd == stack[-1] // Inputs[1] { @0177 memory[0x00:0x00] } 0173 5B JUMPDEST 0174 60 PUSH1 0x00 0176 80 DUP1 0177 FD *REVERT // Stack delta = +0 // Outputs[1] { @0177 revert(memory[0x00:0x00]); } // Block terminates label_0178: // Incoming jump from 0x013B, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @017F msg.data.length } 0178 5B JUMPDEST 0179 61 PUSH2 0x018b 017C 61 PUSH2 0x0186 017F 36 CALLDATASIZE 0180 60 PUSH1 0x04 0182 61 PUSH2 0x134c 0185 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0179 stack[0] = 0x018b // @017C stack[1] = 0x0186 // @017F stack[2] = msg.data.length // @0180 stack[3] = 0x04 // } // Block ends with call to 0x134c, returns to 0x0186 label_0186: // Incoming return from call to 0x134C at 0x0185 0186 5B JUMPDEST 0187 61 PUSH2 0x0382 018A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0382 label_018B: // Incoming return from call to 0x0341 at 0x0340 // Incoming return from call to 0x0186 at 0x0185 // Incoming jump from 0x0304 // Incoming return from call to 0x02C8 at 0x02C7 // Inputs[2] // { // @018E memory[0x40:0x60] // @018F stack[-1] // } 018B 5B JUMPDEST 018C 60 PUSH1 0x40 018E 51 MLOAD 018F 90 SWAP1 0190 15 ISZERO 0191 15 ISZERO 0192 81 DUP2 0193 52 MSTORE 0194 60 PUSH1 0x20 0196 01 ADD // Stack delta = +0 // Outputs[2] // { // @0193 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0196 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0197: // Incoming jump from 0x020A // Incoming jump from 0x01DF // Incoming jump from 0x0196 // Inputs[3] // { // @019A memory[0x40:0x60] // @019C stack[-1] // @019F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0197 5B JUMPDEST 0198 60 PUSH1 0x40 019A 51 MLOAD 019B 80 DUP1 019C 91 SWAP2 019D 03 SUB 019E 90 SWAP1 019F F3 *RETURN // Stack delta = -1 // Outputs[1] { @019F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01A0: // Incoming jump from 0x0146, if 0x06fdde03 == stack[-1] 01A0 5B JUMPDEST 01A1 61 PUSH2 0x01a8 01A4 61 PUSH2 0x03d4 01A7 56 *JUMP // Stack delta = +1 // Outputs[1] { @01A1 stack[0] = 0x01a8 } // Block ends with call to 0x03d4, returns to 0x01A8 label_01A8: // Incoming return from call to 0x0842 at 0x02B9 // Incoming return from call to 0x03D4 at 0x01A7 // Inputs[2] // { // @01AB memory[0x40:0x60] // @01AF stack[-1] // } 01A8 5B JUMPDEST 01A9 60 PUSH1 0x40 01AB 51 MLOAD 01AC 61 PUSH2 0x0197 01AF 91 SWAP2 01B0 90 SWAP1 01B1 61 PUSH2 0x13c1 01B4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01AF stack[-1] = 0x0197 // @01B0 stack[1] = memory[0x40:0x60] // @01B0 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x13c1 label_01B5: // Incoming jump from 0x0151, if 0x081812fc == stack[-1] // Inputs[1] { @01BC msg.data.length } 01B5 5B JUMPDEST 01B6 61 PUSH2 0x01c8 01B9 61 PUSH2 0x01c3 01BC 36 CALLDATASIZE 01BD 60 PUSH1 0x04 01BF 61 PUSH2 0x13d4 01C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01B6 stack[0] = 0x01c8 // @01B9 stack[1] = 0x01c3 // @01BC stack[2] = msg.data.length // @01BD stack[3] = 0x04 // } // Block ends with call to 0x13d4, returns to 0x01C3 label_01C3: // Incoming return from call to 0x13D4 at 0x01C2 01C3 5B JUMPDEST 01C4 61 PUSH2 0x0466 01C7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0466 label_01C8: // Incoming return from call to 0x01C3 at 0x01C2 // Incoming jump from 0x029E // Incoming return from call to 0x025B at 0x025A // Inputs[2] // { // @01CB memory[0x40:0x60] // @01D5 stack[-1] // } 01C8 5B JUMPDEST 01C9 60 PUSH1 0x40 01CB 51 MLOAD 01CC 60 PUSH1 0x01 01CE 60 PUSH1 0x01 01D0 60 PUSH1 0xa0 01D2 1B SHL 01D3 03 SUB 01D4 90 SWAP1 01D5 91 SWAP2 01D6 16 AND 01D7 81 DUP2 01D8 52 MSTORE 01D9 60 PUSH1 0x20 01DB 01 ADD 01DC 61 PUSH2 0x0197 01DF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @01DB stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0197 label_01E0: // Incoming jump from 0x015C, if 0x095ea7b3 == stack[-1] // Inputs[1] { @01E7 msg.data.length } 01E0 5B JUMPDEST 01E1 61 PUSH2 0x01f3 01E4 61 PUSH2 0x01ee 01E7 36 CALLDATASIZE 01E8 60 PUSH1 0x04 01EA 61 PUSH2 0x1409 01ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01E1 stack[0] = 0x01f3 // @01E4 stack[1] = 0x01ee // @01E7 stack[2] = msg.data.length // @01E8 stack[3] = 0x04 // } // Block ends with call to 0x1409, returns to 0x01EE label_01EE: // Incoming return from call to 0x1409 at 0x01ED 01EE 5B JUMPDEST 01EF 61 PUSH2 0x04aa 01F2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04aa label_01F3: // Incoming return from call to 0x0248 at 0x0247 // Incoming return from call to 0x061C at 0x027A // Incoming return from call to 0x02EB at 0x02EA // Incoming return from call to 0x0313 at 0x0312 // Incoming return from call to 0x0937 at 0x031F // Incoming return from call to 0x0289 at 0x0288 // Incoming return from call to 0x01EE at 0x01ED 01F3 5B JUMPDEST 01F4 00 *STOP // Stack delta = +0 // Outputs[1] { @01F4 stop(); } // Block terminates label_01F5: // Incoming jump from 0x0167, if 0x18160ddd == stack[-1] // Inputs[2] // { // @01F8 storage[0x01] // @01FB storage[0x00] // } 01F5 5B JUMPDEST 01F6 60 PUSH1 0x01 01F8 54 SLOAD 01F9 60 PUSH1 0x00 01FB 54 SLOAD 01FC 03 SUB // Stack delta = +1 // Outputs[1] { @01FC stack[0] = storage[0x00] - storage[0x01] } // Block continues label_01FD: // Incoming jump from 0x01FC // Incoming return from call to 0x026E at 0x026D // Incoming jump from 0x02F7 // Incoming jump from 0x0226 // Inputs[2] // { // @0200 memory[0x40:0x60] // @0201 stack[-1] // } 01FD 5B JUMPDEST 01FE 60 PUSH1 0x40 0200 51 MLOAD 0201 90 SWAP1 0202 81 DUP2 0203 52 MSTORE 0204 60 PUSH1 0x20 0206 01 ADD 0207 61 PUSH2 0x0197 020A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0203 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0206 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0197 label_020B: // Incoming jump from 0x0172, if 0x23b872dd == stack[-1] // Inputs[1] { @0212 msg.data.length } 020B 5B JUMPDEST 020C 61 PUSH2 0x01f3 020F 61 PUSH2 0x0219 0212 36 CALLDATASIZE 0213 60 PUSH1 0x04 0215 61 PUSH2 0x1433 0218 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @020C stack[0] = 0x01f3 // @020F stack[1] = 0x0219 // @0212 stack[2] = msg.data.length // @0213 stack[3] = 0x04 // } // Block ends with call to 0x1433, returns to 0x0219 label_0219: // Incoming return from call to 0x1433 at 0x0218 0219 5B JUMPDEST 021A 61 PUSH2 0x0537 021D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0537 label_021E: // Incoming jump from 0x00F4, if 0x32cb6b0c == stack[-1] // Inputs[1] { @0224 storage[0x09] } 021E 5B JUMPDEST 021F 61 PUSH2 0x01fd 0222 60 PUSH1 0x09 0224 54 SLOAD 0225 81 DUP2 0226 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @021F stack[0] = 0x01fd // @0224 stack[1] = storage[0x09] // } // Block ends with unconditional jump to 0x01fd label_0227: // Incoming jump from 0x00FF, if 0x42842e0e == stack[-1] // Inputs[1] { @022E msg.data.length } 0227 5B JUMPDEST 0228 61 PUSH2 0x01f3 022B 61 PUSH2 0x0235 022E 36 CALLDATASIZE 022F 60 PUSH1 0x04 0231 61 PUSH2 0x1433 0234 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0228 stack[0] = 0x01f3 // @022B stack[1] = 0x0235 // @022E stack[2] = msg.data.length // @022F stack[3] = 0x04 // } // Block ends with call to 0x1433, returns to 0x0235 label_0235: // Incoming return from call to 0x1433 at 0x0234 0235 5B JUMPDEST 0236 61 PUSH2 0x0542 0239 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0542 label_023A: // Incoming jump from 0x010A, if 0x4b0bddd2 == stack[-1] // Inputs[1] { @0241 msg.data.length } 023A 5B JUMPDEST 023B 61 PUSH2 0x01f3 023E 61 PUSH2 0x0248 0241 36 CALLDATASIZE 0242 60 PUSH1 0x04 0244 61 PUSH2 0x146f 0247 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023B stack[0] = 0x01f3 // @023E stack[1] = 0x0248 // @0241 stack[2] = msg.data.length // @0242 stack[3] = 0x04 // } // Block ends with call to 0x146f, returns to 0x0248 label_0248: // Incoming return from call to 0x146F at 0x0247 0248 5B JUMPDEST 0249 61 PUSH2 0x055d 024C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x055d label_024D: // Incoming jump from 0x0115, if 0x6352211e == stack[-1] // Inputs[1] { @0254 msg.data.length } 024D 5B JUMPDEST 024E 61 PUSH2 0x01c8 0251 61 PUSH2 0x025b 0254 36 CALLDATASIZE 0255 60 PUSH1 0x04 0257 61 PUSH2 0x13d4 025A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @024E stack[0] = 0x01c8 // @0251 stack[1] = 0x025b // @0254 stack[2] = msg.data.length // @0255 stack[3] = 0x04 // } // Block ends with call to 0x13d4, returns to 0x025B label_025B: // Incoming return from call to 0x13D4 at 0x025A 025B 5B JUMPDEST 025C 61 PUSH2 0x05bb 025F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05bb label_0260: // Incoming jump from 0x0120, if 0x70a08231 == stack[-1] // Inputs[1] { @0267 msg.data.length } 0260 5B JUMPDEST 0261 61 PUSH2 0x01fd 0264 61 PUSH2 0x026e 0267 36 CALLDATASIZE 0268 60 PUSH1 0x04 026A 61 PUSH2 0x14ab 026D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0261 stack[0] = 0x01fd // @0264 stack[1] = 0x026e // @0267 stack[2] = msg.data.length // @0268 stack[3] = 0x04 // } // Block ends with call to 0x14ab, returns to 0x026E label_026E: // Incoming return from call to 0x14AB at 0x026D 026E 5B JUMPDEST 026F 61 PUSH2 0x05cd 0272 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05cd label_0273: // Incoming jump from 0x012B, if 0x715018a6 == stack[-1] 0273 5B JUMPDEST 0274 61 PUSH2 0x01f3 0277 61 PUSH2 0x061c 027A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0274 stack[0] = 0x01f3 } // Block ends with call to 0x061c, returns to 0x01F3 label_027B: // Incoming jump from 0x00A2, if 0x729ad39e == stack[-1] // Inputs[1] { @0282 msg.data.length } 027B 5B JUMPDEST 027C 61 PUSH2 0x01f3 027F 61 PUSH2 0x0289 0282 36 CALLDATASIZE 0283 60 PUSH1 0x04 0285 61 PUSH2 0x150d 0288 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @027C stack[0] = 0x01f3 // @027F stack[1] = 0x0289 // @0282 stack[2] = msg.data.length // @0283 stack[3] = 0x04 // } // Block ends with call to 0x150d, returns to 0x0289 label_0289: // Incoming return from call to 0x150D at 0x0288 0289 5B JUMPDEST 028A 61 PUSH2 0x0652 028D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0652 label_028E: // Incoming jump from 0x00AD, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0291 storage[0x08] } 028E 5B JUMPDEST 028F 60 PUSH1 0x08 0291 54 SLOAD 0292 60 PUSH1 0x01 0294 60 PUSH1 0x01 0296 60 PUSH1 0xa0 0298 1B SHL 0299 03 SUB 029A 16 AND 029B 61 PUSH2 0x01c8 029E 56 *JUMP // Stack delta = +1 // Outputs[1] { @029A stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x01c8 label_029F: // Incoming jump from 0x00B8, if 0x95652cfa == stack[-1] // Inputs[1] { @02A6 msg.data.length } 029F 5B JUMPDEST 02A0 61 PUSH2 0x01f3 02A3 61 PUSH2 0x02ad 02A6 36 CALLDATASIZE 02A7 60 PUSH1 0x04 02A9 61 PUSH2 0x1612 02AC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A0 stack[0] = 0x01f3 // @02A3 stack[1] = 0x02ad // @02A6 stack[2] = msg.data.length // @02A7 stack[3] = 0x04 // } // Block ends with call to 0x1612, returns to 0x02AD label_02AD: // Incoming return from call to 0x1612 at 0x02AC 02AD 5B JUMPDEST 02AE 61 PUSH2 0x0805 02B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0805 label_02B2: // Incoming jump from 0x00C3, if 0x95d89b41 == stack[-1] 02B2 5B JUMPDEST 02B3 61 PUSH2 0x01a8 02B6 61 PUSH2 0x0842 02B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @02B3 stack[0] = 0x01a8 } // Block ends with call to 0x0842, returns to 0x01A8 label_02BA: // Incoming jump from 0x00CE, if 0x9be367cd == stack[-1] // Inputs[1] { @02C1 msg.data.length } 02BA 5B JUMPDEST 02BB 61 PUSH2 0x018b 02BE 61 PUSH2 0x02c8 02C1 36 CALLDATASIZE 02C2 60 PUSH1 0x04 02C4 61 PUSH2 0x14ab 02C7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BB stack[0] = 0x018b // @02BE stack[1] = 0x02c8 // @02C1 stack[2] = msg.data.length // @02C2 stack[3] = 0x04 // } // Block ends with call to 0x14ab, returns to 0x02C8 label_02C8: // Incoming return from call to 0x14AB at 0x02C7 // Inputs[4] // { // @02D0 stack[-1] // @02D6 memory[0x00:0x40] // @02D7 storage[keccak256(memory[0x00:0x40])] // @02DB stack[-2] // } 02C8 5B JUMPDEST 02C9 60 PUSH1 0x0c 02CB 60 PUSH1 0x20 02CD 52 MSTORE 02CE 60 PUSH1 0x00 02D0 90 SWAP1 02D1 81 DUP2 02D2 52 MSTORE 02D3 60 PUSH1 0x40 02D5 90 SWAP1 02D6 20 SHA3 02D7 54 SLOAD 02D8 60 PUSH1 0xff 02DA 16 AND 02DB 81 DUP2 02DC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @02CD memory[0x20:0x40] = 0x0c // @02D2 memory[0x00:0x20] = stack[-1] // @02DA stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_02DD: // Incoming jump from 0x00D9, if 0xa22cb465 == stack[-1] // Inputs[1] { @02E4 msg.data.length } 02DD 5B JUMPDEST 02DE 61 PUSH2 0x01f3 02E1 61 PUSH2 0x02eb 02E4 36 CALLDATASIZE 02E5 60 PUSH1 0x04 02E7 61 PUSH2 0x146f 02EA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DE stack[0] = 0x01f3 // @02E1 stack[1] = 0x02eb // @02E4 stack[2] = msg.data.length // @02E5 stack[3] = 0x04 // } // Block ends with call to 0x146f, returns to 0x02EB label_02EB: // Incoming return from call to 0x146F at 0x02EA 02EB 5B JUMPDEST 02EC 61 PUSH2 0x0851 02EF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0851 label_02F0: // Incoming jump from 0x007C, if 0xa2309ff8 == stack[-1] // Inputs[1] { @02F3 storage[0x00] } 02F0 5B JUMPDEST 02F1 60 PUSH1 0x00 02F3 54 SLOAD 02F4 61 PUSH2 0x01fd 02F7 56 *JUMP // Stack delta = +1 // Outputs[1] { @02F3 stack[0] = storage[0x00] } // Block ends with unconditional jump to 0x01fd label_02F8: // Incoming jump from 0x0087, if 0xb187bd26 == stack[-1] // Inputs[1] { @02FB storage[0x0b] } 02F8 5B JUMPDEST 02F9 60 PUSH1 0x0b 02FB 54 SLOAD 02FC 61 PUSH2 0x018b 02FF 90 SWAP1 0300 60 PUSH1 0xff 0302 16 AND 0303 81 DUP2 0304 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02FF stack[0] = 0x018b // @0302 stack[1] = 0xff & storage[0x0b] // } // Block ends with unconditional jump to 0x018b label_0305: // Incoming jump from 0x0092, if 0xb88d4fde == stack[-1] // Inputs[1] { @030C msg.data.length } 0305 5B JUMPDEST 0306 61 PUSH2 0x01f3 0309 61 PUSH2 0x0313 030C 36 CALLDATASIZE 030D 60 PUSH1 0x04 030F 61 PUSH2 0x165b 0312 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0306 stack[0] = 0x01f3 // @0309 stack[1] = 0x0313 // @030C stack[2] = msg.data.length // @030D stack[3] = 0x04 // } // Block ends with call to 0x165b, returns to 0x0313 label_0313: // Incoming return from call to 0x165B at 0x0312 0313 5B JUMPDEST 0314 61 PUSH2 0x08e6 0317 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08e6 label_0318: // Incoming jump from 0x004B, if 0xc4ae3168 == stack[-1] 0318 5B JUMPDEST 0319 61 PUSH2 0x01f3 031C 61 PUSH2 0x0937 031F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0319 stack[0] = 0x01f3 } // Block ends with call to 0x0937, returns to 0x01F3 label_0320: // Incoming jump from 0x0056, if 0xc87b56dd == stack[-1] // Inputs[1] { @0327 msg.data.length } 0320 5B JUMPDEST 0321 61 PUSH2 0x01a8 0324 61 PUSH2 0x032e 0327 36 CALLDATASIZE 0328 60 PUSH1 0x04 032A 61 PUSH2 0x13d4 032D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0321 stack[0] = 0x01a8 // @0324 stack[1] = 0x032e // @0327 stack[2] = msg.data.length // @0328 stack[3] = 0x04 // } // Block ends with call to 0x13d4, returns to 0x032E label_032E: // Incoming return from call to 0x13D4 at 0x032D 032E 5B JUMPDEST 032F 61 PUSH2 0x0975 0332 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0975 label_0333: // Incoming jump from 0x0061, if 0xe985e9c5 == stack[-1] // Inputs[1] { @033A msg.data.length } 0333 5B JUMPDEST 0334 61 PUSH2 0x018b 0337 61 PUSH2 0x0341 033A 36 CALLDATASIZE 033B 60 PUSH1 0x04 033D 61 PUSH2 0x16d7 0340 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0334 stack[0] = 0x018b // @0337 stack[1] = 0x0341 // @033A stack[2] = msg.data.length // @033B stack[3] = 0x04 // } // Block ends with call to 0x16d7, returns to 0x0341 label_0341: // Incoming call from 0x0506, returns to 0x0507 // Incoming return from call to 0x16D7 at 0x0340 // Incoming call from 0x0BC1, returns to 0x0BC2 // Inputs[6] // { // @034A stack[-2] // @035D memory[0x00:0x40] // @035E stack[-1] // @0368 memory[0x00:0x40] // @0369 storage[keccak256(memory[0x00:0x40])] // @036D stack[-3] // } 0341 5B JUMPDEST 0342 60 PUSH1 0x01 0344 60 PUSH1 0x01 0346 60 PUSH1 0xa0 0348 1B SHL 0349 03 SUB 034A 91 SWAP2 034B 82 DUP3 034C 16 AND 034D 60 PUSH1 0x00 034F 90 SWAP1 0350 81 DUP2 0351 52 MSTORE 0352 60 PUSH1 0x07 0354 60 PUSH1 0x20 0356 90 SWAP1 0357 81 DUP2 0358 52 MSTORE 0359 60 PUSH1 0x40 035B 80 DUP1 035C 83 DUP4 035D 20 SHA3 035E 93 SWAP4 035F 90 SWAP1 0360 94 SWAP5 0361 16 AND 0362 82 DUP3 0363 52 MSTORE 0364 91 SWAP2 0365 90 SWAP1 0366 91 SWAP2 0367 52 MSTORE 0368 20 SHA3 0369 54 SLOAD 036A 60 PUSH1 0xff 036C 16 AND 036D 90 SWAP1 036E 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0351 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0358 memory[0x20:0x40] = 0x07 // @0363 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0367 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @036D stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_036F: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @0376 msg.data.length } 036F 5B JUMPDEST 0370 61 PUSH2 0x01f3 0373 61 PUSH2 0x037d 0376 36 CALLDATASIZE 0377 60 PUSH1 0x04 0379 61 PUSH2 0x14ab 037C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0370 stack[0] = 0x01f3 // @0373 stack[1] = 0x037d // @0376 stack[2] = msg.data.length // @0377 stack[3] = 0x04 // } // Block ends with call to 0x14ab, returns to 0x037D label_037D: // Incoming return from call to 0x14AB at 0x037C 037D 5B JUMPDEST 037E 61 PUSH2 0x0a40 0381 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a40 label_0382: // Incoming jump from 0x018A // Inputs[1] { @038E stack[-1] } 0382 5B JUMPDEST 0383 60 PUSH1 0x00 0385 60 PUSH1 0x01 0387 60 PUSH1 0x01 0389 60 PUSH1 0xe0 038B 1B SHL 038C 03 SUB 038D 19 NOT 038E 82 DUP3 038F 16 AND 0390 63 PUSH4 0x80ac58cd 0395 60 PUSH1 0xe0 0397 1B SHL 0398 14 EQ 0399 80 DUP1 039A 61 PUSH2 0x03b3 039D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0383 stack[0] = 0x00 // @0398 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x03b3, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_039E: // Incoming jump from 0x039D, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @03A8 stack[-3] } 039E 50 POP 039F 60 PUSH1 0x01 03A1 60 PUSH1 0x01 03A3 60 PUSH1 0xe0 03A5 1B SHL 03A6 03 SUB 03A7 19 NOT 03A8 82 DUP3 03A9 16 AND 03AA 63 PUSH4 0x5b5e139f 03AF 60 PUSH1 0xe0 03B1 1B SHL 03B2 14 EQ 03B3 5B JUMPDEST 03B4 80 DUP1 03B5 61 PUSH2 0x03ce 03B8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03B2 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x03ce, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_03B9: // Incoming jump from 0x03B8, if not stack[-1] // Incoming jump from 0x03B8, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @03CB stack[-3] } 03B9 50 POP 03BA 63 PUSH4 0x01ffc9a7 03BF 60 PUSH1 0xe0 03C1 1B SHL 03C2 60 PUSH1 0x01 03C4 60 PUSH1 0x01 03C6 60 PUSH1 0xe0 03C8 1B SHL 03C9 03 SUB 03CA 19 NOT 03CB 83 DUP4 03CC 16 AND 03CD 14 EQ // Stack delta = +0 // Outputs[1] { @03CD stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_03CE: // Incoming jump from 0x03CD // Incoming jump from 0x03B8, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x03B8, if stack[-1] // Incoming jump from 0x0AE7, if !(stack[-1] < storage[0x00]) // Inputs[3] // { // @03CF stack[-1] // @03CF stack[-4] // @03D0 stack[-3] // } 03CE 5B JUMPDEST 03CF 92 SWAP3 03D0 91 SWAP2 03D1 50 POP 03D2 50 POP 03D3 56 *JUMP // Stack delta = -3 // Outputs[1] { @03CF stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_03D4: // Incoming call from 0x01A7, returns to 0x01A8 // Inputs[1] { @03DA storage[0x02] } 03D4 5B JUMPDEST 03D5 60 PUSH1 0x60 03D7 60 PUSH1 0x02 03D9 80 DUP1 03DA 54 SLOAD 03DB 61 PUSH2 0x03e3 03DE 90 SWAP1 03DF 61 PUSH2 0x170a 03E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03D5 stack[0] = 0x60 // @03D7 stack[1] = 0x02 // @03DE stack[2] = 0x03e3 // @03DE stack[3] = storage[0x02] // } // Block ends with call to 0x170a, returns to 0x03E3 label_03E3: // Incoming return from call to 0x170A at 0x03E2 // Incoming return from call to 0x170A at 0x0850 // Incoming return from call to 0x170A at 0x0FD3 // Inputs[4] // { // @03E4 stack[-1] // @03F3 memory[0x40:0x60] // @03FB stack[-2] // @0406 storage[stack[-2]] // } 03E3 5B JUMPDEST 03E4 80 DUP1 03E5 60 PUSH1 0x1f 03E7 01 ADD 03E8 60 PUSH1 0x20 03EA 80 DUP1 03EB 91 SWAP2 03EC 04 DIV 03ED 02 MUL 03EE 60 PUSH1 0x20 03F0 01 ADD 03F1 60 PUSH1 0x40 03F3 51 MLOAD 03F4 90 SWAP1 03F5 81 DUP2 03F6 01 ADD 03F7 60 PUSH1 0x40 03F9 52 MSTORE 03FA 80 DUP1 03FB 92 SWAP3 03FC 91 SWAP2 03FD 90 SWAP1 03FE 81 DUP2 03FF 81 DUP2 0400 52 MSTORE 0401 60 PUSH1 0x20 0403 01 ADD 0404 82 DUP3 0405 80 DUP1 0406 54 SLOAD 0407 61 PUSH2 0x040f 040A 90 SWAP1 040B 61 PUSH2 0x170a 040E 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @03F9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @03FB stack[-2] = memory[0x40:0x60] // @03FC stack[-1] = stack[-2] // @03FD stack[0] = stack[-1] // @0400 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0403 stack[1] = 0x20 + memory[0x40:0x60] // @0404 stack[2] = stack[-2] // @040A stack[4] = storage[stack[-2]] // @040A stack[3] = 0x040f // } // Block ends with call to 0x170a, returns to 0x040F label_040F: // Incoming return from call to 0x170A at 0x040E // Inputs[1] { @0410 stack[-1] } 040F 5B JUMPDEST 0410 80 DUP1 0411 15 ISZERO 0412 61 PUSH2 0x045c 0415 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045c, if !stack[-1] label_0416: // Incoming jump from 0x0415, if not !stack[-1] // Inputs[1] { @0416 stack[-1] } 0416 80 DUP1 0417 60 PUSH1 0x1f 0419 10 LT 041A 61 PUSH2 0x0431 041D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0431, if 0x1f < stack[-1] label_041E: // Incoming jump from 0x041D, if not 0x1f < stack[-1] // Inputs[4] // { // @0422 stack[-2] // @0423 storage[stack[-2]] // @0426 stack[-3] // @0428 stack[-1] // } 041E 61 PUSH2 0x0100 0421 80 DUP1 0422 83 DUP4 0423 54 SLOAD 0424 04 DIV 0425 02 MUL 0426 83 DUP4 0427 52 MSTORE 0428 91 SWAP2 0429 60 PUSH1 0x20 042B 01 ADD 042C 91 SWAP2 042D 61 PUSH2 0x045c 0430 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0427 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @042C stack[-1] = stack[-1] // @042C stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x045c label_0431: // Incoming jump from 0x041D, if 0x1f < stack[-1] // Inputs[5] // { // @0432 stack[-3] // @0433 stack[-1] // @0435 stack[-2] // @043D memory[0x00:0x20] // @0441 storage[keccak256(memory[0x00:0x20])] // } 0431 5B JUMPDEST 0432 82 DUP3 0433 01 ADD 0434 91 SWAP2 0435 90 SWAP1 0436 60 PUSH1 0x00 0438 52 MSTORE 0439 60 PUSH1 0x20 043B 60 PUSH1 0x00 043D 20 SHA3 043E 90 SWAP1 043F 5B JUMPDEST 0440 81 DUP2 0441 54 SLOAD 0442 81 DUP2 0443 52 MSTORE 0444 90 SWAP1 0445 60 PUSH1 0x01 0447 01 ADD 0448 90 SWAP1 0449 60 PUSH1 0x20 044B 01 ADD 044C 80 DUP1 044D 83 DUP4 044E 11 GT 044F 61 PUSH2 0x043f 0452 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0434 stack[-3] = stack[-3] + stack[-1] // @0438 memory[0x00:0x20] = stack[-2] // @0443 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0448 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @044B stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x043f, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0453: // Incoming jump from 0x0452, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0452, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0453 stack[-3] // @0454 stack[-1] // } 0453 82 DUP3 0454 90 SWAP1 0455 03 SUB 0456 60 PUSH1 0x1f 0458 16 AND 0459 82 DUP3 045A 01 ADD 045B 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @045B stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @045B stack[-1] = stack[-3] // } // Block continues label_045C: // Incoming jump from 0x0430 // Incoming jump from 0x0415, if !stack[-1] // Incoming jump from 0x045B // Inputs[3] // { // @0462 stack[-6] // @0462 stack[-7] // @0464 stack[-8] // } 045C 5B JUMPDEST 045D 50 POP 045E 50 POP 045F 50 POP 0460 50 POP 0461 50 POP 0462 90 SWAP1 0463 50 POP 0464 90 SWAP1 0465 56 *JUMP // Stack delta = -7 // Outputs[1] { @0464 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0466: // Incoming jump from 0x01C7 // Incoming call from 0x0BD1, returns to 0x0BD2 // Inputs[1] { @046C stack[-1] } 0466 5B JUMPDEST 0467 60 PUSH1 0x00 0469 61 PUSH2 0x0471 046C 82 DUP3 046D 61 PUSH2 0x0adb 0470 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0467 stack[0] = 0x00 // @0469 stack[1] = 0x0471 // @046C stack[2] = stack[-1] // } // Block ends with call to 0x0adb, returns to 0x0471 label_0471: // Incoming return from call to 0x0ADB at 0x0470 // Inputs[1] { @0475 stack[-1] } 0471 5B JUMPDEST 0472 61 PUSH2 0x048e 0475 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x048e, if stack[-1] label_0476: // Incoming jump from 0x0475, if not stack[-1] // Inputs[3] // { // @0478 memory[0x40:0x60] // @0488 memory[0x40:0x60] // @048D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0476 60 PUSH1 0x40 0478 51 MLOAD 0479 63 PUSH4 0x33d1c039 047E 60 PUSH1 0xe2 0480 1B SHL 0481 81 DUP2 0482 52 MSTORE 0483 60 PUSH1 0x04 0485 01 ADD 0486 60 PUSH1 0x40 0488 51 MLOAD 0489 80 DUP1 048A 91 SWAP2 048B 03 SUB 048C 90 SWAP1 048D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0482 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @048D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_048E: // Incoming jump from 0x0475, if stack[-1] // Inputs[4] // { // @0492 stack[-2] // @049D memory[0x00:0x40] // @049E storage[keccak256(memory[0x00:0x40])] // @04A8 stack[-3] // } 048E 5B JUMPDEST 048F 50 POP 0490 60 PUSH1 0x00 0492 90 SWAP1 0493 81 DUP2 0494 52 MSTORE 0495 60 PUSH1 0x06 0497 60 PUSH1 0x20 0499 52 MSTORE 049A 60 PUSH1 0x40 049C 90 SWAP1 049D 20 SHA3 049E 54 SLOAD 049F 60 PUSH1 0x01 04A1 60 PUSH1 0x01 04A3 60 PUSH1 0xa0 04A5 1B SHL 04A6 03 SUB 04A7 16 AND 04A8 90 SWAP1 04A9 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0494 memory[0x00:0x20] = stack[-2] // @0499 memory[0x20:0x40] = 0x06 // @04A8 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_04AA: // Incoming jump from 0x01F2 // Inputs[1] { @04B0 stack[-1] } 04AA 5B JUMPDEST 04AB 60 PUSH1 0x00 04AD 61 PUSH2 0x04b5 04B0 82 DUP3 04B1 61 PUSH2 0x05bb 04B4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04AB stack[0] = 0x00 // @04AD stack[1] = 0x04b5 // @04B0 stack[2] = stack[-1] // } // Block ends with call to 0x05bb, returns to 0x04B5 label_04B5: // Incoming return from call to 0x05BB at 0x04B4 // Inputs[3] // { // @04B6 stack[-2] // @04B6 stack[-1] // @04C2 stack[-4] // } 04B5 5B JUMPDEST 04B6 90 SWAP1 04B7 50 POP 04B8 80 DUP1 04B9 60 PUSH1 0x01 04BB 60 PUSH1 0x01 04BD 60 PUSH1 0xa0 04BF 1B SHL 04C0 03 SUB 04C1 16 AND 04C2 83 DUP4 04C3 60 PUSH1 0x01 04C5 60 PUSH1 0x01 04C7 60 PUSH1 0xa0 04C9 1B SHL 04CA 03 SUB 04CB 16 AND 04CC 03 SUB 04CD 61 PUSH2 0x04e9 04D0 57 *JUMPI // Stack delta = -1 // Outputs[1] { @04B6 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x04e9, if ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) label_04D1: // Incoming jump from 0x04D0, if not ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @04D3 memory[0x40:0x60] // @04E3 memory[0x40:0x60] // @04E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04D1 60 PUSH1 0x40 04D3 51 MLOAD 04D4 63 PUSH4 0x250fdee3 04D9 60 PUSH1 0xe2 04DB 1B SHL 04DC 81 DUP2 04DD 52 MSTORE 04DE 60 PUSH1 0x04 04E0 01 ADD 04E1 60 PUSH1 0x40 04E3 51 MLOAD 04E4 80 DUP1 04E5 91 SWAP2 04E6 03 SUB 04E7 90 SWAP1 04E8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @04DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @04E8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_04E9: // Incoming jump from 0x04D0, if ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @04EA msg.sender // @04F3 stack[-1] // } 04E9 5B JUMPDEST 04EA 33 CALLER 04EB 60 PUSH1 0x01 04ED 60 PUSH1 0x01 04EF 60 PUSH1 0xa0 04F1 1B SHL 04F2 03 SUB 04F3 82 DUP3 04F4 16 AND 04F5 14 EQ 04F6 80 DUP1 04F7 15 ISZERO 04F8 90 SWAP1 04F9 61 PUSH2 0x0509 04FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F8 stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x0509, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_04FD: // Incoming jump from 0x04FC, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0501 stack[-2] // @0502 msg.sender // } 04FD 50 POP 04FE 61 PUSH2 0x0507 0501 81 DUP2 0502 33 CALLER 0503 61 PUSH2 0x0341 0506 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04FE stack[-1] = 0x0507 // @0501 stack[0] = stack[-2] // @0502 stack[1] = msg.sender // } // Block ends with call to 0x0341, returns to 0x0507 label_0507: // Incoming return from call to 0x0341 at 0x0506 // Inputs[1] { @0508 stack[-1] } 0507 5B JUMPDEST 0508 15 ISZERO // Stack delta = +0 // Outputs[1] { @0508 stack[-1] = !stack[-1] } // Block continues label_0509: // Incoming jump from 0x04FC, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming jump from 0x0508 // Inputs[1] { @050A stack[-1] } 0509 5B JUMPDEST 050A 15 ISZERO 050B 61 PUSH2 0x0527 050E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0527, if !stack[-1] label_050F: // Incoming jump from 0x050E, if not !stack[-1] // Inputs[3] // { // @0511 memory[0x40:0x60] // @0521 memory[0x40:0x60] // @0526 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 050F 60 PUSH1 0x40 0511 51 MLOAD 0512 63 PUSH4 0x67d9dca1 0517 60 PUSH1 0xe1 0519 1B SHL 051A 81 DUP2 051B 52 MSTORE 051C 60 PUSH1 0x04 051E 01 ADD 051F 60 PUSH1 0x40 0521 51 MLOAD 0522 80 DUP1 0523 91 SWAP2 0524 03 SUB 0525 90 SWAP1 0526 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @051B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @0526 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0527: // Incoming jump from 0x050E, if !stack[-1] // Inputs[3] // { // @052B stack[-3] // @052C stack[-2] // @052D stack[-1] // } 0527 5B JUMPDEST 0528 61 PUSH2 0x0532 052B 83 DUP4 052C 83 DUP4 052D 83 DUP4 052E 61 PUSH2 0x0b06 0531 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0528 stack[0] = 0x0532 // @052B stack[1] = stack[-3] // @052C stack[2] = stack[-2] // @052D stack[3] = stack[-1] // } // Block ends with call to 0x0b06, returns to 0x0532 label_0532: // Incoming return from call to 0x0B06 at 0x0531 // Incoming return from call to 0x0B62 at 0x0541 // Incoming return from call to 0x08E6 at 0x055C // Inputs[1] { @0536 stack[-4] } 0532 5B JUMPDEST 0533 50 POP 0534 50 POP 0535 50 POP 0536 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0537: // Incoming jump from 0x021D // Inputs[3] // { // @053B stack[-3] // @053C stack[-2] // @053D stack[-1] // } 0537 5B JUMPDEST 0538 61 PUSH2 0x0532 053B 83 DUP4 053C 83 DUP4 053D 83 DUP4 053E 61 PUSH2 0x0b62 0541 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0538 stack[0] = 0x0532 // @053B stack[1] = stack[-3] // @053C stack[2] = stack[-2] // @053D stack[3] = stack[-1] // } // Block ends with call to 0x0b62, returns to 0x0532 label_0542: // Incoming jump from 0x0239 // Inputs[4] // { // @0546 stack[-3] // @0547 stack[-2] // @0548 stack[-1] // @054B memory[0x40:0x60] // } 0542 5B JUMPDEST 0543 61 PUSH2 0x0532 0546 83 DUP4 0547 83 DUP4 0548 83 DUP4 0549 60 PUSH1 0x40 054B 51 MLOAD 054C 80 DUP1 054D 60 PUSH1 0x20 054F 01 ADD 0550 60 PUSH1 0x40 0552 52 MSTORE 0553 80 DUP1 0554 60 PUSH1 0x00 0556 81 DUP2 0557 52 MSTORE 0558 50 POP 0559 61 PUSH2 0x08e6 055C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0543 stack[0] = 0x0532 // @0546 stack[1] = stack[-3] // @0547 stack[2] = stack[-2] // @0548 stack[3] = stack[-1] // @054B stack[4] = memory[0x40:0x60] // @0552 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0557 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x08e6, returns to 0x0532 label_055D: // Incoming jump from 0x024C // Inputs[2] // { // @0560 storage[0x08] // @056A msg.sender // } 055D 5B JUMPDEST 055E 60 PUSH1 0x08 0560 54 SLOAD 0561 60 PUSH1 0x01 0563 60 PUSH1 0x01 0565 60 PUSH1 0xa0 0567 1B SHL 0568 03 SUB 0569 16 AND 056A 33 CALLER 056B 14 EQ 056C 61 PUSH2 0x0590 056F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0590, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0570: // Incoming jump from 0x056F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0572 memory[0x40:0x60] } 0570 60 PUSH1 0x40 0572 51 MLOAD 0573 62 PUSH3 0x461bcd 0577 60 PUSH1 0xe5 0579 1B SHL 057A 81 DUP2 057B 52 MSTORE 057C 60 PUSH1 0x04 057E 01 ADD 057F 61 PUSH2 0x0587 0582 90 SWAP1 0583 61 PUSH2 0x1744 0586 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @057B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0582 stack[0] = 0x0587 // @0582 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1744, returns to 0x0587 label_0587: // Incoming return from call to 0x1744 at 0x0A69 // Incoming return from call to 0x1744 at 0x0586 // Incoming jump from 0x06A0 // Incoming return from call to 0x1744 at 0x0960 // Incoming return from call to 0x1744 at 0x0645 // Incoming return from call to 0x1744 at 0x082E // Incoming jump from 0x0ACE // Incoming jump from 0x0753 // Incoming jump from 0x07BE // Incoming jump from 0x09E3 // Incoming jump from 0x06F3 // Inputs[3] // { // @058A memory[0x40:0x60] // @058C stack[-1] // @058F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0587 5B JUMPDEST 0588 60 PUSH1 0x40 058A 51 MLOAD 058B 80 DUP1 058C 91 SWAP2 058D 03 SUB 058E 90 SWAP1 058F FD *REVERT // Stack delta = -1 // Outputs[1] { @058F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0590: // Incoming jump from 0x056F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[5] // { // @0599 stack[-2] // @059A stack[-1] // @05AA memory[0x00:0x40] // @05AC storage[keccak256(memory[0x00:0x40])] // @05BA stack[-3] // } 0590 5B JUMPDEST 0591 60 PUSH1 0x01 0593 60 PUSH1 0x01 0595 60 PUSH1 0xa0 0597 1B SHL 0598 03 SUB 0599 91 SWAP2 059A 90 SWAP1 059B 91 SWAP2 059C 16 AND 059D 60 PUSH1 0x00 059F 90 SWAP1 05A0 81 DUP2 05A1 52 MSTORE 05A2 60 PUSH1 0x0c 05A4 60 PUSH1 0x20 05A6 52 MSTORE 05A7 60 PUSH1 0x40 05A9 90 SWAP1 05AA 20 SHA3 05AB 80 DUP1 05AC 54 SLOAD 05AD 60 PUSH1 0xff 05AF 19 NOT 05B0 16 AND 05B1 91 SWAP2 05B2 15 ISZERO 05B3 15 ISZERO 05B4 91 SWAP2 05B5 90 SWAP1 05B6 91 SWAP2 05B7 17 OR 05B8 90 SWAP1 05B9 55 SSTORE 05BA 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @05A1 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @05A6 memory[0x20:0x40] = 0x0c // @05B9 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] label_05BB: // Incoming jump from 0x025F // Incoming call from 0x04B4, returns to 0x04B5 // Inputs[1] { @05C1 stack[-1] } 05BB 5B JUMPDEST 05BC 60 PUSH1 0x00 05BE 61 PUSH2 0x05c6 05C1 82 DUP3 05C2 61 PUSH2 0x0d51 05C5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05BC stack[0] = 0x00 // @05BE stack[1] = 0x05c6 // @05C1 stack[2] = stack[-1] // } // Block ends with call to 0x0d51, returns to 0x05C6 label_05C6: // Incoming return from call to 0x0D51 at 0x05C5 // Inputs[4] // { // @05C7 memory[stack[-1]:stack[-1] + 0x20] // @05C7 stack[-1] // @05C8 stack[-4] // @05C9 stack[-3] // } 05C6 5B JUMPDEST 05C7 51 MLOAD 05C8 92 SWAP3 05C9 91 SWAP2 05CA 50 POP 05CB 50 POP 05CC 56 *JUMP // Stack delta = -3 // Outputs[1] { @05C8 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_05CD: // Incoming jump from 0x0272 // Inputs[1] { @05D8 stack[-1] } 05CD 5B JUMPDEST 05CE 60 PUSH1 0x00 05D0 60 PUSH1 0x01 05D2 60 PUSH1 0x01 05D4 60 PUSH1 0xa0 05D6 1B SHL 05D7 03 SUB 05D8 82 DUP3 05D9 16 AND 05DA 61 PUSH2 0x05f6 05DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05CE stack[0] = 0x00 } // Block ends with conditional jump to 0x05f6, if stack[-1] & (0x01 << 0xa0) - 0x01 label_05DE: // Incoming jump from 0x05DD, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @05E0 memory[0x40:0x60] // @05F0 memory[0x40:0x60] // @05F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05DE 60 PUSH1 0x40 05E0 51 MLOAD 05E1 63 PUSH4 0x23d3ad81 05E6 60 PUSH1 0xe2 05E8 1B SHL 05E9 81 DUP2 05EA 52 MSTORE 05EB 60 PUSH1 0x04 05ED 01 ADD 05EE 60 PUSH1 0x40 05F0 51 MLOAD 05F1 80 DUP1 05F2 91 SWAP2 05F3 03 SUB 05F4 90 SWAP1 05F5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @05EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @05F5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_05F6: // Incoming jump from 0x05DD, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0600 stack[-2] // @060E memory[0x00:0x40] // @060F storage[keccak256(memory[0x00:0x40])] // @061A stack[-3] // } 05F6 5B JUMPDEST 05F7 50 POP 05F8 60 PUSH1 0x01 05FA 60 PUSH1 0x01 05FC 60 PUSH1 0xa0 05FE 1B SHL 05FF 03 SUB 0600 16 AND 0601 60 PUSH1 0x00 0603 90 SWAP1 0604 81 DUP2 0605 52 MSTORE 0606 60 PUSH1 0x05 0608 60 PUSH1 0x20 060A 52 MSTORE 060B 60 PUSH1 0x40 060D 90 SWAP1 060E 20 SHA3 060F 54 SLOAD 0610 67 PUSH8 0xffffffffffffffff 0619 16 AND 061A 90 SWAP1 061B 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0605 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @060A memory[0x20:0x40] = 0x05 // @061A stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_061C: // Incoming call from 0x027A, returns to 0x01F3 // Inputs[2] // { // @061F storage[0x08] // @0629 msg.sender // } 061C 5B JUMPDEST 061D 60 PUSH1 0x08 061F 54 SLOAD 0620 60 PUSH1 0x01 0622 60 PUSH1 0x01 0624 60 PUSH1 0xa0 0626 1B SHL 0627 03 SUB 0628 16 AND 0629 33 CALLER 062A 14 EQ 062B 61 PUSH2 0x0646 062E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0646, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_062F: // Incoming jump from 0x062E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0631 memory[0x40:0x60] } 062F 60 PUSH1 0x40 0631 51 MLOAD 0632 62 PUSH3 0x461bcd 0636 60 PUSH1 0xe5 0638 1B SHL 0639 81 DUP2 063A 52 MSTORE 063B 60 PUSH1 0x04 063D 01 ADD 063E 61 PUSH2 0x0587 0641 90 SWAP1 0642 61 PUSH2 0x1744 0645 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @063A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0641 stack[0] = 0x0587 // @0641 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1744, returns to 0x0587 label_0646: // Incoming jump from 0x062E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0646 5B JUMPDEST 0647 61 PUSH2 0x0650 064A 60 PUSH1 0x00 064C 61 PUSH2 0x0e6d 064F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0647 stack[0] = 0x0650 // @064A stack[1] = 0x00 // } // Block ends with call to 0x0e6d, returns to 0x0650 label_0650: // Incoming return from call to 0x0E6D at 0x064F // Inputs[1] { @0651 stack[-1] } 0650 5B JUMPDEST 0651 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0652: // Incoming jump from 0x028D // Inputs[2] // { // @0653 tx.origin // @0654 msg.sender // } 0652 5B JUMPDEST 0653 32 ORIGIN 0654 33 CALLER 0655 14 EQ 0656 61 PUSH2 0x06a1 0659 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a1, if msg.sender == tx.origin label_065A: // Incoming jump from 0x0659, if not msg.sender == tx.origin // Inputs[1] { @065C memory[0x40:0x60] } 065A 60 PUSH1 0x40 065C 51 MLOAD 065D 62 PUSH3 0x461bcd 0661 60 PUSH1 0xe5 0663 1B SHL 0664 81 DUP2 0665 52 MSTORE 0666 60 PUSH1 0x20 0668 60 PUSH1 0x04 066A 82 DUP3 066B 01 ADD 066C 52 MSTORE 066D 60 PUSH1 0x1e 066F 60 PUSH1 0x24 0671 82 DUP3 0672 01 ADD 0673 52 MSTORE 0674 7F PUSH32 0x5468652063616c6c657220697320616e6f7468657220636f6e74726163740000 0695 60 PUSH1 0x44 0697 82 DUP3 0698 01 ADD 0699 52 MSTORE 069A 60 PUSH1 0x64 069C 01 ADD 069D 61 PUSH2 0x0587 06A0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0665 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @066C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0673 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0699 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468652063616c6c657220697320616e6f7468657220636f6e74726163740000 // @069C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0587 label_06A1: // Incoming jump from 0x0659, if msg.sender == tx.origin // Inputs[1] { @06A4 storage[0x0b] } 06A1 5B JUMPDEST 06A2 60 PUSH1 0x0b 06A4 54 SLOAD 06A5 60 PUSH1 0xff 06A7 16 AND 06A8 15 ISZERO 06A9 61 PUSH2 0x06f4 06AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f4, if !(0xff & storage[0x0b]) label_06AD: // Incoming jump from 0x06AC, if not !(0xff & storage[0x0b]) // Inputs[1] { @06AF memory[0x40:0x60] } 06AD 60 PUSH1 0x40 06AF 51 MLOAD 06B0 62 PUSH3 0x461bcd 06B4 60 PUSH1 0xe5 06B6 1B SHL 06B7 81 DUP2 06B8 52 MSTORE 06B9 60 PUSH1 0x20 06BB 60 PUSH1 0x04 06BD 82 DUP3 06BE 01 ADD 06BF 52 MSTORE 06C0 60 PUSH1 0x1c 06C2 60 PUSH1 0x24 06C4 82 DUP3 06C5 01 ADD 06C6 52 MSTORE 06C7 7F PUSH32 0x4d696e74696e67206973207061757365642063757272656e746c792e00000000 06E8 60 PUSH1 0x44 06EA 82 DUP3 06EB 01 ADD 06EC 52 MSTORE 06ED 60 PUSH1 0x64 06EF 01 ADD 06F0 61 PUSH2 0x0587 06F3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @06B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06BF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06C6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @06EC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d696e74696e67206973207061757365642063757272656e746c792e00000000 // @06EF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0587 label_06F4: // Incoming jump from 0x06AC, if !(0xff & storage[0x0b]) // Inputs[4] // { // @06F7 storage[0x09] // @06F8 stack[-1] // @06F9 memory[stack[-1]:stack[-1] + 0x20] // @06FC storage[0x00] // } 06F4 5B JUMPDEST 06F5 60 PUSH1 0x09 06F7 54 SLOAD 06F8 81 DUP2 06F9 51 MLOAD 06FA 60 PUSH1 0x00 06FC 54 SLOAD 06FD 61 PUSH2 0x0706 0700 91 SWAP2 0701 90 SWAP1 0702 61 PUSH2 0x178f 0705 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06F7 stack[0] = storage[0x09] // @0700 stack[1] = 0x0706 // @0701 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // @0701 stack[3] = storage[0x00] // } // Block ends with call to 0x178f, returns to 0x0706 label_0706: // Incoming return from call to 0x178F at 0x0705 // Inputs[2] // { // @0707 stack[-2] // @0707 stack[-1] // } 0706 5B JUMPDEST 0707 11 GT 0708 15 ISZERO 0709 61 PUSH2 0x0754 070C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0754, if !(stack[-1] > stack[-2]) label_070D: // Incoming jump from 0x070C, if not !(stack[-1] > stack[-2]) // Inputs[1] { @070F memory[0x40:0x60] } 070D 60 PUSH1 0x40 070F 51 MLOAD 0710 62 PUSH3 0x461bcd 0714 60 PUSH1 0xe5 0716 1B SHL 0717 81 DUP2 0718 52 MSTORE 0719 60 PUSH1 0x20 071B 60 PUSH1 0x04 071D 82 DUP3 071E 01 ADD 071F 52 MSTORE 0720 60 PUSH1 0x1d 0722 60 PUSH1 0x24 0724 82 DUP3 0725 01 ADD 0726 52 MSTORE 0727 7F PUSH32 0x596f752063616e6e6f7420657863656564206d617820737570706c792e000000 0748 60 PUSH1 0x44 074A 82 DUP3 074B 01 ADD 074C 52 MSTORE 074D 60 PUSH1 0x64 074F 01 ADD 0750 61 PUSH2 0x0587 0753 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0718 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @071F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0726 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @074C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f752063616e6e6f7420657863656564206d617820737570706c792e000000 // @074F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0587 label_0754: // Incoming jump from 0x070C, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @0755 msg.sender // @0763 memory[0x00:0x40] // @0764 storage[keccak256(memory[0x00:0x40])] // } 0754 5B JUMPDEST 0755 33 CALLER 0756 60 PUSH1 0x00 0758 90 SWAP1 0759 81 DUP2 075A 52 MSTORE 075B 60 PUSH1 0x0c 075D 60 PUSH1 0x20 075F 52 MSTORE 0760 60 PUSH1 0x40 0762 90 SWAP1 0763 20 SHA3 0764 54 SLOAD 0765 60 PUSH1 0xff 0767 16 AND 0768 61 PUSH2 0x07bf 076B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @075A memory[0x00:0x20] = msg.sender // @075F memory[0x20:0x40] = 0x0c // } // Block ends with conditional jump to 0x07bf, if 0xff & storage[keccak256(memory[0x00:0x40])] label_076C: // Incoming jump from 0x076B, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @076E memory[0x40:0x60] } 076C 60 PUSH1 0x40 076E 51 MLOAD 076F 62 PUSH3 0x461bcd 0773 60 PUSH1 0xe5 0775 1B SHL 0776 81 DUP2 0777 52 MSTORE 0778 60 PUSH1 0x20 077A 60 PUSH1 0x04 077C 82 DUP3 077D 01 ADD 077E 52 MSTORE 077F 60 PUSH1 0x23 0781 60 PUSH1 0x24 0783 82 DUP3 0784 01 ADD 0785 52 MSTORE 0786 7F PUSH32 0x4f6e6c79206d696e7461626c652066726f6d2061646d696e2061646472657373 07A7 60 PUSH1 0x44 07A9 82 DUP3 07AA 01 ADD 07AB 52 MSTORE 07AC 62 PUSH3 0x32b997 07B0 60 PUSH1 0xe9 07B2 1B SHL 07B3 60 PUSH1 0x64 07B5 82 DUP3 07B6 01 ADD 07B7 52 MSTORE 07B8 60 PUSH1 0x84 07BA 01 ADD 07BB 61 PUSH2 0x0587 07BE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0777 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @077E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0785 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @07AB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79206d696e7461626c652066726f6d2061646d696e2061646472657373 // @07B7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x32b997 << 0xe9 // @07BA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0587 label_07BF: // Incoming jump from 0x076B, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @07C3 stack[-1] // @07C4 memory[stack[-1]:stack[-1] + 0x20] // } 07BF 5B JUMPDEST 07C0 60 PUSH1 0x00 07C2 5B JUMPDEST 07C3 81 DUP2 07C4 51 MLOAD 07C5 81 DUP2 07C6 10 LT 07C7 15 ISZERO 07C8 61 PUSH2 0x0801 07CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07C0 stack[0] = 0x00 } // Block ends with conditional jump to 0x0801, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_07CC: // Incoming jump from 0x07CB, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @07CF stack[-2] // @07D0 stack[-1] // @07D2 memory[stack[-2]:stack[-2] + 0x20] // } 07CC 61 PUSH2 0x07ef 07CF 82 DUP3 07D0 82 DUP3 07D1 81 DUP2 07D2 51 MLOAD 07D3 81 DUP2 07D4 10 LT 07D5 61 PUSH2 0x07e0 07D8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @07CC stack[0] = 0x07ef // @07CF stack[1] = stack[-2] // @07D0 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x07e0, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_07D9: // Incoming jump from 0x07D8, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 07D9 61 PUSH2 0x07e0 07DC 61 PUSH2 0x17a7 07DF 56 *JUMP // Stack delta = +1 // Outputs[1] { @07D9 stack[0] = 0x07e0 } // Block ends with unconditional jump to 0x17a7 label_07E0: // Incoming jump from 0x07D8, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @07E3 stack[-1] // @07E7 stack[-2] // @07E8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 07E0 5B JUMPDEST 07E1 60 PUSH1 0x20 07E3 02 MUL 07E4 60 PUSH1 0x20 07E6 01 ADD 07E7 01 ADD 07E8 51 MLOAD 07E9 60 PUSH1 0x01 07EB 61 PUSH2 0x0ebf 07EE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @07E8 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @07E9 stack[-1] = 0x01 // } // Block ends with unconditional jump to 0x0ebf 07EF 5B JUMPDEST 07F0 80 DUP1 07F1 61 PUSH2 0x07f9 07F4 81 DUP2 07F5 61 PUSH2 0x17bd 07F8 56 *JUMP 07F9 5B JUMPDEST 07FA 91 SWAP2 07FB 50 POP 07FC 50 POP 07FD 61 PUSH2 0x07c2 0800 56 *JUMP label_0801: // Incoming jump from 0x07CB, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @0804 stack[-3] } 0801 5B JUMPDEST 0802 50 POP 0803 50 POP 0804 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0805: // Incoming jump from 0x02B1 // Inputs[2] // { // @0808 storage[0x08] // @0812 msg.sender // } 0805 5B JUMPDEST 0806 60 PUSH1 0x08 0808 54 SLOAD 0809 60 PUSH1 0x01 080B 60 PUSH1 0x01 080D 60 PUSH1 0xa0 080F 1B SHL 0810 03 SUB 0811 16 AND 0812 33 CALLER 0813 14 EQ 0814 61 PUSH2 0x082f 0817 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x082f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0818: // Incoming jump from 0x0817, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @081A memory[0x40:0x60] } 0818 60 PUSH1 0x40 081A 51 MLOAD 081B 62 PUSH3 0x461bcd 081F 60 PUSH1 0xe5 0821 1B SHL 0822 81 DUP2 0823 52 MSTORE 0824 60 PUSH1 0x04 0826 01 ADD 0827 61 PUSH2 0x0587 082A 90 SWAP1 082B 61 PUSH2 0x1744 082E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0823 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @082A stack[0] = 0x0587 // @082A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1744, returns to 0x0587 label_082F: // Incoming jump from 0x0817, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0830 stack[-1] // @0831 memory[stack[-1]:stack[-1] + 0x20] // } 082F 5B JUMPDEST 0830 80 DUP1 0831 51 MLOAD 0832 61 PUSH2 0x0801 0835 90 SWAP1 0836 60 PUSH1 0x0a 0838 90 SWAP1 0839 60 PUSH1 0x20 083B 84 DUP5 083C 01 ADD 083D 90 SWAP1 083E 61 PUSH2 0x129d 0841 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0835 stack[0] = 0x0801 // @0838 stack[1] = 0x0a // @083D stack[2] = stack[-1] + 0x20 // @083D stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x129d label_0842: // Incoming call from 0x02B9, returns to 0x01A8 // Inputs[1] { @0848 storage[0x03] } 0842 5B JUMPDEST 0843 60 PUSH1 0x60 0845 60 PUSH1 0x03 0847 80 DUP1 0848 54 SLOAD 0849 61 PUSH2 0x03e3 084C 90 SWAP1 084D 61 PUSH2 0x170a 0850 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0843 stack[0] = 0x60 // @0845 stack[1] = 0x03 // @084C stack[2] = 0x03e3 // @084C stack[3] = storage[0x03] // } // Block ends with call to 0x170a, returns to 0x03E3 label_0851: // Incoming jump from 0x02EF // Inputs[2] // { // @0852 msg.sender // @085B stack[-2] // } 0851 5B JUMPDEST 0852 33 CALLER 0853 60 PUSH1 0x01 0855 60 PUSH1 0x01 0857 60 PUSH1 0xa0 0859 1B SHL 085A 03 SUB 085B 83 DUP4 085C 16 AND 085D 03 SUB 085E 61 PUSH2 0x087a 0861 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x087a, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender label_0862: // Incoming jump from 0x0861, if not (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[3] // { // @0864 memory[0x40:0x60] // @0874 memory[0x40:0x60] // @0879 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0862 60 PUSH1 0x40 0864 51 MLOAD 0865 63 PUSH4 0xb06307db 086A 60 PUSH1 0xe0 086C 1B SHL 086D 81 DUP2 086E 52 MSTORE 086F 60 PUSH1 0x04 0871 01 ADD 0872 60 PUSH1 0x40 0874 51 MLOAD 0875 80 DUP1 0876 91 SWAP2 0877 03 SUB 0878 90 SWAP1 0879 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @086E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @0879 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_087A: // Incoming jump from 0x0861, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[10] // { // @087B msg.sender // @088C memory[0x00:0x40] // @0895 stack[-2] // @08A0 memory[0x00:0x40] // @08A2 storage[keccak256(memory[0x00:0x40])] // @08A7 stack[-1] // @08B1 memory[0x40:0x60] // @08DD memory[0x40:0x60] // @08E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @08E5 stack[-3] // } 087A 5B JUMPDEST 087B 33 CALLER 087C 60 PUSH1 0x00 087E 81 DUP2 087F 81 DUP2 0880 52 MSTORE 0881 60 PUSH1 0x07 0883 60 PUSH1 0x20 0885 90 SWAP1 0886 81 DUP2 0887 52 MSTORE 0888 60 PUSH1 0x40 088A 80 DUP1 088B 83 DUP4 088C 20 SHA3 088D 60 PUSH1 0x01 088F 60 PUSH1 0x01 0891 60 PUSH1 0xa0 0893 1B SHL 0894 03 SUB 0895 87 DUP8 0896 16 AND 0897 80 DUP1 0898 85 DUP6 0899 52 MSTORE 089A 90 SWAP1 089B 83 DUP4 089C 52 MSTORE 089D 92 SWAP3 089E 81 DUP2 089F 90 SWAP1 08A0 20 SHA3 08A1 80 DUP1 08A2 54 SLOAD 08A3 60 PUSH1 0xff 08A5 19 NOT 08A6 16 AND 08A7 86 DUP7 08A8 15 ISZERO 08A9 15 ISZERO 08AA 90 SWAP1 08AB 81 DUP2 08AC 17 OR 08AD 90 SWAP1 08AE 91 SWAP2 08AF 55 SSTORE 08B0 90 SWAP1 08B1 51 MLOAD 08B2 90 SWAP1 08B3 81 DUP2 08B4 52 MSTORE 08B5 91 SWAP2 08B6 92 SWAP3 08B7 91 SWAP2 08B8 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 08D9 91 SWAP2 08DA 01 ADD 08DB 60 PUSH1 0x40 08DD 51 MLOAD 08DE 80 DUP1 08DF 91 SWAP2 08E0 03 SUB 08E1 90 SWAP1 08E2 A3 LOG3 08E3 50 POP 08E4 50 POP 08E5 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0880 memory[0x00:0x20] = msg.sender // @0887 memory[0x20:0x40] = 0x07 // @0899 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @089C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @08AF storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @08B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @08E2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_08E6: // Incoming call from 0x055C, returns to 0x0532 // Incoming jump from 0x0317 // Inputs[3] // { // @08EA stack[-4] // @08EB stack[-3] // @08EC stack[-2] // } 08E6 5B JUMPDEST 08E7 61 PUSH2 0x08f1 08EA 84 DUP5 08EB 84 DUP5 08EC 84 DUP5 08ED 61 PUSH2 0x0b62 08F0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08E7 stack[0] = 0x08f1 // @08EA stack[1] = stack[-4] // @08EB stack[2] = stack[-3] // @08EC stack[3] = stack[-2] // } // Block ends with call to 0x0b62, returns to 0x08F1 label_08F1: // Incoming return from call to 0x0B62 at 0x08F0 // Inputs[2] // { // @08FA stack[-3] // @08FC address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 08F1 5B JUMPDEST 08F2 60 PUSH1 0x01 08F4 60 PUSH1 0x01 08F6 60 PUSH1 0xa0 08F8 1B SHL 08F9 03 SUB 08FA 83 DUP4 08FB 16 AND 08FC 3B EXTCODESIZE 08FD 15 ISZERO 08FE 15 ISZERO 08FF 80 DUP1 0900 15 ISZERO 0901 61 PUSH2 0x0913 0904 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08FE stack[0] = !!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length } // Block ends with conditional jump to 0x0913, if !!!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_0905: // Incoming jump from 0x0904, if not !!!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @0909 stack[-5] // @090A stack[-4] // @090B stack[-3] // @090C stack[-2] // } 0905 50 POP 0906 61 PUSH2 0x0911 0909 84 DUP5 090A 84 DUP5 090B 84 DUP5 090C 84 DUP5 090D 61 PUSH2 0x0ed9 0910 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0906 stack[-1] = 0x0911 // @0909 stack[0] = stack[-5] // @090A stack[1] = stack[-4] // @090B stack[2] = stack[-3] // @090C stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x0ed9 0911 5B JUMPDEST 0912 15 ISZERO label_0913: // Incoming jump from 0x0904, if !!!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0914 stack[-1] } 0913 5B JUMPDEST 0914 15 ISZERO 0915 61 PUSH2 0x0931 0918 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0931, if !stack[-1] label_0919: // Incoming jump from 0x0918, if not !stack[-1] // Inputs[3] // { // @091B memory[0x40:0x60] // @092B memory[0x40:0x60] // @0930 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0919 60 PUSH1 0x40 091B 51 MLOAD 091C 63 PUSH4 0x68d2bf6b 0921 60 PUSH1 0xe1 0923 1B SHL 0924 81 DUP2 0925 52 MSTORE 0926 60 PUSH1 0x04 0928 01 ADD 0929 60 PUSH1 0x40 092B 51 MLOAD 092C 80 DUP1 092D 91 SWAP2 092E 03 SUB 092F 90 SWAP1 0930 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0925 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @0930 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0931: // Incoming jump from 0x138C, if !(stack[-1] > stack[-4]) // Incoming jump from 0x0918, if !stack[-1] // Incoming call from 0x129C, returns to 0x0931 // Incoming return from call to 0x0931 at 0x129C // Inputs[1] { @0936 stack[-5] } 0931 5B JUMPDEST 0932 50 POP 0933 50 POP 0934 50 POP 0935 50 POP 0936 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0937: // Incoming call from 0x031F, returns to 0x01F3 // Inputs[2] // { // @093A storage[0x08] // @0944 msg.sender // } 0937 5B JUMPDEST 0938 60 PUSH1 0x08 093A 54 SLOAD 093B 60 PUSH1 0x01 093D 60 PUSH1 0x01 093F 60 PUSH1 0xa0 0941 1B SHL 0942 03 SUB 0943 16 AND 0944 33 CALLER 0945 14 EQ 0946 61 PUSH2 0x0961 0949 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0961, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_094A: // Incoming jump from 0x0949, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @094C memory[0x40:0x60] } 094A 60 PUSH1 0x40 094C 51 MLOAD 094D 62 PUSH3 0x461bcd 0951 60 PUSH1 0xe5 0953 1B SHL 0954 81 DUP2 0955 52 MSTORE 0956 60 PUSH1 0x04 0958 01 ADD 0959 61 PUSH2 0x0587 095C 90 SWAP1 095D 61 PUSH2 0x1744 0960 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0955 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @095C stack[0] = 0x0587 // @095C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1744, returns to 0x0587 label_0961: // Incoming jump from 0x0949, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0965 storage[0x0b] // @0974 stack[-1] // } 0961 5B JUMPDEST 0962 60 PUSH1 0x0b 0964 80 DUP1 0965 54 SLOAD 0966 60 PUSH1 0xff 0968 19 NOT 0969 81 DUP2 096A 16 AND 096B 60 PUSH1 0xff 096D 90 SWAP1 096E 91 SWAP2 096F 16 AND 0970 15 ISZERO 0971 17 OR 0972 90 SWAP1 0973 55 SSTORE 0974 56 *JUMP // Stack delta = -1 // Outputs[1] { @0973 storage[0x0b] = !(storage[0x0b] & 0xff) | (storage[0x0b] & ~0xff) } // Block ends with unconditional jump to stack[-1] label_0975: // Incoming jump from 0x0332 // Inputs[1] { @097B stack[-1] } 0975 5B JUMPDEST 0976 60 PUSH1 0x60 0978 61 PUSH2 0x0980 097B 82 DUP3 097C 61 PUSH2 0x0adb 097F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0976 stack[0] = 0x60 // @0978 stack[1] = 0x0980 // @097B stack[2] = stack[-1] // } // Block ends with call to 0x0adb, returns to 0x0980 label_0980: // Incoming return from call to 0x0ADB at 0x097F // Inputs[1] { @0984 stack[-1] } 0980 5B JUMPDEST 0981 61 PUSH2 0x09e4 0984 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09e4, if stack[-1] label_0985: // Incoming jump from 0x0984, if not stack[-1] // Inputs[1] { @0987 memory[0x40:0x60] } 0985 60 PUSH1 0x40 0987 51 MLOAD 0988 62 PUSH3 0x461bcd 098C 60 PUSH1 0xe5 098E 1B SHL 098F 81 DUP2 0990 52 MSTORE 0991 60 PUSH1 0x20 0993 60 PUSH1 0x04 0995 82 DUP3 0996 01 ADD 0997 52 MSTORE 0998 60 PUSH1 0x2f 099A 60 PUSH1 0x24 099C 82 DUP3 099D 01 ADD 099E 52 MSTORE 099F 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 09C0 60 PUSH1 0x44 09C2 82 DUP3 09C3 01 ADD 09C4 52 MSTORE 09C5 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 09D5 60 PUSH1 0x89 09D7 1B SHL 09D8 60 PUSH1 0x64 09DA 82 DUP3 09DB 01 ADD 09DC 52 MSTORE 09DD 60 PUSH1 0x84 09DF 01 ADD 09E0 61 PUSH2 0x0587 09E3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0990 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0997 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @099E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @09C4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @09DC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @09DF stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0587 label_09E4: // Incoming jump from 0x0984, if stack[-1] 09E4 5B JUMPDEST 09E5 60 PUSH1 0x00 09E7 61 PUSH2 0x09ee 09EA 61 PUSH2 0x0fc5 09ED 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09E5 stack[0] = 0x00 // @09E7 stack[1] = 0x09ee // } // Block ends with unconditional jump to 0x0fc5 09EE 5B JUMPDEST 09EF 90 SWAP1 09F0 50 POP 09F1 80 DUP1 09F2 51 MLOAD 09F3 60 PUSH1 0x00 09F5 03 SUB 09F6 61 PUSH2 0x0a0e 09F9 57 *JUMPI 09FA 60 PUSH1 0x40 09FC 51 MLOAD 09FD 80 DUP1 09FE 60 PUSH1 0x20 0A00 01 ADD 0A01 60 PUSH1 0x40 0A03 52 MSTORE 0A04 80 DUP1 0A05 60 PUSH1 0x00 0A07 81 DUP2 0A08 52 MSTORE 0A09 50 POP 0A0A 61 PUSH2 0x0a39 0A0D 56 *JUMP 0A0E 5B JUMPDEST 0A0F 80 DUP1 0A10 61 PUSH2 0x0a18 0A13 84 DUP5 0A14 61 PUSH2 0x0fd4 0A17 56 *JUMP 0A18 5B JUMPDEST 0A19 60 PUSH1 0x40 0A1B 51 MLOAD 0A1C 60 PUSH1 0x20 0A1E 01 ADD 0A1F 61 PUSH2 0x0a29 0A22 92 SWAP3 0A23 91 SWAP2 0A24 90 SWAP1 0A25 61 PUSH2 0x17d6 0A28 56 *JUMP 0A29 5B JUMPDEST 0A2A 60 PUSH1 0x40 0A2C 51 MLOAD 0A2D 60 PUSH1 0x20 0A2F 81 DUP2 0A30 83 DUP4 0A31 03 SUB 0A32 03 SUB 0A33 81 DUP2 0A34 52 MSTORE 0A35 90 SWAP1 0A36 60 PUSH1 0x40 0A38 52 MSTORE label_0A39: // Incoming return from call to 0x1336 at 0x1368 // Incoming return from call to 0x13ED at 0x14C5 // Incoming return from call to 0x1336 at 0x185E // Incoming return from call to 0x1395 at 0x13D3 // Inputs[3] // { // @0A3A stack[-1] // @0A3A stack[-5] // @0A3B stack[-4] // } 0A39 5B JUMPDEST 0A3A 93 SWAP4 0A3B 92 SWAP3 0A3C 50 POP 0A3D 50 POP 0A3E 50 POP 0A3F 56 *JUMP // Stack delta = -4 // Outputs[1] { @0A3A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0A40: // Incoming jump from 0x0381 // Inputs[2] // { // @0A43 storage[0x08] // @0A4D msg.sender // } 0A40 5B JUMPDEST 0A41 60 PUSH1 0x08 0A43 54 SLOAD 0A44 60 PUSH1 0x01 0A46 60 PUSH1 0x01 0A48 60 PUSH1 0xa0 0A4A 1B SHL 0A4B 03 SUB 0A4C 16 AND 0A4D 33 CALLER 0A4E 14 EQ 0A4F 61 PUSH2 0x0a6a 0A52 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a6a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0A53: // Incoming jump from 0x0A52, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0A55 memory[0x40:0x60] } 0A53 60 PUSH1 0x40 0A55 51 MLOAD 0A56 62 PUSH3 0x461bcd 0A5A 60 PUSH1 0xe5 0A5C 1B SHL 0A5D 81 DUP2 0A5E 52 MSTORE 0A5F 60 PUSH1 0x04 0A61 01 ADD 0A62 61 PUSH2 0x0587 0A65 90 SWAP1 0A66 61 PUSH2 0x1744 0A69 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A65 stack[0] = 0x0587 // @0A65 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1744, returns to 0x0587 label_0A6A: // Incoming jump from 0x0A52, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0A73 stack[-1] } 0A6A 5B JUMPDEST 0A6B 60 PUSH1 0x01 0A6D 60 PUSH1 0x01 0A6F 60 PUSH1 0xa0 0A71 1B SHL 0A72 03 SUB 0A73 81 DUP2 0A74 16 AND 0A75 61 PUSH2 0x0acf 0A78 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0acf, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0A79: // Incoming jump from 0x0A78, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A7B memory[0x40:0x60] } 0A79 60 PUSH1 0x40 0A7B 51 MLOAD 0A7C 62 PUSH3 0x461bcd 0A80 60 PUSH1 0xe5 0A82 1B SHL 0A83 81 DUP2 0A84 52 MSTORE 0A85 60 PUSH1 0x20 0A87 60 PUSH1 0x04 0A89 82 DUP3 0A8A 01 ADD 0A8B 52 MSTORE 0A8C 60 PUSH1 0x26 0A8E 60 PUSH1 0x24 0A90 82 DUP3 0A91 01 ADD 0A92 52 MSTORE 0A93 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0AB4 60 PUSH1 0x44 0AB6 82 DUP3 0AB7 01 ADD 0AB8 52 MSTORE 0AB9 65 PUSH6 0x646472657373 0AC0 60 PUSH1 0xd0 0AC2 1B SHL 0AC3 60 PUSH1 0x64 0AC5 82 DUP3 0AC6 01 ADD 0AC7 52 MSTORE 0AC8 60 PUSH1 0x84 0ACA 01 ADD 0ACB 61 PUSH2 0x0587 0ACE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0A84 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A8B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A92 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0AB8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0AC7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0ACA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0587 label_0ACF: // Incoming jump from 0x0A78, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0AD3 stack[-1] } 0ACF 5B JUMPDEST 0AD0 61 PUSH2 0x0ad8 0AD3 81 DUP2 0AD4 61 PUSH2 0x0e6d 0AD7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AD0 stack[0] = 0x0ad8 // @0AD3 stack[1] = stack[-1] // } // Block ends with call to 0x0e6d, returns to 0x0AD8 label_0AD8: // Incoming return from call to 0x0E6D at 0x0AD7 // Incoming jump from 0x1347, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0ADA stack[-2] } 0AD8 5B JUMPDEST 0AD9 50 POP 0ADA 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0ADB: // Incoming call from 0x0470, returns to 0x0471 // Incoming call from 0x097F, returns to 0x0980 // Inputs[2] // { // @0ADF storage[0x00] // @0AE0 stack[-1] // } 0ADB 5B JUMPDEST 0ADC 60 PUSH1 0x00 0ADE 80 DUP1 0ADF 54 SLOAD 0AE0 82 DUP3 0AE1 10 LT 0AE2 80 DUP1 0AE3 15 ISZERO 0AE4 61 PUSH2 0x03ce 0AE7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0ADC stack[0] = 0x00 // @0AE1 stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x03ce, if !(stack[-1] < storage[0x00]) label_0AE8: // Incoming jump from 0x0AE7, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @0AEC stack[-3] // @0AF7 memory[0x00:0x40] // @0AF8 storage[keccak256(memory[0x00:0x40])] // @0B04 stack[-4] // } 0AE8 50 POP 0AE9 50 POP 0AEA 60 PUSH1 0x00 0AEC 90 SWAP1 0AED 81 DUP2 0AEE 52 MSTORE 0AEF 60 PUSH1 0x04 0AF1 60 PUSH1 0x20 0AF3 52 MSTORE 0AF4 60 PUSH1 0x40 0AF6 90 SWAP1 0AF7 20 SHA3 0AF8 54 SLOAD 0AF9 60 PUSH1 0x01 0AFB 60 PUSH1 0xe0 0AFD 1B SHL 0AFE 90 SWAP1 0AFF 04 DIV 0B00 60 PUSH1 0xff 0B02 16 AND 0B03 15 ISZERO 0B04 90 SWAP1 0B05 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0AEE memory[0x00:0x20] = stack[-3] // @0AF3 memory[0x20:0x40] = 0x04 // @0B04 stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_0B06: // Incoming call from 0x0531, returns to 0x0532 // Incoming call from 0x0C2F, returns to 0x0C30 // Inputs[8] // { // @0B09 stack[-2] // @0B15 memory[0x00:0x40] // @0B17 storage[keccak256(memory[0x00:0x40])] // @0B2A stack[-3] // @0B34 memory[0x40:0x60] // @0B38 stack[-1] // @0B5D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0B61 stack[-4] // } 0B06 5B JUMPDEST 0B07 60 PUSH1 0x00 0B09 82 DUP3 0B0A 81 DUP2 0B0B 52 MSTORE 0B0C 60 PUSH1 0x06 0B0E 60 PUSH1 0x20 0B10 52 MSTORE 0B11 60 PUSH1 0x40 0B13 80 DUP1 0B14 82 DUP3 0B15 20 SHA3 0B16 80 DUP1 0B17 54 SLOAD 0B18 60 PUSH1 0x01 0B1A 60 PUSH1 0x01 0B1C 60 PUSH1 0xa0 0B1E 1B SHL 0B1F 03 SUB 0B20 19 NOT 0B21 16 AND 0B22 60 PUSH1 0x01 0B24 60 PUSH1 0x01 0B26 60 PUSH1 0xa0 0B28 1B SHL 0B29 03 SUB 0B2A 87 DUP8 0B2B 81 DUP2 0B2C 16 AND 0B2D 91 SWAP2 0B2E 82 DUP3 0B2F 17 OR 0B30 90 SWAP1 0B31 92 SWAP3 0B32 55 SSTORE 0B33 91 SWAP2 0B34 51 MLOAD 0B35 85 DUP6 0B36 93 SWAP4 0B37 91 SWAP2 0B38 85 DUP6 0B39 16 AND 0B3A 91 SWAP2 0B3B 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0B5C 91 SWAP2 0B5D A4 LOG4 0B5E 50 POP 0B5F 50 POP 0B60 50 POP 0B61 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0B0B memory[0x00:0x20] = stack[-2] // @0B10 memory[0x20:0x40] = 0x06 // @0B32 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0B5D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_0B62: // Incoming call from 0x0541, returns to 0x0532 // Incoming call from 0x08F0, returns to 0x08F1 // Inputs[1] { @0B68 stack[-1] } 0B62 5B JUMPDEST 0B63 60 PUSH1 0x00 0B65 61 PUSH2 0x0b6d 0B68 82 DUP3 0B69 61 PUSH2 0x0d51 0B6C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B63 stack[0] = 0x00 // @0B65 stack[1] = 0x0b6d // @0B68 stack[2] = stack[-1] // } // Block ends with call to 0x0d51, returns to 0x0B6D label_0B6D: // Incoming return from call to 0x0D51 at 0x0B6C // Inputs[4] // { // @0B6E stack[-2] // @0B6E stack[-1] // @0B70 stack[-5] // @0B7E memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 0B6D 5B JUMPDEST 0B6E 90 SWAP1 0B6F 50 POP 0B70 83 DUP4 0B71 60 PUSH1 0x01 0B73 60 PUSH1 0x01 0B75 60 PUSH1 0xa0 0B77 1B SHL 0B78 03 SUB 0B79 16 AND 0B7A 81 DUP2 0B7B 60 PUSH1 0x00 0B7D 01 ADD 0B7E 51 MLOAD 0B7F 60 PUSH1 0x01 0B81 60 PUSH1 0x01 0B83 60 PUSH1 0xa0 0B85 1B SHL 0B86 03 SUB 0B87 16 AND 0B88 14 EQ 0B89 61 PUSH2 0x0ba4 0B8C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0B6E stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0ba4, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_0B8D: // Incoming jump from 0x0B8C, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @0B8F memory[0x40:0x60] // @0B9E memory[0x40:0x60] // @0BA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B8D 60 PUSH1 0x40 0B8F 51 MLOAD 0B90 62 PUSH3 0xa11481 0B94 60 PUSH1 0xe8 0B96 1B SHL 0B97 81 DUP2 0B98 52 MSTORE 0B99 60 PUSH1 0x04 0B9B 01 ADD 0B9C 60 PUSH1 0x40 0B9E 51 MLOAD 0B9F 80 DUP1 0BA0 91 SWAP2 0BA1 03 SUB 0BA2 90 SWAP1 0BA3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @0BA3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0BA4: // Incoming jump from 0x0B8C, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @0BA7 msg.sender // @0BB0 stack[-4] // } 0BA4 5B JUMPDEST 0BA5 60 PUSH1 0x00 0BA7 33 CALLER 0BA8 60 PUSH1 0x01 0BAA 60 PUSH1 0x01 0BAC 60 PUSH1 0xa0 0BAE 1B SHL 0BAF 03 SUB 0BB0 86 DUP7 0BB1 16 AND 0BB2 14 EQ 0BB3 80 DUP1 0BB4 61 PUSH2 0x0bc2 0BB7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0BA5 stack[0] = 0x00 // @0BB2 stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x0bc2, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_0BB8: // Incoming jump from 0x0BB7, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0BBC stack[-6] // @0BBD msg.sender // } 0BB8 50 POP 0BB9 61 PUSH2 0x0bc2 0BBC 85 DUP6 0BBD 33 CALLER 0BBE 61 PUSH2 0x0341 0BC1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BB9 stack[-1] = 0x0bc2 // @0BBC stack[0] = stack[-6] // @0BBD stack[1] = msg.sender // } // Block ends with call to 0x0341, returns to 0x0BC2 label_0BC2: // Incoming return from call to 0x0341 at 0x0BC1 // Incoming jump from 0x0BB7, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @0BC3 stack[-1] } 0BC2 5B JUMPDEST 0BC3 80 DUP1 0BC4 61 PUSH2 0x0bdd 0BC7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bdd, if stack[-1] label_0BC8: // Incoming jump from 0x0BC7, if not stack[-1] // Inputs[2] // { // @0BC9 msg.sender // @0BCD stack[-4] // } 0BC8 50 POP 0BC9 33 CALLER 0BCA 61 PUSH2 0x0bd2 0BCD 84 DUP5 0BCE 61 PUSH2 0x0466 0BD1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BC9 stack[-1] = msg.sender // @0BCA stack[0] = 0x0bd2 // @0BCD stack[1] = stack[-4] // } // Block ends with call to 0x0466, returns to 0x0BD2 label_0BD2: // Incoming return from call to 0x0466 at 0x0BD1 // Inputs[2] // { // @0BDB stack[-1] // @0BDC stack[-2] // } 0BD2 5B JUMPDEST 0BD3 60 PUSH1 0x01 0BD5 60 PUSH1 0x01 0BD7 60 PUSH1 0xa0 0BD9 1B SHL 0BDA 03 SUB 0BDB 16 AND 0BDC 14 EQ // Stack delta = -1 // Outputs[1] { @0BDC stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_0BDD: // Incoming jump from 0x0BDC // Incoming jump from 0x0BC7, if stack[-1] // Inputs[2] // { // @0BDE stack[-2] // @0BDE stack[-1] // } 0BDD 5B JUMPDEST 0BDE 90 SWAP1 0BDF 50 POP 0BE0 80 DUP1 0BE1 61 PUSH2 0x0bfd 0BE4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0BDE stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0bfd, if stack[-1] label_0BE5: // Incoming jump from 0x0BE4, if not stack[-1] // Inputs[3] // { // @0BE7 memory[0x40:0x60] // @0BF7 memory[0x40:0x60] // @0BFC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BE5 60 PUSH1 0x40 0BE7 51 MLOAD 0BE8 63 PUSH4 0x2ce44b5f 0BED 60 PUSH1 0xe1 0BEF 1B SHL 0BF0 81 DUP2 0BF1 52 MSTORE 0BF2 60 PUSH1 0x04 0BF4 01 ADD 0BF5 60 PUSH1 0x40 0BF7 51 MLOAD 0BF8 80 DUP1 0BF9 91 SWAP2 0BFA 03 SUB 0BFB 90 SWAP1 0BFC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @0BFC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0BFD: // Incoming jump from 0x0BE4, if stack[-1] // Inputs[1] { @0C06 stack[-4] } 0BFD 5B JUMPDEST 0BFE 60 PUSH1 0x01 0C00 60 PUSH1 0x01 0C02 60 PUSH1 0xa0 0C04 1B SHL 0C05 03 SUB 0C06 84 DUP5 0C07 16 AND 0C08 61 PUSH2 0x0c24 0C0B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c24, if stack[-4] & (0x01 << 0xa0) - 0x01 label_0C0C: // Incoming jump from 0x0C0B, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0C0E memory[0x40:0x60] // @0C1E memory[0x40:0x60] // @0C23 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C0C 60 PUSH1 0x40 0C0E 51 MLOAD 0C0F 63 PUSH4 0x3a954ecd 0C14 60 PUSH1 0xe2 0C16 1B SHL 0C17 81 DUP2 0C18 52 MSTORE 0C19 60 PUSH1 0x04 0C1B 01 ADD 0C1C 60 PUSH1 0x40 0C1E 51 MLOAD 0C1F 80 DUP1 0C20 91 SWAP2 0C21 03 SUB 0C22 90 SWAP1 0C23 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @0C23 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C24: // Incoming jump from 0x0C0B, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0C2A stack[-3] // @0C2B stack[-5] // } 0C24 5B JUMPDEST 0C25 61 PUSH2 0x0c30 0C28 60 PUSH1 0x00 0C2A 84 DUP5 0C2B 87 DUP8 0C2C 61 PUSH2 0x0b06 0C2F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C25 stack[0] = 0x0c30 // @0C28 stack[1] = 0x00 // @0C2A stack[2] = stack[-3] // @0C2B stack[3] = stack[-5] // } // Block ends with call to 0x0b06, returns to 0x0C30 label_0C30: // Incoming return from call to 0x0B06 at 0x0C2F // Inputs[12] // { // @0C39 stack[-5] // @0C4C memory[0x00:0x40] // @0C4E storage[keccak256(memory[0x00:0x40])] // @0C72 stack[-4] // @0C7A memory[0x00:0x40] // @0C7C storage[keccak256(memory[0x00:0x40])] // @0C90 stack[-3] // @0C9A memory[0x00:0x40] // @0C9C storage[keccak256(memory[0x00:0x40])] // @0CAF block.timestamp // @0CC0 memory[0x00:0x40] // @0CC2 storage[keccak256(memory[0x00:0x40])] // } 0C30 5B JUMPDEST 0C31 60 PUSH1 0x01 0C33 60 PUSH1 0x01 0C35 60 PUSH1 0xa0 0C37 1B SHL 0C38 03 SUB 0C39 85 DUP6 0C3A 81 DUP2 0C3B 16 AND 0C3C 60 PUSH1 0x00 0C3E 90 SWAP1 0C3F 81 DUP2 0C40 52 MSTORE 0C41 60 PUSH1 0x05 0C43 60 PUSH1 0x20 0C45 90 SWAP1 0C46 81 DUP2 0C47 52 MSTORE 0C48 60 PUSH1 0x40 0C4A 80 DUP1 0C4B 83 DUP4 0C4C 20 SHA3 0C4D 80 DUP1 0C4E 54 SLOAD 0C4F 67 PUSH8 0xffffffffffffffff 0C58 19 NOT 0C59 80 DUP1 0C5A 82 DUP3 0C5B 16 AND 0C5C 67 PUSH8 0xffffffffffffffff 0C65 92 SWAP3 0C66 83 DUP4 0C67 16 AND 0C68 60 PUSH1 0x00 0C6A 19 NOT 0C6B 01 ADD 0C6C 83 DUP4 0C6D 16 AND 0C6E 17 OR 0C6F 90 SWAP1 0C70 92 SWAP3 0C71 55 SSTORE 0C72 89 DUP10 0C73 86 DUP7 0C74 16 AND 0C75 80 DUP1 0C76 86 DUP7 0C77 52 MSTORE 0C78 83 DUP4 0C79 86 DUP7 0C7A 20 SHA3 0C7B 80 DUP1 0C7C 54 SLOAD 0C7D 93 SWAP4 0C7E 84 DUP5 0C7F 16 AND 0C80 93 SWAP4 0C81 83 DUP4 0C82 16 AND 0C83 60 PUSH1 0x01 0C85 90 SWAP1 0C86 81 DUP2 0C87 01 ADD 0C88 84 DUP5 0C89 16 AND 0C8A 94 SWAP5 0C8B 90 SWAP1 0C8C 94 SWAP5 0C8D 17 OR 0C8E 90 SWAP1 0C8F 55 SSTORE 0C90 89 DUP10 0C91 86 DUP7 0C92 52 MSTORE 0C93 60 PUSH1 0x04 0C95 90 SWAP1 0C96 94 SWAP5 0C97 52 MSTORE 0C98 82 DUP3 0C99 85 DUP6 0C9A 20 SHA3 0C9B 80 DUP1 0C9C 54 SLOAD 0C9D 60 PUSH1 0x01 0C9F 60 PUSH1 0x01 0CA1 60 PUSH1 0xe0 0CA3 1B SHL 0CA4 03 SUB 0CA5 19 NOT 0CA6 16 AND 0CA7 90 SWAP1 0CA8 94 SWAP5 0CA9 17 OR 0CAA 60 PUSH1 0x01 0CAC 60 PUSH1 0xa0 0CAE 1B SHL 0CAF 42 TIMESTAMP 0CB0 90 SWAP1 0CB1 92 SWAP3 0CB2 16 AND 0CB3 91 SWAP2 0CB4 90 SWAP1 0CB5 91 SWAP2 0CB6 02 MUL 0CB7 17 OR 0CB8 83 DUP4 0CB9 55 SSTORE 0CBA 87 DUP8 0CBB 01 ADD 0CBC 80 DUP1 0CBD 84 DUP5 0CBE 52 MSTORE 0CBF 92 SWAP3 0CC0 20 SHA3 0CC1 80 DUP1 0CC2 54 SLOAD 0CC3 91 SWAP2 0CC4 93 SWAP4 0CC5 90 SWAP1 0CC6 91 SWAP2 0CC7 16 AND 0CC8 61 PUSH2 0x0d06 0CCB 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @0C40 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @0C47 memory[0x20:0x40] = 0x05 // @0C71 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & ~0x00 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @0C77 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @0C8F storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @0C92 memory[0x00:0x20] = stack[-3] // @0C97 memory[0x20:0x40] = 0x04 // @0CB9 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0CBE memory[0x00:0x20] = stack[-3] + 0x01 // @0CBF stack[1] = stack[-3] + 0x01 // @0CC4 stack[0] = keccak256(memory[0x00:0x40]) // @0CC6 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0d06, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_0CCC: // Incoming jump from 0x0CCB, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0CCE storage[0x00] // @0CCF stack[-2] // } 0CCC 60 PUSH1 0x00 0CCE 54 SLOAD 0CCF 82 DUP3 0CD0 14 EQ 0CD1 61 PUSH2 0x0d06 0CD4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d06, if stack[-2] == storage[0x00] label_0CD5: // Incoming jump from 0x0CD4, if not stack[-2] == storage[0x00] // Inputs[5] // { // @0CD5 stack[-1] // @0CD6 storage[stack[-1]] // @0CD9 stack[-5] // @0CDB memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @0D00 stack[-8] // } 0CD5 80 DUP1 0CD6 54 SLOAD 0CD7 60 PUSH1 0x20 0CD9 86 DUP7 0CDA 01 ADD 0CDB 51 MLOAD 0CDC 67 PUSH8 0xffffffffffffffff 0CE5 16 AND 0CE6 60 PUSH1 0x01 0CE8 60 PUSH1 0xa0 0CEA 1B SHL 0CEB 02 MUL 0CEC 60 PUSH1 0x01 0CEE 60 PUSH1 0x01 0CF0 60 PUSH1 0xe0 0CF2 1B SHL 0CF3 03 SUB 0CF4 19 NOT 0CF5 90 SWAP1 0CF6 91 SWAP2 0CF7 16 AND 0CF8 60 PUSH1 0x01 0CFA 60 PUSH1 0x01 0CFC 60 PUSH1 0xa0 0CFE 1B SHL 0CFF 03 SUB 0D00 8A DUP11 0D01 16 AND 0D02 17 OR 0D03 17 OR 0D04 81 DUP2 0D05 55 SSTORE // Stack delta = +0 // Outputs[1] { @0D05 storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_0D06: // Incoming jump from 0x0D05 // Incoming jump from 0x0CD4, if stack[-2] == storage[0x00] // Incoming jump from 0x0CCB, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[7] // { // @0D0A stack[-6] // @0D0B stack[-7] // @0D15 stack[-8] // @0D42 memory[0x40:0x60] // @0D45 memory[0x40:0x60] // @0D4A memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0D50 stack[-9] // } 0D06 5B JUMPDEST 0D07 50 POP 0D08 50 POP 0D09 50 POP 0D0A 82 DUP3 0D0B 84 DUP5 0D0C 60 PUSH1 0x01 0D0E 60 PUSH1 0x01 0D10 60 PUSH1 0xa0 0D12 1B SHL 0D13 03 SUB 0D14 16 AND 0D15 86 DUP7 0D16 60 PUSH1 0x01 0D18 60 PUSH1 0x01 0D1A 60 PUSH1 0xa0 0D1C 1B SHL 0D1D 03 SUB 0D1E 16 AND 0D1F 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0D40 60 PUSH1 0x40 0D42 51 MLOAD 0D43 60 PUSH1 0x40 0D45 51 MLOAD 0D46 80 DUP1 0D47 91 SWAP2 0D48 03 SUB 0D49 90 SWAP1 0D4A A4 LOG4 0D4B 50 POP 0D4C 50 POP 0D4D 50 POP 0D4E 50 POP 0D4F 50 POP 0D50 56 *JUMP // Stack delta = -9 // Outputs[1] { @0D4A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block ends with unconditional jump to stack[-9] label_0D51: // Incoming call from 0x0B6C, returns to 0x0B6D // Incoming call from 0x05C5, returns to 0x05C6 // Inputs[3] // { // @0D55 memory[0x40:0x60] // @0D6F stack[-1] // @0D72 storage[0x00] // } 0D51 5B JUMPDEST 0D52 60 PUSH1 0x40 0D54 80 DUP1 0D55 51 MLOAD 0D56 60 PUSH1 0x60 0D58 81 DUP2 0D59 01 ADD 0D5A 82 DUP3 0D5B 52 MSTORE 0D5C 60 PUSH1 0x00 0D5E 80 DUP1 0D5F 82 DUP3 0D60 52 MSTORE 0D61 60 PUSH1 0x20 0D63 82 DUP3 0D64 01 ADD 0D65 81 DUP2 0D66 90 SWAP1 0D67 52 MSTORE 0D68 91 SWAP2 0D69 81 DUP2 0D6A 01 ADD 0D6B 91 SWAP2 0D6C 90 SWAP1 0D6D 91 SWAP2 0D6E 52 MSTORE 0D6F 81 DUP2 0D70 60 PUSH1 0x00 0D72 54 SLOAD 0D73 81 DUP2 0D74 10 LT 0D75 15 ISZERO 0D76 61 PUSH2 0x0e54 0D79 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @0D5B memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0D60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0D67 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0D6D stack[0] = memory[0x40:0x60] // @0D6E memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @0D6F stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0e54, if !(stack[-1] < storage[0x00]) label_0D7A: // Incoming jump from 0x0D79, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @0D7C stack[-1] // @0D8B memory[0x00:0x40] // @0D8D memory[0x40:0x60] // @0D95 storage[keccak256(memory[0x00:0x40])] // } 0D7A 60 PUSH1 0x00 0D7C 81 DUP2 0D7D 81 DUP2 0D7E 52 MSTORE 0D7F 60 PUSH1 0x04 0D81 60 PUSH1 0x20 0D83 90 SWAP1 0D84 81 DUP2 0D85 52 MSTORE 0D86 60 PUSH1 0x40 0D88 91 SWAP2 0D89 82 DUP3 0D8A 90 SWAP1 0D8B 20 SHA3 0D8C 82 DUP3 0D8D 51 MLOAD 0D8E 60 PUSH1 0x60 0D90 81 DUP2 0D91 01 ADD 0D92 84 DUP5 0D93 52 MSTORE 0D94 90 SWAP1 0D95 54 SLOAD 0D96 60 PUSH1 0x01 0D98 60 PUSH1 0x01 0D9A 60 PUSH1 0xa0 0D9C 1B SHL 0D9D 03 SUB 0D9E 81 DUP2 0D9F 16 AND 0DA0 82 DUP3 0DA1 52 MSTORE 0DA2 60 PUSH1 0x01 0DA4 60 PUSH1 0xa0 0DA6 1B SHL 0DA7 81 DUP2 0DA8 04 DIV 0DA9 67 PUSH8 0xffffffffffffffff 0DB2 16 AND 0DB3 92 SWAP3 0DB4 82 DUP3 0DB5 01 ADD 0DB6 92 SWAP3 0DB7 90 SWAP1 0DB8 92 SWAP3 0DB9 52 MSTORE 0DBA 60 PUSH1 0x01 0DBC 60 PUSH1 0xe0 0DBE 1B SHL 0DBF 90 SWAP1 0DC0 91 SWAP2 0DC1 04 DIV 0DC2 60 PUSH1 0xff 0DC4 16 AND 0DC5 15 ISZERO 0DC6 15 ISZERO 0DC7 91 SWAP2 0DC8 81 DUP2 0DC9 01 ADD 0DCA 82 DUP3 0DCB 90 SWAP1 0DCC 52 MSTORE 0DCD 90 SWAP1 0DCE 61 PUSH2 0x0e52 0DD1 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @0D7E memory[0x00:0x20] = stack[-1] // @0D85 memory[0x20:0x40] = 0x04 // @0D93 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0DA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0DB9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0DCC memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @0DCD stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0e52, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_0DD2: // Incoming jump from 0x0DD1, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @0DD2 stack[-1] // @0DD3 memory[stack[-1]:stack[-1] + 0x20] // } 0DD2 80 DUP1 0DD3 51 MLOAD 0DD4 60 PUSH1 0x01 0DD6 60 PUSH1 0x01 0DD8 60 PUSH1 0xa0 0DDA 1B SHL 0DDB 03 SUB 0DDC 16 AND 0DDD 15 ISZERO 0DDE 61 PUSH2 0x0de8 0DE1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0de8, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_0DE2: // Incoming jump from 0x0DE1, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0DE2 stack[-5] // @0DE2 stack[-1] // @0DE3 stack[-4] // } 0DE2 93 SWAP4 0DE3 92 SWAP3 0DE4 50 POP 0DE5 50 POP 0DE6 50 POP 0DE7 56 *JUMP // Stack delta = -4 // Outputs[1] { @0DE2 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0DE8: // Incoming jump from 0x0DE1, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0E51 // Inputs[4] // { // @0DED stack[-2] // @0DFF memory[0x00:0x40] // @0E01 memory[0x40:0x60] // @0E09 storage[keccak256(memory[0x00:0x40])] // } 0DE8 5B JUMPDEST 0DE9 50 POP 0DEA 60 PUSH1 0x00 0DEC 19 NOT 0DED 01 ADD 0DEE 60 PUSH1 0x00 0DF0 81 DUP2 0DF1 81 DUP2 0DF2 52 MSTORE 0DF3 60 PUSH1 0x04 0DF5 60 PUSH1 0x20 0DF7 90 SWAP1 0DF8 81 DUP2 0DF9 52 MSTORE 0DFA 60 PUSH1 0x40 0DFC 91 SWAP2 0DFD 82 DUP3 0DFE 90 SWAP1 0DFF 20 SHA3 0E00 82 DUP3 0E01 51 MLOAD 0E02 60 PUSH1 0x60 0E04 81 DUP2 0E05 01 ADD 0E06 84 DUP5 0E07 52 MSTORE 0E08 90 SWAP1 0E09 54 SLOAD 0E0A 60 PUSH1 0x01 0E0C 60 PUSH1 0x01 0E0E 60 PUSH1 0xa0 0E10 1B SHL 0E11 03 SUB 0E12 81 DUP2 0E13 16 AND 0E14 80 DUP1 0E15 83 DUP4 0E16 52 MSTORE 0E17 60 PUSH1 0x01 0E19 60 PUSH1 0xa0 0E1B 1B SHL 0E1C 82 DUP3 0E1D 04 DIV 0E1E 67 PUSH8 0xffffffffffffffff 0E27 16 AND 0E28 93 SWAP4 0E29 83 DUP4 0E2A 01 ADD 0E2B 93 SWAP4 0E2C 90 SWAP1 0E2D 93 SWAP4 0E2E 52 MSTORE 0E2F 60 PUSH1 0x01 0E31 60 PUSH1 0xe0 0E33 1B SHL 0E34 90 SWAP1 0E35 04 DIV 0E36 60 PUSH1 0xff 0E38 16 AND 0E39 15 ISZERO 0E3A 15 ISZERO 0E3B 92 SWAP3 0E3C 81 DUP2 0E3D 01 ADD 0E3E 92 SWAP3 0E3F 90 SWAP1 0E40 92 SWAP3 0E41 52 MSTORE 0E42 15 ISZERO 0E43 61 PUSH2 0x0e4d 0E46 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @0DED stack[-2] = ~0x00 + stack[-2] // @0DF2 memory[0x00:0x20] = ~0x00 + stack[-2] // @0DF9 memory[0x20:0x40] = 0x04 // @0E07 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0E16 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0E2E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0E40 stack[-1] = memory[0x40:0x60] // @0E41 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x0e4d, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_0E47: // Incoming jump from 0x0E46, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @0E47 stack[-5] // @0E47 stack[-1] // @0E48 stack[-4] // } 0E47 93 SWAP4 0E48 92 SWAP3 0E49 50 POP 0E4A 50 POP 0E4B 50 POP 0E4C 56 *JUMP // Stack delta = -4 // Outputs[1] { @0E47 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0E4D: // Incoming jump from 0x0E46, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 0E4D 5B JUMPDEST 0E4E 61 PUSH2 0x0de8 0E51 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0de8 label_0E52: // Incoming jump from 0x0DD1, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 0E52 5B JUMPDEST 0E53 50 POP // Stack delta = -1 // Block continues label_0E54: // Incoming jump from 0x0E53 // Incoming jump from 0x0D79, if !(stack[-1] < storage[0x00]) // Inputs[3] // { // @0E57 memory[0x40:0x60] // @0E67 memory[0x40:0x60] // @0E6C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E54 5B JUMPDEST 0E55 60 PUSH1 0x40 0E57 51 MLOAD 0E58 63 PUSH4 0x6f96cda1 0E5D 60 PUSH1 0xe1 0E5F 1B SHL 0E60 81 DUP2 0E61 52 MSTORE 0E62 60 PUSH1 0x04 0E64 01 ADD 0E65 60 PUSH1 0x40 0E67 51 MLOAD 0E68 80 DUP1 0E69 91 SWAP2 0E6A 03 SUB 0E6B 90 SWAP1 0E6C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @0E6C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E6D: // Incoming call from 0x0AD7, returns to 0x0AD8 // Incoming call from 0x064F, returns to 0x0650 // Inputs[5] // { // @0E71 storage[0x08] // @0E7A stack[-1] // @0E8F memory[0x40:0x60] // @0EBB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0EBE stack[-2] // } 0E6D 5B JUMPDEST 0E6E 60 PUSH1 0x08 0E70 80 DUP1 0E71 54 SLOAD 0E72 60 PUSH1 0x01 0E74 60 PUSH1 0x01 0E76 60 PUSH1 0xa0 0E78 1B SHL 0E79 03 SUB 0E7A 83 DUP4 0E7B 81 DUP2 0E7C 16 AND 0E7D 60 PUSH1 0x01 0E7F 60 PUSH1 0x01 0E81 60 PUSH1 0xa0 0E83 1B SHL 0E84 03 SUB 0E85 19 NOT 0E86 83 DUP4 0E87 16 AND 0E88 81 DUP2 0E89 17 OR 0E8A 90 SWAP1 0E8B 93 SWAP4 0E8C 55 SSTORE 0E8D 60 PUSH1 0x40 0E8F 51 MLOAD 0E90 91 SWAP2 0E91 16 AND 0E92 91 SWAP2 0E93 90 SWAP1 0E94 82 DUP3 0E95 90 SWAP1 0E96 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0EB7 90 SWAP1 0EB8 60 PUSH1 0x00 0EBA 90 SWAP1 0EBB A3 LOG3 0EBC 50 POP 0EBD 50 POP 0EBE 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0E8C storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @0EBB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_0EBF: // Incoming jump from 0x07EE // Inputs[3] // { // @0EC3 stack[-2] // @0EC4 stack[-1] // @0EC7 memory[0x40:0x60] // } 0EBF 5B JUMPDEST 0EC0 61 PUSH2 0x0801 0EC3 82 DUP3 0EC4 82 DUP3 0EC5 60 PUSH1 0x40 0EC7 51 MLOAD 0EC8 80 DUP1 0EC9 60 PUSH1 0x20 0ECB 01 ADD 0ECC 60 PUSH1 0x40 0ECE 52 MSTORE 0ECF 80 DUP1 0ED0 60 PUSH1 0x00 0ED2 81 DUP2 0ED3 52 MSTORE 0ED4 50 POP 0ED5 61 PUSH2 0x10d5 0ED8 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0EC0 stack[0] = 0x0801 // @0EC3 stack[1] = stack[-2] // @0EC4 stack[2] = stack[-1] // @0EC7 stack[3] = memory[0x40:0x60] // @0ECE memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0ED3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x10d5 label_0ED9: // Incoming jump from 0x0910 // Incoming jump from 0x1210 // Inputs[6] // { // @0EDC memory[0x40:0x60] // @0EF2 stack[-3] // @0EFF msg.sender // @0F01 stack[-4] // @0F03 stack[-2] // @0F05 stack[-1] // } 0ED9 5B JUMPDEST 0EDA 60 PUSH1 0x40 0EDC 51 MLOAD 0EDD 63 PUSH4 0x0a85bd01 0EE2 60 PUSH1 0xe1 0EE4 1B SHL 0EE5 81 DUP2 0EE6 52 MSTORE 0EE7 60 PUSH1 0x00 0EE9 90 SWAP1 0EEA 60 PUSH1 0x01 0EEC 60 PUSH1 0x01 0EEE 60 PUSH1 0xa0 0EF0 1B SHL 0EF1 03 SUB 0EF2 85 DUP6 0EF3 16 AND 0EF4 90 SWAP1 0EF5 63 PUSH4 0x150b7a02 0EFA 90 SWAP1 0EFB 61 PUSH2 0x0f0e 0EFE 90 SWAP1 0EFF 33 CALLER 0F00 90 SWAP1 0F01 89 DUP10 0F02 90 SWAP1 0F03 88 DUP9 0F04 90 SWAP1 0F05 88 DUP9 0F06 90 SWAP1 0F07 60 PUSH1 0x04 0F09 01 ADD 0F0A 61 PUSH2 0x1805 0F0D 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @0EE6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @0EE9 stack[0] = 0x00 // @0EF4 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0EFA stack[2] = 0x150b7a02 // @0EFE stack[3] = 0x0f0e // @0F00 stack[4] = msg.sender // @0F02 stack[5] = stack[-4] // @0F04 stack[6] = stack[-2] // @0F06 stack[7] = stack[-1] // @0F09 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1805, returns to 0x0F0E label_0F0E: // Incoming return from call to 0x1805 at 0x0F0D // Inputs[6] // { // @0F13 memory[0x40:0x60] // @0F15 stack[-1] // @0F1A stack[-3] // @0F1B msg.gas // @0F1C address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0F1C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0F0E 5B JUMPDEST 0F0F 60 PUSH1 0x20 0F11 60 PUSH1 0x40 0F13 51 MLOAD 0F14 80 DUP1 0F15 83 DUP4 0F16 03 SUB 0F17 81 DUP2 0F18 60 PUSH1 0x00 0F1A 87 DUP8 0F1B 5A GAS 0F1C F1 CALL 0F1D 92 SWAP3 0F1E 50 POP 0F1F 50 POP 0F20 50 POP 0F21 80 DUP1 0F22 15 ISZERO 0F23 61 PUSH2 0x0f49 0F26 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0F1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0F1D stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0f49, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_0F27: // Incoming jump from 0x0F26, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @0F2B memory[0x40:0x60] // @0F2E returndata.length // } 0F27 50 POP 0F28 60 PUSH1 0x40 0F2A 80 DUP1 0F2B 51 MLOAD 0F2C 60 PUSH1 0x1f 0F2E 3D RETURNDATASIZE 0F2F 90 SWAP1 0F30 81 DUP2 0F31 01 ADD 0F32 60 PUSH1 0x1f 0F34 19 NOT 0F35 16 AND 0F36 82 DUP3 0F37 01 ADD 0F38 90 SWAP1 0F39 92 SWAP3 0F3A 52 MSTORE 0F3B 61 PUSH2 0x0f46 0F3E 91 SWAP2 0F3F 81 DUP2 0F40 01 ADD 0F41 90 SWAP1 0F42 61 PUSH2 0x1842 0F45 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0F3A memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @0F3E stack[-1] = 0x0f46 // @0F41 stack[1] = memory[0x40:0x60] // @0F41 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1842 0F46 5B JUMPDEST 0F47 60 PUSH1 0x01 label_0F49: // Incoming jump from 0x0F26, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @0F4D stack[-1] } 0F49 5B JUMPDEST 0F4A 61 PUSH2 0x0fa7 0F4D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fa7, if stack[-1] label_0F4E: // Incoming jump from 0x0F4D, if not stack[-1] // Inputs[1] { @0F4E returndata.length } 0F4E 3D RETURNDATASIZE 0F4F 80 DUP1 0F50 80 DUP1 0F51 15 ISZERO 0F52 61 PUSH2 0x0f77 0F55 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0F4E stack[0] = returndata.length // @0F4F stack[1] = returndata.length // } // Block ends with conditional jump to 0x0f77, if !returndata.length label_0F56: // Incoming jump from 0x0F55, if not !returndata.length // Inputs[6] // { // @0F58 memory[0x40:0x60] // @0F59 stack[-2] // @0F60 returndata.length // @0F68 returndata.length // @0F6B returndata.length // @0F72 returndata[0x00:0x00 + returndata.length] // } 0F56 60 PUSH1 0x40 0F58 51 MLOAD 0F59 91 SWAP2 0F5A 50 POP 0F5B 60 PUSH1 0x1f 0F5D 19 NOT 0F5E 60 PUSH1 0x3f 0F60 3D RETURNDATASIZE 0F61 01 ADD 0F62 16 AND 0F63 82 DUP3 0F64 01 ADD 0F65 60 PUSH1 0x40 0F67 52 MSTORE 0F68 3D RETURNDATASIZE 0F69 82 DUP3 0F6A 52 MSTORE 0F6B 3D RETURNDATASIZE 0F6C 60 PUSH1 0x00 0F6E 60 PUSH1 0x20 0F70 84 DUP5 0F71 01 ADD 0F72 3E RETURNDATACOPY 0F73 61 PUSH2 0x0f7c 0F76 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0F59 stack[-2] = memory[0x40:0x60] // @0F67 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0F6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0F72 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0f7c label_0F77: // Incoming jump from 0x0F55, if !returndata.length // Inputs[2] // { // @0F7A stack[-2] // @0F7F memory[0x60:0x80] // } 0F77 5B JUMPDEST 0F78 60 PUSH1 0x60 0F7A 91 SWAP2 0F7B 50 POP 0F7C 5B JUMPDEST 0F7D 50 POP 0F7E 80 DUP1 0F7F 51 MLOAD 0F80 60 PUSH1 0x00 0F82 03 SUB 0F83 61 PUSH2 0x0f9f 0F86 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0F7A stack[-2] = 0x60 } // Block ends with conditional jump to 0x0f9f, if 0x00 - memory[0x60:0x80] label_0F87: // Incoming jump from 0x0F86, if not 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0F86, if not 0x00 - memory[0x60:0x80] // Inputs[3] // { // @0F89 memory[0x40:0x60] // @0F99 memory[0x40:0x60] // @0F9E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F87 60 PUSH1 0x40 0F89 51 MLOAD 0F8A 63 PUSH4 0x68d2bf6b 0F8F 60 PUSH1 0xe1 0F91 1B SHL 0F92 81 DUP2 0F93 52 MSTORE 0F94 60 PUSH1 0x04 0F96 01 ADD 0F97 60 PUSH1 0x40 0F99 51 MLOAD 0F9A 80 DUP1 0F9B 91 SWAP2 0F9C 03 SUB 0F9D 90 SWAP1 0F9E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @0F9E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F9F: // Incoming jump from 0x0F86, if 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0F86, if 0x00 - memory[0x60:0x80] // Inputs[3] // { // @0FA0 stack[-1] // @0FA1 memory[stack[-1]:stack[-1] + 0x20] // @0FA6 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 0F9F 5B JUMPDEST 0FA0 80 DUP1 0FA1 51 MLOAD 0FA2 81 DUP2 0FA3 60 PUSH1 0x20 0FA5 01 ADD 0FA6 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FA6 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_0FA7: // Incoming jump from 0x0F4D, if stack[-1] // Inputs[2] // { // @0FB1 stack[-1] // @0FBB stack[-2] // } 0FA7 5B JUMPDEST 0FA8 60 PUSH1 0x01 0FAA 60 PUSH1 0x01 0FAC 60 PUSH1 0xe0 0FAE 1B SHL 0FAF 03 SUB 0FB0 19 NOT 0FB1 16 AND 0FB2 63 PUSH4 0x0a85bd01 0FB7 60 PUSH1 0xe1 0FB9 1B SHL 0FBA 14 EQ 0FBB 90 SWAP1 0FBC 50 POP // Stack delta = -1 // Outputs[1] { @0FBB stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_0FBD: // Incoming return from call to 0x15BA at 0x165A // Incoming jump from 0x0FBC // Inputs[3] // { // @0FBE stack[-6] // @0FBE stack[-1] // @0FBF stack[-5] // } 0FBD 5B JUMPDEST 0FBE 94 SWAP5 0FBF 93 SWAP4 0FC0 50 POP 0FC1 50 POP 0FC2 50 POP 0FC3 50 POP 0FC4 56 *JUMP // Stack delta = -5 // Outputs[1] { @0FBE stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0FC5: // Incoming jump from 0x09ED // Inputs[1] { @0FCB storage[0x0a] } 0FC5 5B JUMPDEST 0FC6 60 PUSH1 0x60 0FC8 60 PUSH1 0x0a 0FCA 80 DUP1 0FCB 54 SLOAD 0FCC 61 PUSH2 0x03e3 0FCF 90 SWAP1 0FD0 61 PUSH2 0x170a 0FD3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FC6 stack[0] = 0x60 // @0FC8 stack[1] = 0x0a // @0FCF stack[2] = 0x03e3 // @0FCF stack[3] = storage[0x0a] // } // Block ends with call to 0x170a, returns to 0x03E3 0FD4 5B JUMPDEST 0FD5 60 PUSH1 0x60 0FD7 81 DUP2 0FD8 60 PUSH1 0x00 0FDA 03 SUB 0FDB 61 PUSH2 0x0ffb 0FDE 57 *JUMPI 0FDF 50 POP 0FE0 50 POP 0FE1 60 PUSH1 0x40 0FE3 80 DUP1 0FE4 51 MLOAD 0FE5 80 DUP1 0FE6 82 DUP3 0FE7 01 ADD 0FE8 90 SWAP1 0FE9 91 SWAP2 0FEA 52 MSTORE 0FEB 60 PUSH1 0x01 0FED 81 DUP2 0FEE 52 MSTORE 0FEF 60 PUSH1 0x03 0FF1 60 PUSH1 0xfc 0FF3 1B SHL 0FF4 60 PUSH1 0x20 0FF6 82 DUP3 0FF7 01 ADD 0FF8 52 MSTORE 0FF9 90 SWAP1 0FFA 56 *JUMP 0FFB 5B JUMPDEST 0FFC 81 DUP2 0FFD 60 PUSH1 0x00 0FFF 5B JUMPDEST 1000 81 DUP2 1001 15 ISZERO 1002 61 PUSH2 0x1025 1005 57 *JUMPI 1006 80 DUP1 1007 61 PUSH2 0x100f 100A 81 DUP2 100B 61 PUSH2 0x17bd 100E 56 *JUMP 100F 5B JUMPDEST 1010 91 SWAP2 1011 50 POP 1012 61 PUSH2 0x101e 1015 90 SWAP1 1016 50 POP 1017 60 PUSH1 0x0a 1019 83 DUP4 101A 61 PUSH2 0x1875 101D 56 *JUMP 101E 5B JUMPDEST 101F 91 SWAP2 1020 50 POP 1021 61 PUSH2 0x0fff 1024 56 *JUMP 1025 5B JUMPDEST 1026 60 PUSH1 0x00 1028 81 DUP2 1029 67 PUSH8 0xffffffffffffffff 1032 81 DUP2 1033 11 GT 1034 15 ISZERO 1035 61 PUSH2 0x1040 1038 57 *JUMPI 1039 61 PUSH2 0x1040 103C 61 PUSH2 0x14c6 103F 56 *JUMP 1040 5B JUMPDEST 1041 60 PUSH1 0x40 1043 51 MLOAD 1044 90 SWAP1 1045 80 DUP1 1046 82 DUP3 1047 52 MSTORE 1048 80 DUP1 1049 60 PUSH1 0x1f 104B 01 ADD 104C 60 PUSH1 0x1f 104E 19 NOT 104F 16 AND 1050 60 PUSH1 0x20 1052 01 ADD 1053 82 DUP3 1054 01 ADD 1055 60 PUSH1 0x40 1057 52 MSTORE 1058 80 DUP1 1059 15 ISZERO 105A 61 PUSH2 0x106a 105D 57 *JUMPI 105E 60 PUSH1 0x20 1060 82 DUP3 1061 01 ADD 1062 81 DUP2 1063 80 DUP1 1064 36 CALLDATASIZE 1065 83 DUP4 1066 37 CALLDATACOPY 1067 01 ADD 1068 90 SWAP1 1069 50 POP 106A 5B JUMPDEST 106B 50 POP 106C 90 SWAP1 106D 50 POP 106E 5B JUMPDEST 106F 84 DUP5 1070 15 ISZERO 1071 61 PUSH2 0x0fbd 1074 57 *JUMPI 1075 61 PUSH2 0x107f 1078 60 PUSH1 0x01 107A 83 DUP4 107B 61 PUSH2 0x1889 107E 56 *JUMP 107F 5B JUMPDEST 1080 91 SWAP2 1081 50 POP 1082 61 PUSH2 0x108c 1085 60 PUSH1 0x0a 1087 86 DUP7 1088 61 PUSH2 0x18a0 108B 56 *JUMP 108C 5B JUMPDEST 108D 61 PUSH2 0x1097 1090 90 SWAP1 1091 60 PUSH1 0x30 1093 61 PUSH2 0x178f 1096 56 *JUMP 1097 5B JUMPDEST 1098 60 PUSH1 0xf8 109A 1B SHL 109B 81 DUP2 109C 83 DUP4 109D 81 DUP2 109E 51 MLOAD 109F 81 DUP2 10A0 10 LT 10A1 61 PUSH2 0x10ac 10A4 57 *JUMPI 10A5 61 PUSH2 0x10ac 10A8 61 PUSH2 0x17a7 10AB 56 *JUMP 10AC 5B JUMPDEST 10AD 60 PUSH1 0x20 10AF 01 ADD 10B0 01 ADD 10B1 90 SWAP1 10B2 60 PUSH1 0x01 10B4 60 PUSH1 0x01 10B6 60 PUSH1 0xf8 10B8 1B SHL 10B9 03 SUB 10BA 19 NOT 10BB 16 AND 10BC 90 SWAP1 10BD 81 DUP2 10BE 60 PUSH1 0x00 10C0 1A BYTE 10C1 90 SWAP1 10C2 53 MSTORE8 10C3 50 POP 10C4 61 PUSH2 0x10ce 10C7 60 PUSH1 0x0a 10C9 86 DUP7 10CA 61 PUSH2 0x1875 10CD 56 *JUMP 10CE 5B JUMPDEST 10CF 94 SWAP5 10D0 50 POP 10D1 61 PUSH2 0x106e 10D4 56 *JUMP label_10D5: // Incoming jump from 0x0ED8 // Inputs[2] // { // @10D8 storage[0x00] // @10E1 stack[-3] // } 10D5 5B JUMPDEST 10D6 60 PUSH1 0x00 10D8 54 SLOAD 10D9 60 PUSH1 0x01 10DB 60 PUSH1 0x01 10DD 60 PUSH1 0xa0 10DF 1B SHL 10E0 03 SUB 10E1 84 DUP5 10E2 16 AND 10E3 61 PUSH2 0x10fe 10E6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10D8 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x10fe, if stack[-3] & (0x01 << 0xa0) - 0x01 label_10E7: // Incoming jump from 0x10E6, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @10E9 memory[0x40:0x60] // @10F8 memory[0x40:0x60] // @10FD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 10E7 60 PUSH1 0x40 10E9 51 MLOAD 10EA 62 PUSH3 0x2e0763 10EE 60 PUSH1 0xe8 10F0 1B SHL 10F1 81 DUP2 10F2 52 MSTORE 10F3 60 PUSH1 0x04 10F5 01 ADD 10F6 60 PUSH1 0x40 10F8 51 MLOAD 10F9 80 DUP1 10FA 91 SWAP2 10FB 03 SUB 10FC 90 SWAP1 10FD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @10FD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_10FE: // Incoming jump from 0x10E6, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @10FF stack[-3] } 10FE 5B JUMPDEST 10FF 82 DUP3 1100 60 PUSH1 0x00 1102 03 SUB 1103 61 PUSH2 0x111f 1106 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x111f, if 0x00 - stack[-3] label_1107: // Incoming jump from 0x1106, if not 0x00 - stack[-3] // Inputs[3] // { // @1109 memory[0x40:0x60] // @1119 memory[0x40:0x60] // @111E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1107 60 PUSH1 0x40 1109 51 MLOAD 110A 63 PUSH4 0xb562e8dd 110F 60 PUSH1 0xe0 1111 1B SHL 1112 81 DUP2 1113 52 MSTORE 1114 60 PUSH1 0x04 1116 01 ADD 1117 60 PUSH1 0x40 1119 51 MLOAD 111A 80 DUP1 111B 91 SWAP2 111C 03 SUB 111D 90 SWAP1 111E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1113 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @111E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_111F: // Incoming jump from 0x1106, if 0x00 - stack[-3] // Inputs[9] // { // @1128 stack[-4] // @113A memory[0x00:0x40] // @113C storage[keccak256(memory[0x00:0x40])] // @115D stack[-3] // @118E stack[-1] // @1198 memory[0x00:0x40] // @119A storage[keccak256(memory[0x00:0x40])] // @11AC block.timestamp // @11C0 address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 111F 5B JUMPDEST 1120 60 PUSH1 0x01 1122 60 PUSH1 0x01 1124 60 PUSH1 0xa0 1126 1B SHL 1127 03 SUB 1128 84 DUP5 1129 16 AND 112A 60 PUSH1 0x00 112C 81 DUP2 112D 81 DUP2 112E 52 MSTORE 112F 60 PUSH1 0x05 1131 60 PUSH1 0x20 1133 90 SWAP1 1134 81 DUP2 1135 52 MSTORE 1136 60 PUSH1 0x40 1138 80 DUP1 1139 83 DUP4 113A 20 SHA3 113B 80 DUP1 113C 54 SLOAD 113D 6F PUSH16 0xffffffffffffffffffffffffffffffff 114E 19 NOT 114F 81 DUP2 1150 16 AND 1151 67 PUSH8 0xffffffffffffffff 115A 80 DUP1 115B 83 DUP4 115C 16 AND 115D 8B DUP12 115E 01 ADD 115F 81 DUP2 1160 16 AND 1161 91 SWAP2 1162 82 DUP3 1163 17 OR 1164 68 PUSH9 0x010000000000000000 116E 67 PUSH8 0xffffffffffffffff 1177 19 NOT 1178 90 SWAP1 1179 94 SWAP5 117A 16 AND 117B 90 SWAP1 117C 92 SWAP3 117D 17 OR 117E 83 DUP4 117F 90 SWAP1 1180 04 DIV 1181 81 DUP2 1182 16 AND 1183 8B DUP12 1184 01 ADD 1185 81 DUP2 1186 16 AND 1187 90 SWAP1 1188 92 SWAP3 1189 02 MUL 118A 17 OR 118B 90 SWAP1 118C 91 SWAP2 118D 55 SSTORE 118E 85 DUP6 118F 84 DUP5 1190 52 MSTORE 1191 60 PUSH1 0x04 1193 90 SWAP1 1194 92 SWAP3 1195 52 MSTORE 1196 90 SWAP1 1197 91 SWAP2 1198 20 SHA3 1199 80 DUP1 119A 54 SLOAD 119B 60 PUSH1 0x01 119D 60 PUSH1 0x01 119F 60 PUSH1 0xe0 11A1 1B SHL 11A2 03 SUB 11A3 19 NOT 11A4 16 AND 11A5 83 DUP4 11A6 17 OR 11A7 60 PUSH1 0x01 11A9 60 PUSH1 0xa0 11AB 1B SHL 11AC 42 TIMESTAMP 11AD 90 SWAP1 11AE 93 SWAP4 11AF 16 AND 11B0 92 SWAP3 11B1 90 SWAP1 11B2 92 SWAP3 11B3 02 MUL 11B4 91 SWAP2 11B5 90 SWAP1 11B6 91 SWAP2 11B7 17 OR 11B8 90 SWAP1 11B9 55 SSTORE 11BA 81 DUP2 11BB 90 SWAP1 11BC 81 DUP2 11BD 85 DUP6 11BE 01 ADD 11BF 90 SWAP1 11C0 3B EXTCODESIZE 11C1 15 ISZERO 11C2 61 PUSH2 0x1248 11C5 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @112E memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1135 memory[0x20:0x40] = 0x05 // @118D storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * (0xffffffffffffffff & stack[-3] + (0xffffffffffffffff & ((0xffffffffffffffff & stack[-3] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | (0xffffffffffffffff & stack[-3] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @1190 memory[0x00:0x20] = stack[-1] // @1195 memory[0x20:0x40] = 0x04 // @11B9 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-4] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @11BB stack[0] = stack[-1] // @11BF stack[1] = stack[-3] + stack[-1] // } // Block ends with conditional jump to 0x1248, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_11C6: // Incoming jump from 0x11C5, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @11C9 memory[0x40:0x60] // @11CA stack[-2] // @11D4 stack[-6] // @11FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @120C stack[-4] // } 11C6 5B JUMPDEST 11C7 60 PUSH1 0x40 11C9 51 MLOAD 11CA 82 DUP3 11CB 90 SWAP1 11CC 60 PUSH1 0x01 11CE 60 PUSH1 0x01 11D0 60 PUSH1 0xa0 11D2 1B SHL 11D3 03 SUB 11D4 88 DUP9 11D5 16 AND 11D6 90 SWAP1 11D7 60 PUSH1 0x00 11D9 90 SWAP1 11DA 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 11FB 90 SWAP1 11FC 82 DUP3 11FD 90 SWAP1 11FE A4 LOG4 11FF 61 PUSH2 0x1211 1202 60 PUSH1 0x00 1204 87 DUP8 1205 84 DUP5 1206 80 DUP1 1207 60 PUSH1 0x01 1209 01 ADD 120A 95 SWAP6 120B 50 POP 120C 87 DUP8 120D 61 PUSH2 0x0ed9 1210 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @11FE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @11FF stack[0] = 0x1211 // @1202 stack[1] = 0x00 // @1204 stack[2] = stack[-6] // @1205 stack[3] = stack[-2] // @120A stack[-2] = 0x01 + stack[-2] // @120C stack[4] = stack[-4] // } // Block ends with unconditional jump to 0x0ed9 1211 5B JUMPDEST 1212 61 PUSH2 0x122e 1215 57 *JUMPI 1216 60 PUSH1 0x40 1218 51 MLOAD 1219 63 PUSH4 0x68d2bf6b 121E 60 PUSH1 0xe1 1220 1B SHL 1221 81 DUP2 1222 52 MSTORE 1223 60 PUSH1 0x04 1225 01 ADD 1226 60 PUSH1 0x40 1228 51 MLOAD 1229 80 DUP1 122A 91 SWAP2 122B 03 SUB 122C 90 SWAP1 122D FD *REVERT 122E 5B JUMPDEST 122F 80 DUP1 1230 82 DUP3 1231 03 SUB 1232 61 PUSH2 0x11c6 1235 57 *JUMPI 1236 82 DUP3 1237 60 PUSH1 0x00 1239 54 SLOAD 123A 14 EQ 123B 61 PUSH2 0x1243 123E 57 *JUMPI 123F 60 PUSH1 0x00 1241 80 DUP1 1242 FD *REVERT 1243 5B JUMPDEST 1244 61 PUSH2 0x128d 1247 56 *JUMP label_1248: // Incoming jump from 0x11C5, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @124C memory[0x40:0x60] // @124F stack[-2] // @125B stack[-6] // @1285 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1286 stack[-1] // } 1248 5B JUMPDEST 1249 5B JUMPDEST 124A 60 PUSH1 0x40 124C 51 MLOAD 124D 60 PUSH1 0x01 124F 83 DUP4 1250 01 ADD 1251 92 SWAP3 1252 90 SWAP1 1253 60 PUSH1 0x01 1255 60 PUSH1 0x01 1257 60 PUSH1 0xa0 1259 1B SHL 125A 03 SUB 125B 88 DUP9 125C 16 AND 125D 90 SWAP1 125E 60 PUSH1 0x00 1260 90 SWAP1 1261 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1282 90 SWAP1 1283 82 DUP3 1284 90 SWAP1 1285 A4 LOG4 1286 80 DUP1 1287 82 DUP3 1288 03 SUB 1289 61 PUSH2 0x1249 128C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1251 stack[-2] = stack[-2] + 0x01 // @1285 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1249, if (stack[-2] + 0x01) - stack[-1] label_128D: // Incoming jump from 0x128C, if not (stack[-2] + 0x01) - stack[-1] // Incoming jump from 0x128C, if not (stack[-2] + 0x01) - stack[-1] // Inputs[4] // { // @1291 stack[-2] // @1298 stack[-6] // @1299 stack[-3] // @129A stack[-5] // } 128D 5B JUMPDEST 128E 50 POP 128F 60 PUSH1 0x00 1291 90 SWAP1 1292 81 DUP2 1293 55 SSTORE 1294 61 PUSH2 0x0931 1297 90 SWAP1 1298 85 DUP6 1299 83 DUP4 129A 86 DUP7 129B 84 DUP5 129C 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @1293 storage[0x00] = stack[-2] // @1297 stack[-2] = 0x0931 // @1297 stack[-1] = 0x00 // @1298 stack[0] = stack[-6] // @1299 stack[1] = stack[-3] // @129A stack[2] = stack[-5] // } // Block ends with call to 0x0931, returns to 0x0931 label_129D: // Incoming jump from 0x0841 // Inputs[2] // { // @129E stack[-3] // @12A0 storage[stack[-3]] // } 129D 5B JUMPDEST 129E 82 DUP3 129F 80 DUP1 12A0 54 SLOAD 12A1 61 PUSH2 0x12a9 12A4 90 SWAP1 12A5 61 PUSH2 0x170a 12A8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @129E stack[0] = stack[-3] // @12A4 stack[1] = 0x12a9 // @12A4 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x170a, returns to 0x12A9 label_12A9: // Incoming return from call to 0x170A at 0x12A8 // Inputs[5] // { // @12AA stack[-1] // @12AA stack[-2] // @12B2 memory[0x00:0x20] // @12BD stack[-4] // @12BE stack[-3] // } 12A9 5B JUMPDEST 12AA 90 SWAP1 12AB 60 PUSH1 0x00 12AD 52 MSTORE 12AE 60 PUSH1 0x20 12B0 60 PUSH1 0x00 12B2 20 SHA3 12B3 90 SWAP1 12B4 60 PUSH1 0x1f 12B6 01 ADD 12B7 60 PUSH1 0x20 12B9 90 SWAP1 12BA 04 DIV 12BB 81 DUP2 12BC 01 ADD 12BD 92 SWAP3 12BE 82 DUP3 12BF 61 PUSH2 0x12cb 12C2 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @12AD memory[0x00:0x20] = stack[-2] // @12B3 stack[-2] = keccak256(memory[0x00:0x20]) // @12BD stack[-1] = stack[-4] // @12BD stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x12cb, if stack[-3] label_12C3: // Incoming jump from 0x12C2, if not stack[-3] // Inputs[1] { @12C5 stack[-5] } 12C3 60 PUSH1 0x00 12C5 85 DUP6 12C6 55 SSTORE 12C7 61 PUSH2 0x1311 12CA 56 *JUMP // Stack delta = +0 // Outputs[1] { @12C6 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1311 label_12CB: // Incoming jump from 0x12C2, if stack[-3] // Inputs[1] { @12CC stack[-3] } 12CB 5B JUMPDEST 12CC 82 DUP3 12CD 60 PUSH1 0x1f 12CF 10 LT 12D0 61 PUSH2 0x12e4 12D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12e4, if 0x1f < stack[-3] label_12D4: // Incoming jump from 0x12D3, if not 0x1f < stack[-3] // Inputs[4] // { // @12D4 stack[-1] // @12D5 memory[stack[-1]:stack[-1] + 0x20] // @12DA stack[-3] // @12DE stack[-5] // } 12D4 80 DUP1 12D5 51 MLOAD 12D6 60 PUSH1 0xff 12D8 19 NOT 12D9 16 AND 12DA 83 DUP4 12DB 80 DUP1 12DC 01 ADD 12DD 17 OR 12DE 85 DUP6 12DF 55 SSTORE 12E0 61 PUSH2 0x1311 12E3 56 *JUMP // Stack delta = +0 // Outputs[1] { @12DF storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1311 label_12E4: // Incoming jump from 0x12D3, if 0x1f < stack[-3] // Inputs[2] // { // @12E5 stack[-3] // @12EB stack[-5] // } 12E4 5B JUMPDEST 12E5 82 DUP3 12E6 80 DUP1 12E7 01 ADD 12E8 60 PUSH1 0x01 12EA 01 ADD 12EB 85 DUP6 12EC 55 SSTORE 12ED 82 DUP3 12EE 15 ISZERO 12EF 61 PUSH2 0x1311 12F2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @12EC storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1311, if !stack[-3] label_12F3: // Incoming jump from 0x12F2, if not !stack[-3] // Inputs[2] // { // @12F3 stack[-3] // @12F3 stack[-1] // } 12F3 91 SWAP2 12F4 82 DUP3 12F5 01 ADD 12F6 5B JUMPDEST 12F7 82 DUP3 12F8 81 DUP2 12F9 11 GT 12FA 15 ISZERO 12FB 61 PUSH2 0x1311 12FE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @12F3 stack[-3] = stack[-1] // @12F5 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1311, if !(stack[-1] + stack[-3] > stack[-1]) label_12FF: // Incoming jump from 0x12FE, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x12FE, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @12FF stack[-3] // @1300 memory[stack[-3]:stack[-3] + 0x20] // @1301 stack[-2] // @1303 stack[-1] // } 12FF 82 DUP3 1300 51 MLOAD 1301 82 DUP3 1302 55 SSTORE 1303 91 SWAP2 1304 60 PUSH1 0x20 1306 01 ADD 1307 91 SWAP2 1308 90 SWAP1 1309 60 PUSH1 0x01 130B 01 ADD 130C 90 SWAP1 130D 61 PUSH2 0x12f6 1310 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1302 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1307 stack[-3] = 0x20 + stack[-3] // @130C stack[-2] = 0x01 + stack[-2] // @130C stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x12f6 label_1311: // Incoming jump from 0x12F2, if !stack[-3] // Incoming jump from 0x12FE, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x12FE, if !(stack[-1] > stack[-3]) // Incoming jump from 0x12E3 // Incoming jump from 0x12CA // Inputs[2] // { // @1316 stack[-4] // @1317 stack[-3] // } 1311 5B JUMPDEST 1312 50 POP 1313 61 PUSH2 0x131d 1316 92 SWAP3 1317 91 SWAP2 1318 50 POP 1319 61 PUSH2 0x1321 131C 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1316 stack[-4] = 0x131d // @1317 stack[-3] = stack[-4] // } // Block ends with call to 0x1321, returns to 0x131D label_131D: // Incoming jump from 0x132A, if !(stack[-2] > stack[-1]) // Incoming jump from 0x132A, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1321 at 0x131C // Inputs[2] // { // @131F stack[-3] // @131F stack[-2] // } 131D 5B JUMPDEST 131E 50 POP 131F 90 SWAP1 1320 56 *JUMP // Stack delta = -2 // Outputs[1] { @131F stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1321: // Incoming call from 0x131C, returns to 0x131D // Inputs[2] // { // @1323 stack[-1] // @1324 stack[-2] // } 1321 5B JUMPDEST 1322 5B JUMPDEST 1323 80 DUP1 1324 82 DUP3 1325 11 GT 1326 15 ISZERO 1327 61 PUSH2 0x131d 132A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x131d, if !(stack[-2] > stack[-1]) label_132B: // Incoming jump from 0x132A, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x132A, if not !(stack[-2] > stack[-1]) // Inputs[1] { @132D stack[-1] } 132B 60 PUSH1 0x00 132D 81 DUP2 132E 55 SSTORE 132F 60 PUSH1 0x01 1331 01 ADD 1332 61 PUSH2 0x1322 1335 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @132E storage[stack[-1]] = 0x00 // @1331 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1322 label_1336: // Incoming call from 0x1368, returns to 0x0A39 // Incoming call from 0x185E, returns to 0x0A39 // Inputs[1] { @1340 stack[-1] } 1336 5B JUMPDEST 1337 60 PUSH1 0x01 1339 60 PUSH1 0x01 133B 60 PUSH1 0xe0 133D 1B SHL 133E 03 SUB 133F 19 NOT 1340 81 DUP2 1341 16 AND 1342 81 DUP2 1343 14 EQ 1344 61 PUSH2 0x0ad8 1347 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ad8, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1348: // Incoming jump from 0x1347, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @134B memory[0x00:0x00] } 1348 60 PUSH1 0x00 134A 80 DUP1 134B FD *REVERT // Stack delta = +0 // Outputs[1] { @134B revert(memory[0x00:0x00]); } // Block terminates label_134C: // Incoming call from 0x0185, returns to 0x0186 // Inputs[2] // { // @1351 stack[-1] // @1352 stack[-2] // } 134C 5B JUMPDEST 134D 60 PUSH1 0x00 134F 60 PUSH1 0x20 1351 82 DUP3 1352 84 DUP5 1353 03 SUB 1354 12 SLT 1355 15 ISZERO 1356 61 PUSH2 0x135e 1359 57 *JUMPI // Stack delta = +1 // Outputs[1] { @134D stack[0] = 0x00 } // Block ends with conditional jump to 0x135e, if !(stack[-2] - stack[-1] i< 0x20) label_135A: // Incoming jump from 0x1359, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @135D memory[0x00:0x00] } 135A 60 PUSH1 0x00 135C 80 DUP1 135D FD *REVERT // Stack delta = +0 // Outputs[1] { @135D revert(memory[0x00:0x00]); } // Block terminates label_135E: // Incoming jump from 0x1359, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @135F stack[-2] // @1360 msg.data[stack[-2]:stack[-2] + 0x20] // } 135E 5B JUMPDEST 135F 81 DUP2 1360 35 CALLDATALOAD 1361 61 PUSH2 0x0a39 1364 81 DUP2 1365 61 PUSH2 0x1336 1368 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1360 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1361 stack[1] = 0x0a39 // @1364 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1336, returns to 0x0A39 label_1369: // Incoming call from 0x13AC, returns to 0x13AD // Inputs[1] { @136D stack[-3] } 1369 5B JUMPDEST 136A 60 PUSH1 0x00 136C 5B JUMPDEST 136D 83 DUP4 136E 81 DUP2 136F 10 LT 1370 15 ISZERO 1371 61 PUSH2 0x1384 1374 57 *JUMPI // Stack delta = +1 // Outputs[1] { @136A stack[0] = 0x00 } // Block ends with conditional jump to 0x1384, if !(0x00 < stack[-3]) label_1375: // Incoming jump from 0x1374, if not !(0x00 < stack[-3]) // Incoming jump from 0x1374, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1375 stack[-2] // @1376 stack[-1] // @1378 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1379 stack[-3] // } 1375 81 DUP2 1376 81 DUP2 1377 01 ADD 1378 51 MLOAD 1379 83 DUP4 137A 82 DUP3 137B 01 ADD 137C 52 MSTORE 137D 60 PUSH1 0x20 137F 01 ADD 1380 61 PUSH2 0x136c 1383 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @137C memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @137F stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x136c label_1384: // Incoming jump from 0x1374, if !(0x00 < stack[-3]) // Incoming jump from 0x1374, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @1385 stack[-4] // @1386 stack[-1] // } 1384 5B JUMPDEST 1385 83 DUP4 1386 81 DUP2 1387 11 GT 1388 15 ISZERO 1389 61 PUSH2 0x0931 138C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0931, if !(stack[-1] > stack[-4]) label_138D: // Incoming jump from 0x138C, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1391 stack[-4] // @1392 stack[-3] // @1394 stack[-5] // } 138D 50 POP 138E 50 POP 138F 60 PUSH1 0x00 1391 91 SWAP2 1392 01 ADD 1393 52 MSTORE 1394 56 *JUMP // Stack delta = -5 // Outputs[1] { @1393 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1395: // Incoming call from 0x1837, returns to 0x1838 // Incoming call from 0x13D3, returns to 0x0A39 // Inputs[3] // { // @1398 stack[-1] // @1399 memory[stack[-1]:stack[-1] + 0x20] // @139B stack[-2] // } 1395 5B JUMPDEST 1396 60 PUSH1 0x00 1398 81 DUP2 1399 51 MLOAD 139A 80 DUP1 139B 84 DUP5 139C 52 MSTORE 139D 61 PUSH2 0x13ad 13A0 81 DUP2 13A1 60 PUSH1 0x20 13A3 86 DUP7 13A4 01 ADD 13A5 60 PUSH1 0x20 13A7 86 DUP7 13A8 01 ADD 13A9 61 PUSH2 0x1369 13AC 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1396 stack[0] = 0x00 // @1399 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @139C memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @139D stack[2] = 0x13ad // @13A0 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @13A4 stack[4] = stack[-2] + 0x20 // @13A8 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1369, returns to 0x13AD label_13AD: // Incoming return from call to 0x1369 at 0x13AC // Inputs[4] // { // @13B0 stack[-1] // @13B5 stack[-4] // @13B6 stack[-2] // @13BC stack[-5] // } 13AD 5B JUMPDEST 13AE 60 PUSH1 0x1f 13B0 01 ADD 13B1 60 PUSH1 0x1f 13B3 19 NOT 13B4 16 AND 13B5 92 SWAP3 13B6 90 SWAP1 13B7 92 SWAP3 13B8 01 ADD 13B9 60 PUSH1 0x20 13BB 01 ADD 13BC 92 SWAP3 13BD 91 SWAP2 13BE 50 POP 13BF 50 POP 13C0 56 *JUMP // Stack delta = -4 // Outputs[1] { @13BC stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_13C1: // Incoming jump from 0x01B4 // Inputs[2] // { // @13C4 stack[-1] // @13CF stack[-2] // } 13C1 5B JUMPDEST 13C2 60 PUSH1 0x20 13C4 81 DUP2 13C5 52 MSTORE 13C6 60 PUSH1 0x00 13C8 61 PUSH2 0x0a39 13CB 60 PUSH1 0x20 13CD 83 DUP4 13CE 01 ADD 13CF 84 DUP5 13D0 61 PUSH2 0x1395 13D3 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @13C5 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @13C6 stack[0] = 0x00 // @13C8 stack[1] = 0x0a39 // @13CE stack[2] = stack[-1] + 0x20 // @13CF stack[3] = stack[-2] // } // Block ends with call to 0x1395, returns to 0x0A39 label_13D4: // Incoming call from 0x01C2, returns to 0x01C3 // Incoming call from 0x032D, returns to 0x032E // Incoming call from 0x025A, returns to 0x025B // Inputs[2] // { // @13D9 stack[-1] // @13DA stack[-2] // } 13D4 5B JUMPDEST 13D5 60 PUSH1 0x00 13D7 60 PUSH1 0x20 13D9 82 DUP3 13DA 84 DUP5 13DB 03 SUB 13DC 12 SLT 13DD 15 ISZERO 13DE 61 PUSH2 0x13e6 13E1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13D5 stack[0] = 0x00 } // Block ends with conditional jump to 0x13e6, if !(stack[-2] - stack[-1] i< 0x20) label_13E2: // Incoming jump from 0x13E1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @13E5 memory[0x00:0x00] } 13E2 60 PUSH1 0x00 13E4 80 DUP1 13E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @13E5 revert(memory[0x00:0x00]); } // Block terminates label_13E6: // Incoming jump from 0x13E1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @13E8 stack[-2] // @13E8 msg.data[stack[-2]:stack[-2] + 0x20] // @13E9 stack[-4] // @13EA stack[-3] // } 13E6 5B JUMPDEST 13E7 50 POP 13E8 35 CALLDATALOAD 13E9 91 SWAP2 13EA 90 SWAP1 13EB 50 POP 13EC 56 *JUMP // Stack delta = -3 // Outputs[1] { @13E9 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_13ED: // Incoming call from 0x1450, returns to 0x1451 // Incoming call from 0x1679, returns to 0x167A // Incoming call from 0x1687, returns to 0x1688 // Incoming call from 0x159E, returns to 0x159F // Incoming call from 0x14C5, returns to 0x0A39 // Incoming call from 0x145E, returns to 0x145F // Incoming call from 0x148A, returns to 0x148B // Incoming call from 0x1424, returns to 0x1425 // Incoming call from 0x16F2, returns to 0x16F3 // Incoming call from 0x1700, returns to 0x1701 // Inputs[2] // { // @13EE stack[-1] // @13EF msg.data[stack[-1]:stack[-1] + 0x20] // } 13ED 5B JUMPDEST 13EE 80 DUP1 13EF 35 CALLDATALOAD 13F0 60 PUSH1 0x01 13F2 60 PUSH1 0x01 13F4 60 PUSH1 0xa0 13F6 1B SHL 13F7 03 SUB 13F8 81 DUP2 13F9 16 AND 13FA 81 DUP2 13FB 14 EQ 13FC 61 PUSH2 0x1404 13FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13EF stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1404, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1400: // Incoming jump from 0x13FF, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1403 memory[0x00:0x00] } 1400 60 PUSH1 0x00 1402 80 DUP1 1403 FD *REVERT // Stack delta = +0 // Outputs[1] { @1403 revert(memory[0x00:0x00]); } // Block terminates label_1404: // Incoming jump from 0x13FF, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1405 stack[-1] // @1405 stack[-3] // @1406 stack[-2] // } 1404 5B JUMPDEST 1405 91 SWAP2 1406 90 SWAP1 1407 50 POP 1408 56 *JUMP // Stack delta = -2 // Outputs[1] { @1405 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1409: // Incoming call from 0x01ED, returns to 0x01EE // Inputs[2] // { // @140F stack[-1] // @1410 stack[-2] // } 1409 5B JUMPDEST 140A 60 PUSH1 0x00 140C 80 DUP1 140D 60 PUSH1 0x40 140F 83 DUP4 1410 85 DUP6 1411 03 SUB 1412 12 SLT 1413 15 ISZERO 1414 61 PUSH2 0x141c 1417 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @140A stack[0] = 0x00 // @140C stack[1] = 0x00 // } // Block ends with conditional jump to 0x141c, if !(stack[-2] - stack[-1] i< 0x40) label_1418: // Incoming jump from 0x1417, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @141B memory[0x00:0x00] } 1418 60 PUSH1 0x00 141A 80 DUP1 141B FD *REVERT // Stack delta = +0 // Outputs[1] { @141B revert(memory[0x00:0x00]); } // Block terminates label_141C: // Incoming jump from 0x1417, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1420 stack[-3] } 141C 5B JUMPDEST 141D 61 PUSH2 0x1425 1420 83 DUP4 1421 61 PUSH2 0x13ed 1424 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @141D stack[0] = 0x1425 // @1420 stack[1] = stack[-3] // } // Block ends with call to 0x13ed, returns to 0x1425 label_1425: // Incoming return from call to 0x13ED at 0x1424 // Inputs[5] // { // @1426 stack[-1] // @1426 stack[-6] // @1429 stack[-4] // @142D msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @142E stack[-5] // } 1425 5B JUMPDEST 1426 94 SWAP5 1427 60 PUSH1 0x20 1429 93 SWAP4 142A 90 SWAP1 142B 93 SWAP4 142C 01 ADD 142D 35 CALLDATALOAD 142E 93 SWAP4 142F 50 POP 1430 50 POP 1431 50 POP 1432 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1426 stack[-6] = stack[-1] // @142E stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1433: // Incoming call from 0x0218, returns to 0x0219 // Incoming call from 0x0234, returns to 0x0235 // Inputs[2] // { // @143B stack[-1] // @143C stack[-2] // } 1433 5B JUMPDEST 1434 60 PUSH1 0x00 1436 80 DUP1 1437 60 PUSH1 0x00 1439 60 PUSH1 0x60 143B 84 DUP5 143C 86 DUP7 143D 03 SUB 143E 12 SLT 143F 15 ISZERO 1440 61 PUSH2 0x1448 1443 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1434 stack[0] = 0x00 // @1436 stack[1] = 0x00 // @1437 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1448, if !(stack[-2] - stack[-1] i< 0x60) label_1444: // Incoming jump from 0x1443, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1447 memory[0x00:0x00] } 1444 60 PUSH1 0x00 1446 80 DUP1 1447 FD *REVERT // Stack delta = +0 // Outputs[1] { @1447 revert(memory[0x00:0x00]); } // Block terminates label_1448: // Incoming jump from 0x1443, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @144C stack[-4] } 1448 5B JUMPDEST 1449 61 PUSH2 0x1451 144C 84 DUP5 144D 61 PUSH2 0x13ed 1450 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1449 stack[0] = 0x1451 // @144C stack[1] = stack[-4] // } // Block ends with call to 0x13ed, returns to 0x1451 label_1451: // Incoming return from call to 0x13ED at 0x1450 // Inputs[3] // { // @1452 stack[-4] // @1452 stack[-1] // @1459 stack[-5] // } 1451 5B JUMPDEST 1452 92 SWAP3 1453 50 POP 1454 61 PUSH2 0x145f 1457 60 PUSH1 0x20 1459 85 DUP6 145A 01 ADD 145B 61 PUSH2 0x13ed 145E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1452 stack[-4] = stack[-1] // @1454 stack[-1] = 0x145f // @145A stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x13ed, returns to 0x145F label_145F: // Incoming return from call to 0x13ED at 0x145E // Inputs[8] // { // @1460 stack[-1] // @1460 stack[-3] // @1464 stack[-5] // @1466 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1467 stack[-2] // @146B stack[-6] // @146D stack[-4] // @146D stack[-7] // } 145F 5B JUMPDEST 1460 91 SWAP2 1461 50 POP 1462 60 PUSH1 0x40 1464 84 DUP5 1465 01 ADD 1466 35 CALLDATALOAD 1467 90 SWAP1 1468 50 POP 1469 92 SWAP3 146A 50 POP 146B 92 SWAP3 146C 50 POP 146D 92 SWAP3 146E 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1469 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @146B stack[-6] = stack[-1] // @146D stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_146F: // Incoming call from 0x0247, returns to 0x0248 // Incoming call from 0x02EA, returns to 0x02EB // Inputs[2] // { // @1475 stack[-1] // @1476 stack[-2] // } 146F 5B JUMPDEST 1470 60 PUSH1 0x00 1472 80 DUP1 1473 60 PUSH1 0x40 1475 83 DUP4 1476 85 DUP6 1477 03 SUB 1478 12 SLT 1479 15 ISZERO 147A 61 PUSH2 0x1482 147D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1470 stack[0] = 0x00 // @1472 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1482, if !(stack[-2] - stack[-1] i< 0x40) label_147E: // Incoming jump from 0x147D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1481 memory[0x00:0x00] } 147E 60 PUSH1 0x00 1480 80 DUP1 1481 FD *REVERT // Stack delta = +0 // Outputs[1] { @1481 revert(memory[0x00:0x00]); } // Block terminates label_1482: // Incoming jump from 0x147D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1486 stack[-3] } 1482 5B JUMPDEST 1483 61 PUSH2 0x148b 1486 83 DUP4 1487 61 PUSH2 0x13ed 148A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1483 stack[0] = 0x148b // @1486 stack[1] = stack[-3] // } // Block ends with call to 0x13ed, returns to 0x148B label_148B: // Incoming return from call to 0x13ED at 0x148A // Inputs[4] // { // @148C stack[-1] // @148C stack[-3] // @1490 stack[-4] // @1492 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 148B 5B JUMPDEST 148C 91 SWAP2 148D 50 POP 148E 60 PUSH1 0x20 1490 83 DUP4 1491 01 ADD 1492 35 CALLDATALOAD 1493 80 DUP1 1494 15 ISZERO 1495 15 ISZERO 1496 81 DUP2 1497 14 EQ 1498 61 PUSH2 0x14a0 149B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @148C stack[-3] = stack[-1] // @1492 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x14a0, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_149C: // Incoming jump from 0x149B, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @149F memory[0x00:0x00] } 149C 60 PUSH1 0x00 149E 80 DUP1 149F FD *REVERT // Stack delta = +0 // Outputs[1] { @149F revert(memory[0x00:0x00]); } // Block terminates label_14A0: // Incoming jump from 0x149B, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @14A1 stack[-1] // @14A2 stack[-2] // @14A5 stack[-5] // @14A7 stack[-6] // @14A7 stack[-3] // @14A8 stack[-4] // } 14A0 5B JUMPDEST 14A1 80 DUP1 14A2 91 SWAP2 14A3 50 POP 14A4 50 POP 14A5 92 SWAP3 14A6 50 POP 14A7 92 SWAP3 14A8 90 SWAP1 14A9 50 POP 14AA 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @14A5 stack[-5] = stack[-1] // @14A7 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_14AB: // Incoming call from 0x026D, returns to 0x026E // Incoming call from 0x02C7, returns to 0x02C8 // Incoming call from 0x037C, returns to 0x037D // Inputs[2] // { // @14B0 stack[-1] // @14B1 stack[-2] // } 14AB 5B JUMPDEST 14AC 60 PUSH1 0x00 14AE 60 PUSH1 0x20 14B0 82 DUP3 14B1 84 DUP5 14B2 03 SUB 14B3 12 SLT 14B4 15 ISZERO 14B5 61 PUSH2 0x14bd 14B8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14AC stack[0] = 0x00 } // Block ends with conditional jump to 0x14bd, if !(stack[-2] - stack[-1] i< 0x20) label_14B9: // Incoming jump from 0x14B8, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @14BC memory[0x00:0x00] } 14B9 60 PUSH1 0x00 14BB 80 DUP1 14BC FD *REVERT // Stack delta = +0 // Outputs[1] { @14BC revert(memory[0x00:0x00]); } // Block terminates label_14BD: // Incoming jump from 0x14B8, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @14C1 stack[-2] } 14BD 5B JUMPDEST 14BE 61 PUSH2 0x0a39 14C1 82 DUP3 14C2 61 PUSH2 0x13ed 14C5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14BE stack[0] = 0x0a39 // @14C1 stack[1] = stack[-2] // } // Block ends with call to 0x13ed, returns to 0x0A39 label_14C6: // Incoming jump from 0x15D3 // Incoming jump from 0x155D // Incoming jump from 0x1504 // Inputs[1] { @14DB memory[0x00:0x24] } 14C6 5B JUMPDEST 14C7 63 PUSH4 0x4e487b71 14CC 60 PUSH1 0xe0 14CE 1B SHL 14CF 60 PUSH1 0x00 14D1 52 MSTORE 14D2 60 PUSH1 0x41 14D4 60 PUSH1 0x04 14D6 52 MSTORE 14D7 60 PUSH1 0x24 14D9 60 PUSH1 0x00 14DB FD *REVERT // Stack delta = +0 // Outputs[3] // { // @14D1 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @14D6 memory[0x04:0x24] = 0x41 // @14DB revert(memory[0x00:0x24]); // } // Block terminates label_14DC: // Incoming call from 0x15E6, returns to 0x15E7 // Incoming call from 0x156E, returns to 0x156F // Inputs[2] // { // @14DF memory[0x40:0x60] // @14E2 stack[-1] // } 14DC 5B JUMPDEST 14DD 60 PUSH1 0x40 14DF 51 MLOAD 14E0 60 PUSH1 0x1f 14E2 82 DUP3 14E3 01 ADD 14E4 60 PUSH1 0x1f 14E6 19 NOT 14E7 16 AND 14E8 81 DUP2 14E9 01 ADD 14EA 67 PUSH8 0xffffffffffffffff 14F3 81 DUP2 14F4 11 GT 14F5 82 DUP3 14F6 82 DUP3 14F7 10 LT 14F8 17 OR 14F9 15 ISZERO 14FA 61 PUSH2 0x1505 14FD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14DF stack[0] = memory[0x40:0x60] // @14E9 stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x1505, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_14FE: // Incoming jump from 0x14FD, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 14FE 61 PUSH2 0x1505 1501 61 PUSH2 0x14c6 1504 56 *JUMP // Stack delta = +1 // Outputs[1] { @14FE stack[0] = 0x1505 } // Block ends with unconditional jump to 0x14c6 label_1505: // Incoming jump from 0x14FD, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @1508 stack[-1] // @1509 stack[-4] // @1509 stack[-2] // @150A stack[-3] // } 1505 5B JUMPDEST 1506 60 PUSH1 0x40 1508 52 MSTORE 1509 91 SWAP2 150A 90 SWAP1 150B 50 POP 150C 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1508 memory[0x40:0x60] = stack[-1] // @1509 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_150D: // Incoming call from 0x0288, returns to 0x0289 // Inputs[2] // { // @1513 stack[-1] // @1514 stack[-2] // } 150D 5B JUMPDEST 150E 60 PUSH1 0x00 1510 60 PUSH1 0x20 1512 80 DUP1 1513 83 DUP4 1514 85 DUP6 1515 03 SUB 1516 12 SLT 1517 15 ISZERO 1518 61 PUSH2 0x1520 151B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @150E stack[0] = 0x00 // @1510 stack[1] = 0x20 // } // Block ends with conditional jump to 0x1520, if !(stack[-2] - stack[-1] i< 0x20) label_151C: // Incoming jump from 0x151B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @151F memory[0x00:0x00] } 151C 60 PUSH1 0x00 151E 80 DUP1 151F FD *REVERT // Stack delta = +0 // Outputs[1] { @151F revert(memory[0x00:0x00]); } // Block terminates label_1520: // Incoming jump from 0x151B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1521 stack[-3] // @1522 msg.data[stack[-3]:stack[-3] + 0x20] // } 1520 5B JUMPDEST 1521 82 DUP3 1522 35 CALLDATALOAD 1523 67 PUSH8 0xffffffffffffffff 152C 80 DUP1 152D 82 DUP3 152E 11 GT 152F 15 ISZERO 1530 61 PUSH2 0x1538 1533 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1522 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1523 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1538, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1534: // Incoming jump from 0x1533, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1537 memory[0x00:0x00] } 1534 60 PUSH1 0x00 1536 80 DUP1 1537 FD *REVERT // Stack delta = +0 // Outputs[1] { @1537 revert(memory[0x00:0x00]); } // Block terminates label_1538: // Incoming jump from 0x1533, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1539 stack[-2] // @153A stack[-5] // @153E stack[-6] // } 1538 5B JUMPDEST 1539 81 DUP2 153A 85 DUP6 153B 01 ADD 153C 91 SWAP2 153D 50 POP 153E 85 DUP6 153F 60 PUSH1 0x1f 1541 83 DUP4 1542 01 ADD 1543 12 SLT 1544 61 PUSH2 0x154c 1547 57 *JUMPI // Stack delta = +0 // Outputs[1] { @153C stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x154c, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1548: // Incoming jump from 0x1547, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @154B memory[0x00:0x00] } 1548 60 PUSH1 0x00 154A 80 DUP1 154B FD *REVERT // Stack delta = +0 // Outputs[1] { @154B revert(memory[0x00:0x00]); } // Block terminates label_154C: // Incoming jump from 0x1547, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @154D stack[-2] // @154E msg.data[stack[-2]:stack[-2] + 0x20] // @154F stack[-1] // } 154C 5B JUMPDEST 154D 81 DUP2 154E 35 CALLDATALOAD 154F 81 DUP2 1550 81 DUP2 1551 11 GT 1552 15 ISZERO 1553 61 PUSH2 0x155e 1556 57 *JUMPI // Stack delta = +1 // Outputs[1] { @154E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x155e, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1557: // Incoming jump from 0x1556, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 1557 61 PUSH2 0x155e 155A 61 PUSH2 0x14c6 155D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1557 stack[0] = 0x155e } // Block ends with unconditional jump to 0x14c6 label_155E: // Incoming jump from 0x1556, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @155F stack[-1] // @1563 stack[-2] // @1568 stack[-4] // } 155E 5B JUMPDEST 155F 80 DUP1 1560 60 PUSH1 0x05 1562 1B SHL 1563 91 SWAP2 1564 50 POP 1565 61 PUSH2 0x156f 1568 84 DUP5 1569 83 DUP4 156A 01 ADD 156B 61 PUSH2 0x14dc 156E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1563 stack[-2] = stack[-1] << 0x05 // @1565 stack[0] = 0x156f // @156A stack[1] = (stack[-1] << 0x05) + stack[-4] // } // Block ends with call to 0x14dc, returns to 0x156F label_156F: // Incoming return from call to 0x14DC at 0x156E // Inputs[6] // { // @1570 stack[-2] // @1571 stack[-1] // @1573 stack[-3] // @1574 stack[-4] // @1576 stack[-5] // @157D stack[-8] // } 156F 5B JUMPDEST 1570 81 DUP2 1571 81 DUP2 1572 52 MSTORE 1573 91 SWAP2 1574 83 DUP4 1575 01 ADD 1576 84 DUP5 1577 01 ADD 1578 91 SWAP2 1579 84 DUP5 157A 81 DUP2 157B 01 ADD 157C 90 SWAP1 157D 88 DUP9 157E 84 DUP5 157F 11 GT 1580 15 ISZERO 1581 61 PUSH2 0x1589 1584 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1572 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1578 stack[-3] = stack[-5] + stack[-4] + stack[-3] // @157C stack[-1] = stack[-1] + stack[-5] // @157C stack[0] = stack[-1] // } // Block ends with conditional jump to 0x1589, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) label_1585: // Incoming jump from 0x1584, if not !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[1] { @1588 memory[0x00:0x00] } 1585 60 PUSH1 0x00 1587 80 DUP1 1588 FD *REVERT // Stack delta = +0 // Outputs[1] { @1588 revert(memory[0x00:0x00]); } // Block terminates label_1589: // Incoming jump from 0x1584, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[4] // { // @158A stack[-1] // @158A stack[-5] // @158B stack[-6] // @158F stack[-4] // } 1589 5B JUMPDEST 158A 93 SWAP4 158B 85 DUP6 158C 01 ADD 158D 93 SWAP4 158E 5B JUMPDEST 158F 83 DUP4 1590 85 DUP6 1591 10 LT 1592 15 ISZERO 1593 61 PUSH2 0x15ae 1596 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @158D stack[-5] = stack[-6] + stack[-5] // @158D stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x15ae, if !(stack[-6] + stack[-5] < stack[-4]) label_1597: // Incoming jump from 0x1596, if not !(stack[-5] < stack[-4]) // Incoming jump from 0x1596, if not !(stack[-6] + stack[-5] < stack[-4]) // Inputs[1] { @159A stack[-5] } 1597 61 PUSH2 0x159f 159A 85 DUP6 159B 61 PUSH2 0x13ed 159E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1597 stack[0] = 0x159f // @159A stack[1] = stack[-5] // } // Block ends with call to 0x13ed, returns to 0x159F label_159F: // Incoming return from call to 0x13ED at 0x159E // Inputs[5] // { // @15A0 stack[-3] // @15A1 stack[-1] // @15A2 stack[-6] // @15A2 stack[-2] // @15A3 stack[-7] // } 159F 5B JUMPDEST 15A0 82 DUP3 15A1 52 MSTORE 15A2 93 SWAP4 15A3 85 DUP6 15A4 01 ADD 15A5 93 SWAP4 15A6 90 SWAP1 15A7 85 DUP6 15A8 01 ADD 15A9 90 SWAP1 15AA 61 PUSH2 0x158e 15AD 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @15A1 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @15A5 stack[-6] = stack[-7] + stack[-6] // @15A9 stack[-2] = stack[-2] // @15A9 stack[-3] = stack[-7] + stack[-3] // } // Block ends with unconditional jump to 0x158e label_15AE: // Incoming jump from 0x1596, if !(stack[-5] < stack[-4]) // Incoming jump from 0x1596, if !(stack[-6] + stack[-5] < stack[-4]) // Inputs[3] // { // @15AF stack[-10] // @15AF stack[-1] // @15B0 stack[-9] // } 15AE 5B JUMPDEST 15AF 98 SWAP9 15B0 97 SWAP8 15B1 50 POP 15B2 50 POP 15B3 50 POP 15B4 50 POP 15B5 50 POP 15B6 50 POP 15B7 50 POP 15B8 50 POP 15B9 56 *JUMP // Stack delta = -9 // Outputs[1] { @15AF stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_15BA: // Incoming call from 0x165A, returns to 0x0FBD // Incoming call from 0x16CA, returns to 0x16CB // Inputs[1] { @15C6 stack[-2] } 15BA 5B JUMPDEST 15BB 60 PUSH1 0x00 15BD 67 PUSH8 0xffffffffffffffff 15C6 83 DUP4 15C7 11 GT 15C8 15 ISZERO 15C9 61 PUSH2 0x15d4 15CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15BB stack[0] = 0x00 } // Block ends with conditional jump to 0x15d4, if !(stack[-2] > 0xffffffffffffffff) label_15CD: // Incoming jump from 0x15CC, if not !(stack[-2] > 0xffffffffffffffff) 15CD 61 PUSH2 0x15d4 15D0 61 PUSH2 0x14c6 15D3 56 *JUMP // Stack delta = +1 // Outputs[1] { @15CD stack[0] = 0x15d4 } // Block ends with unconditional jump to 0x14c6 label_15D4: // Incoming jump from 0x15CC, if !(stack[-2] > 0xffffffffffffffff) // Inputs[1] { @15DA stack[-3] } 15D4 5B JUMPDEST 15D5 61 PUSH2 0x15e7 15D8 60 PUSH1 0x1f 15DA 84 DUP5 15DB 01 ADD 15DC 60 PUSH1 0x1f 15DE 19 NOT 15DF 16 AND 15E0 60 PUSH1 0x20 15E2 01 ADD 15E3 61 PUSH2 0x14dc 15E6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15D5 stack[0] = 0x15e7 // @15E2 stack[1] = 0x20 + (~0x1f & stack[-3] + 0x1f) // } // Block ends with call to 0x14dc, returns to 0x15E7 label_15E7: // Incoming return from call to 0x14DC at 0x15E6 // Inputs[5] // { // @15E8 stack[-1] // @15E8 stack[-2] // @15EA stack[-4] // @15ED stack[-5] // @15EF stack[-3] // } 15E7 5B JUMPDEST 15E8 90 SWAP1 15E9 50 POP 15EA 82 DUP3 15EB 81 DUP2 15EC 52 MSTORE 15ED 83 DUP4 15EE 83 DUP4 15EF 83 DUP4 15F0 01 ADD 15F1 11 GT 15F2 15 ISZERO 15F3 61 PUSH2 0x15fb 15F6 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @15E8 stack[-2] = stack[-1] // @15EC memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x15fb, if !(stack[-3] + stack[-4] > stack[-5]) label_15F7: // Incoming jump from 0x15F6, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @15FA memory[0x00:0x00] } 15F7 60 PUSH1 0x00 15F9 80 DUP1 15FA FD *REVERT // Stack delta = +0 // Outputs[1] { @15FA revert(memory[0x00:0x00]); } // Block terminates label_15FB: // Incoming jump from 0x15F6, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[6] // { // @15FC stack[-3] // @15FD stack[-2] // @1600 stack[-1] // @1602 msg.data[stack[-2]:stack[-2] + stack[-3]] // @160C stack[-5] // @160D stack[-4] // } 15FB 5B JUMPDEST 15FC 82 DUP3 15FD 82 DUP3 15FE 60 PUSH1 0x20 1600 83 DUP4 1601 01 ADD 1602 37 CALLDATACOPY 1603 60 PUSH1 0x00 1605 60 PUSH1 0x20 1607 84 DUP5 1608 83 DUP4 1609 01 ADD 160A 01 ADD 160B 52 MSTORE 160C 93 SWAP4 160D 92 SWAP3 160E 50 POP 160F 50 POP 1610 50 POP 1611 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1602 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-2]:stack[-2] + stack[-3]] // @160B memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @160C stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_1612: // Incoming call from 0x02AC, returns to 0x02AD // Inputs[2] // { // @1617 stack[-1] // @1618 stack[-2] // } 1612 5B JUMPDEST 1613 60 PUSH1 0x00 1615 60 PUSH1 0x20 1617 82 DUP3 1618 84 DUP5 1619 03 SUB 161A 12 SLT 161B 15 ISZERO 161C 61 PUSH2 0x1624 161F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1613 stack[0] = 0x00 } // Block ends with conditional jump to 0x1624, if !(stack[-2] - stack[-1] i< 0x20) label_1620: // Incoming jump from 0x161F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1623 memory[0x00:0x00] } 1620 60 PUSH1 0x00 1622 80 DUP1 1623 FD *REVERT // Stack delta = +0 // Outputs[1] { @1623 revert(memory[0x00:0x00]); } // Block terminates label_1624: // Incoming jump from 0x161F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1625 stack[-2] // @1626 msg.data[stack[-2]:stack[-2] + 0x20] // } 1624 5B JUMPDEST 1625 81 DUP2 1626 35 CALLDATALOAD 1627 67 PUSH8 0xffffffffffffffff 1630 81 DUP2 1631 11 GT 1632 15 ISZERO 1633 61 PUSH2 0x163b 1636 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1626 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x163b, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1637: // Incoming jump from 0x1636, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @163A memory[0x00:0x00] } 1637 60 PUSH1 0x00 1639 80 DUP1 163A FD *REVERT // Stack delta = +0 // Outputs[1] { @163A revert(memory[0x00:0x00]); } // Block terminates label_163B: // Incoming jump from 0x1636, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @163C stack[-3] // @163D stack[-1] // @1642 stack[-4] // } 163B 5B JUMPDEST 163C 82 DUP3 163D 01 ADD 163E 60 PUSH1 0x1f 1640 81 DUP2 1641 01 ADD 1642 84 DUP5 1643 13 SGT 1644 61 PUSH2 0x164c 1647 57 *JUMPI // Stack delta = +0 // Outputs[1] { @163D stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x164c, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1648: // Incoming jump from 0x1647, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @164B memory[0x00:0x00] } 1648 60 PUSH1 0x00 164A 80 DUP1 164B FD *REVERT // Stack delta = +0 // Outputs[1] { @164B revert(memory[0x00:0x00]); } // Block terminates label_164C: // Incoming jump from 0x1647, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1650 stack[-4] // @1651 stack[-1] // @1652 msg.data[stack[-1]:stack[-1] + 0x20] // } 164C 5B JUMPDEST 164D 61 PUSH2 0x0fbd 1650 84 DUP5 1651 82 DUP3 1652 35 CALLDATALOAD 1653 60 PUSH1 0x20 1655 84 DUP5 1656 01 ADD 1657 61 PUSH2 0x15ba 165A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @164D stack[0] = 0x0fbd // @1650 stack[1] = stack[-4] // @1652 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1656 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x15ba, returns to 0x0FBD label_165B: // Incoming call from 0x0312, returns to 0x0313 // Inputs[2] // { // @1664 stack[-1] // @1665 stack[-2] // } 165B 5B JUMPDEST 165C 60 PUSH1 0x00 165E 80 DUP1 165F 60 PUSH1 0x00 1661 80 DUP1 1662 60 PUSH1 0x80 1664 85 DUP6 1665 87 DUP8 1666 03 SUB 1667 12 SLT 1668 15 ISZERO 1669 61 PUSH2 0x1671 166C 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @165C stack[0] = 0x00 // @165E stack[1] = 0x00 // @165F stack[2] = 0x00 // @1661 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1671, if !(stack[-2] - stack[-1] i< 0x80) label_166D: // Incoming jump from 0x166C, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1670 memory[0x00:0x00] } 166D 60 PUSH1 0x00 166F 80 DUP1 1670 FD *REVERT // Stack delta = +0 // Outputs[1] { @1670 revert(memory[0x00:0x00]); } // Block terminates label_1671: // Incoming jump from 0x166C, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1675 stack[-5] } 1671 5B JUMPDEST 1672 61 PUSH2 0x167a 1675 85 DUP6 1676 61 PUSH2 0x13ed 1679 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1672 stack[0] = 0x167a // @1675 stack[1] = stack[-5] // } // Block ends with call to 0x13ed, returns to 0x167A label_167A: // Incoming return from call to 0x13ED at 0x1679 // Inputs[3] // { // @167B stack[-1] // @167B stack[-5] // @1682 stack[-6] // } 167A 5B JUMPDEST 167B 93 SWAP4 167C 50 POP 167D 61 PUSH2 0x1688 1680 60 PUSH1 0x20 1682 86 DUP7 1683 01 ADD 1684 61 PUSH2 0x13ed 1687 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @167B stack[-5] = stack[-1] // @167D stack[-1] = 0x1688 // @1683 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x13ed, returns to 0x1688 label_1688: // Incoming return from call to 0x13ED at 0x1687 // Inputs[6] // { // @1689 stack[-4] // @1689 stack[-1] // @168D stack[-6] // @168F msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1690 stack[-3] // @1696 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1688 5B JUMPDEST 1689 92 SWAP3 168A 50 POP 168B 60 PUSH1 0x40 168D 85 DUP6 168E 01 ADD 168F 35 CALLDATALOAD 1690 91 SWAP2 1691 50 POP 1692 60 PUSH1 0x60 1694 85 DUP6 1695 01 ADD 1696 35 CALLDATALOAD 1697 67 PUSH8 0xffffffffffffffff 16A0 81 DUP2 16A1 11 GT 16A2 15 ISZERO 16A3 61 PUSH2 0x16ab 16A6 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1689 stack[-4] = stack[-1] // @1690 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1696 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x16ab, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_16A7: // Incoming jump from 0x16A6, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @16AA memory[0x00:0x00] } 16A7 60 PUSH1 0x00 16A9 80 DUP1 16AA FD *REVERT // Stack delta = +0 // Outputs[1] { @16AA revert(memory[0x00:0x00]); } // Block terminates label_16AB: // Incoming jump from 0x16A6, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @16AC stack[-6] // @16AD stack[-1] // @16B2 stack[-7] // } 16AB 5B JUMPDEST 16AC 85 DUP6 16AD 01 ADD 16AE 60 PUSH1 0x1f 16B0 81 DUP2 16B1 01 ADD 16B2 87 DUP8 16B3 13 SGT 16B4 61 PUSH2 0x16bc 16B7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @16AD stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x16bc, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_16B8: // Incoming jump from 0x16B7, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @16BB memory[0x00:0x00] } 16B8 60 PUSH1 0x00 16BA 80 DUP1 16BB FD *REVERT // Stack delta = +0 // Outputs[1] { @16BB revert(memory[0x00:0x00]); } // Block terminates label_16BC: // Incoming jump from 0x16B7, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @16C0 stack[-7] // @16C1 stack[-1] // @16C2 msg.data[stack[-1]:stack[-1] + 0x20] // } 16BC 5B JUMPDEST 16BD 61 PUSH2 0x16cb 16C0 87 DUP8 16C1 82 DUP3 16C2 35 CALLDATALOAD 16C3 60 PUSH1 0x20 16C5 84 DUP5 16C6 01 ADD 16C7 61 PUSH2 0x15ba 16CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @16BD stack[0] = 0x16cb // @16C0 stack[1] = stack[-7] // @16C2 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @16C6 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x15ba, returns to 0x16CB label_16CB: // Incoming return from call to 0x15BA at 0x16CA // Inputs[8] // { // @16CC stack[-3] // @16CC stack[-1] // @16CF stack[-6] // @16D0 stack[-9] // @16D1 stack[-5] // @16D2 stack[-8] // @16D4 stack[-4] // @16D4 stack[-7] // } 16CB 5B JUMPDEST 16CC 91 SWAP2 16CD 50 POP 16CE 50 POP 16CF 92 SWAP3 16D0 95 SWAP6 16D1 91 SWAP2 16D2 94 SWAP5 16D3 50 POP 16D4 92 SWAP3 16D5 50 POP 16D6 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @16CF stack[-6] = stack[-1] // @16D0 stack[-9] = stack[-6] // @16D2 stack[-8] = stack[-5] // @16D4 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_16D7: // Incoming call from 0x0340, returns to 0x0341 // Inputs[2] // { // @16DD stack[-1] // @16DE stack[-2] // } 16D7 5B JUMPDEST 16D8 60 PUSH1 0x00 16DA 80 DUP1 16DB 60 PUSH1 0x40 16DD 83 DUP4 16DE 85 DUP6 16DF 03 SUB 16E0 12 SLT 16E1 15 ISZERO 16E2 61 PUSH2 0x16ea 16E5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @16D8 stack[0] = 0x00 // @16DA stack[1] = 0x00 // } // Block ends with conditional jump to 0x16ea, if !(stack[-2] - stack[-1] i< 0x40) label_16E6: // Incoming jump from 0x16E5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @16E9 memory[0x00:0x00] } 16E6 60 PUSH1 0x00 16E8 80 DUP1 16E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @16E9 revert(memory[0x00:0x00]); } // Block terminates label_16EA: // Incoming jump from 0x16E5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @16EE stack[-3] } 16EA 5B JUMPDEST 16EB 61 PUSH2 0x16f3 16EE 83 DUP4 16EF 61 PUSH2 0x13ed 16F2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16EB stack[0] = 0x16f3 // @16EE stack[1] = stack[-3] // } // Block ends with call to 0x13ed, returns to 0x16F3 label_16F3: // Incoming return from call to 0x13ED at 0x16F2 // Inputs[3] // { // @16F4 stack[-3] // @16F4 stack[-1] // @16FB stack[-4] // } 16F3 5B JUMPDEST 16F4 91 SWAP2 16F5 50 POP 16F6 61 PUSH2 0x1701 16F9 60 PUSH1 0x20 16FB 84 DUP5 16FC 01 ADD 16FD 61 PUSH2 0x13ed 1700 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @16F4 stack[-3] = stack[-1] // @16F6 stack[-1] = 0x1701 // @16FC stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x13ed, returns to 0x1701 label_1701: // Incoming return from call to 0x13ED at 0x1700 // Inputs[6] // { // @1702 stack[-2] // @1702 stack[-1] // @1704 stack[-5] // @1706 stack[-3] // @1706 stack[-6] // @1707 stack[-4] // } 1701 5B JUMPDEST 1702 90 SWAP1 1703 50 POP 1704 92 SWAP3 1705 50 POP 1706 92 SWAP3 1707 90 SWAP1 1708 50 POP 1709 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1704 stack[-5] = stack[-1] // @1706 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_170A: // Incoming call from 0x03E2, returns to 0x03E3 // Incoming call from 0x0850, returns to 0x03E3 // Incoming call from 0x0FD3, returns to 0x03E3 // Incoming call from 0x12A8, returns to 0x12A9 // Incoming call from 0x040E, returns to 0x040F // Inputs[1] { @170D stack[-1] } 170A 5B JUMPDEST 170B 60 PUSH1 0x01 170D 81 DUP2 170E 81 DUP2 170F 1C SHR 1710 90 SWAP1 1711 82 DUP3 1712 16 AND 1713 80 DUP1 1714 61 PUSH2 0x171e 1717 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1710 stack[0] = stack[-1] >> 0x01 // @1712 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x171e, if stack[-1] & 0x01 label_1718: // Incoming jump from 0x1717, if not stack[-1] & 0x01 // Inputs[2] // { // @171A stack[-2] // @1723 stack[-1] // } 1718 60 PUSH1 0x7f 171A 82 DUP3 171B 16 AND 171C 91 SWAP2 171D 50 POP 171E 5B JUMPDEST 171F 60 PUSH1 0x20 1721 82 DUP3 1722 10 LT 1723 81 DUP2 1724 03 SUB 1725 61 PUSH2 0x173e 1728 57 *JUMPI // Stack delta = +0 // Outputs[1] { @171C stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x173e, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_1729: // Incoming jump from 0x1728, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x1728, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @173D memory[0x00:0x24] } 1729 63 PUSH4 0x4e487b71 172E 60 PUSH1 0xe0 1730 1B SHL 1731 60 PUSH1 0x00 1733 52 MSTORE 1734 60 PUSH1 0x22 1736 60 PUSH1 0x04 1738 52 MSTORE 1739 60 PUSH1 0x24 173B 60 PUSH1 0x00 173D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1733 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1738 memory[0x04:0x24] = 0x22 // @173D revert(memory[0x00:0x24]); // } // Block terminates label_173E: // Incoming jump from 0x1728, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x1728, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @1740 stack[-4] // @1740 stack[-2] // @1741 stack[-3] // } 173E 5B JUMPDEST 173F 50 POP 1740 91 SWAP2 1741 90 SWAP1 1742 50 POP 1743 56 *JUMP // Stack delta = -3 // Outputs[1] { @1740 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1744: // Incoming call from 0x0645, returns to 0x0587 // Incoming call from 0x0A69, returns to 0x0587 // Incoming call from 0x0586, returns to 0x0587 // Incoming call from 0x082E, returns to 0x0587 // Incoming call from 0x0960, returns to 0x0587 // Inputs[2] // { // @1748 stack[-1] // @1777 stack[-2] // } 1744 5B JUMPDEST 1745 60 PUSH1 0x20 1747 80 DUP1 1748 82 DUP3 1749 52 MSTORE 174A 81 DUP2 174B 81 DUP2 174C 01 ADD 174D 52 MSTORE 174E 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 176F 60 PUSH1 0x40 1771 82 DUP3 1772 01 ADD 1773 52 MSTORE 1774 60 PUSH1 0x60 1776 01 ADD 1777 90 SWAP1 1778 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1749 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @174D memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @1773 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1777 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1779: // Incoming jump from 0x17A1 // Inputs[1] { @178E memory[0x00:0x24] } 1779 5B JUMPDEST 177A 63 PUSH4 0x4e487b71 177F 60 PUSH1 0xe0 1781 1B SHL 1782 60 PUSH1 0x00 1784 52 MSTORE 1785 60 PUSH1 0x11 1787 60 PUSH1 0x04 1789 52 MSTORE 178A 60 PUSH1 0x24 178C 60 PUSH1 0x00 178E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1784 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1789 memory[0x04:0x24] = 0x11 // @178E revert(memory[0x00:0x24]); // } // Block terminates label_178F: // Incoming call from 0x0705, returns to 0x0706 // Inputs[2] // { // @1792 stack[-2] // @1794 stack[-1] // } 178F 5B JUMPDEST 1790 60 PUSH1 0x00 1792 82 DUP3 1793 19 NOT 1794 82 DUP3 1795 11 GT 1796 15 ISZERO 1797 61 PUSH2 0x17a2 179A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1790 stack[0] = 0x00 } // Block ends with conditional jump to 0x17a2, if !(stack[-1] > ~stack[-2]) label_179B: // Incoming jump from 0x179A, if not !(stack[-1] > ~stack[-2]) 179B 61 PUSH2 0x17a2 179E 61 PUSH2 0x1779 17A1 56 *JUMP // Stack delta = +1 // Outputs[1] { @179B stack[0] = 0x17a2 } // Block ends with unconditional jump to 0x1779 label_17A2: // Incoming jump from 0x179A, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @17A4 stack[-2] // @17A4 stack[-3] // @17A5 stack[-4] // } 17A2 5B JUMPDEST 17A3 50 POP 17A4 01 ADD 17A5 90 SWAP1 17A6 56 *JUMP // Stack delta = -3 // Outputs[1] { @17A5 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_17A7: // Incoming jump from 0x07DF // Inputs[1] { @17BC memory[0x00:0x24] } 17A7 5B JUMPDEST 17A8 63 PUSH4 0x4e487b71 17AD 60 PUSH1 0xe0 17AF 1B SHL 17B0 60 PUSH1 0x00 17B2 52 MSTORE 17B3 60 PUSH1 0x32 17B5 60 PUSH1 0x04 17B7 52 MSTORE 17B8 60 PUSH1 0x24 17BA 60 PUSH1 0x00 17BC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @17B2 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @17B7 memory[0x04:0x24] = 0x32 // @17BC revert(memory[0x00:0x24]); // } // Block terminates 17BD 5B JUMPDEST 17BE 60 PUSH1 0x00 17C0 60 PUSH1 0x01 17C2 82 DUP3 17C3 01 ADD 17C4 61 PUSH2 0x17cf 17C7 57 *JUMPI 17C8 61 PUSH2 0x17cf 17CB 61 PUSH2 0x1779 17CE 56 *JUMP 17CF 5B JUMPDEST 17D0 50 POP 17D1 60 PUSH1 0x01 17D3 01 ADD 17D4 90 SWAP1 17D5 56 *JUMP 17D6 5B JUMPDEST 17D7 60 PUSH1 0x00 17D9 83 DUP4 17DA 51 MLOAD 17DB 61 PUSH2 0x17e8 17DE 81 DUP2 17DF 84 DUP5 17E0 60 PUSH1 0x20 17E2 88 DUP9 17E3 01 ADD 17E4 61 PUSH2 0x1369 17E7 56 *JUMP 17E8 5B JUMPDEST 17E9 83 DUP4 17EA 51 MLOAD 17EB 90 SWAP1 17EC 83 DUP4 17ED 01 ADD 17EE 90 SWAP1 17EF 61 PUSH2 0x17fc 17F2 81 DUP2 17F3 83 DUP4 17F4 60 PUSH1 0x20 17F6 88 DUP9 17F7 01 ADD 17F8 61 PUSH2 0x1369 17FB 56 *JUMP 17FC 5B JUMPDEST 17FD 01 ADD 17FE 94 SWAP5 17FF 93 SWAP4 1800 50 POP 1801 50 POP 1802 50 POP 1803 50 POP 1804 56 *JUMP label_1805: // Incoming call from 0x0F0D, returns to 0x0F0E // Inputs[5] // { // @180E stack[-5] // @1811 stack[-1] // @1813 stack[-4] // @181E stack[-3] // @1833 stack[-2] // } 1805 5B JUMPDEST 1806 60 PUSH1 0x01 1808 60 PUSH1 0x01 180A 60 PUSH1 0xa0 180C 1B SHL 180D 03 SUB 180E 85 DUP6 180F 81 DUP2 1810 16 AND 1811 82 DUP3 1812 52 MSTORE 1813 84 DUP5 1814 16 AND 1815 60 PUSH1 0x20 1817 82 DUP3 1818 01 ADD 1819 52 MSTORE 181A 60 PUSH1 0x40 181C 81 DUP2 181D 01 ADD 181E 83 DUP4 181F 90 SWAP1 1820 52 MSTORE 1821 60 PUSH1 0x80 1823 60 PUSH1 0x60 1825 82 DUP3 1826 01 ADD 1827 81 DUP2 1828 90 SWAP1 1829 52 MSTORE 182A 60 PUSH1 0x00 182C 90 SWAP1 182D 61 PUSH2 0x1838 1830 90 SWAP1 1831 83 DUP4 1832 01 ADD 1833 84 DUP5 1834 61 PUSH2 0x1395 1837 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1812 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1819 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1820 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @1829 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @182C stack[0] = 0x00 // @1830 stack[1] = 0x1838 // @1832 stack[2] = stack[-1] + 0x80 // @1833 stack[3] = stack[-2] // } // Block ends with call to 0x1395, returns to 0x1838 label_1838: // Incoming return from call to 0x1395 at 0x1837 // Inputs[3] // { // @1839 stack[-1] // @1839 stack[-8] // @183A stack[-7] // } 1838 5B JUMPDEST 1839 96 SWAP7 183A 95 SWAP6 183B 50 POP 183C 50 POP 183D 50 POP 183E 50 POP 183F 50 POP 1840 50 POP 1841 56 *JUMP // Stack delta = -7 // Outputs[1] { @1839 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1842: // Incoming jump from 0x0F45 // Inputs[2] // { // @1847 stack[-1] // @1848 stack[-2] // } 1842 5B JUMPDEST 1843 60 PUSH1 0x00 1845 60 PUSH1 0x20 1847 82 DUP3 1848 84 DUP5 1849 03 SUB 184A 12 SLT 184B 15 ISZERO 184C 61 PUSH2 0x1854 184F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1843 stack[0] = 0x00 } // Block ends with conditional jump to 0x1854, if !(stack[-2] - stack[-1] i< 0x20) label_1850: // Incoming jump from 0x184F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1853 memory[0x00:0x00] } 1850 60 PUSH1 0x00 1852 80 DUP1 1853 FD *REVERT // Stack delta = +0 // Outputs[1] { @1853 revert(memory[0x00:0x00]); } // Block terminates label_1854: // Incoming jump from 0x184F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1855 stack[-2] // @1856 memory[stack[-2]:stack[-2] + 0x20] // } 1854 5B JUMPDEST 1855 81 DUP2 1856 51 MLOAD 1857 61 PUSH2 0x0a39 185A 81 DUP2 185B 61 PUSH2 0x1336 185E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1856 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1857 stack[1] = 0x0a39 // @185A stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1336, returns to 0x0A39 185F 5B JUMPDEST 1860 63 PUSH4 0x4e487b71 1865 60 PUSH1 0xe0 1867 1B SHL 1868 60 PUSH1 0x00 186A 52 MSTORE 186B 60 PUSH1 0x12 186D 60 PUSH1 0x04 186F 52 MSTORE 1870 60 PUSH1 0x24 1872 60 PUSH1 0x00 1874 FD *REVERT 1875 5B JUMPDEST 1876 60 PUSH1 0x00 1878 82 DUP3 1879 61 PUSH2 0x1884 187C 57 *JUMPI 187D 61 PUSH2 0x1884 1880 61 PUSH2 0x185f 1883 56 *JUMP 1884 5B JUMPDEST 1885 50 POP 1886 04 DIV 1887 90 SWAP1 1888 56 *JUMP 1889 5B JUMPDEST 188A 60 PUSH1 0x00 188C 82 DUP3 188D 82 DUP3 188E 10 LT 188F 15 ISZERO 1890 61 PUSH2 0x189b 1893 57 *JUMPI 1894 61 PUSH2 0x189b 1897 61 PUSH2 0x1779 189A 56 *JUMP 189B 5B JUMPDEST 189C 50 POP 189D 03 SUB 189E 90 SWAP1 189F 56 *JUMP 18A0 5B JUMPDEST 18A1 60 PUSH1 0x00 18A3 82 DUP3 18A4 61 PUSH2 0x18af 18A7 57 *JUMPI 18A8 61 PUSH2 0x18af 18AB 61 PUSH2 0x185f 18AE 56 *JUMP 18AF 5B JUMPDEST 18B0 50 POP 18B1 06 MOD 18B2 90 SWAP1 18B3 56 *JUMP 18B4 FE *ASSERT 18B5 A2 LOG2 18B6 64 PUSH5 0x6970667358 18BC 22 22 18BD 12 SLT 18BE 20 SHA3 18BF 09 MULMOD 18C0 D7 D7 18C1 1A BYTE 18C2 AB AB 18C3 50 POP 18C4 2D 2D 18C5 91 SWAP2 18C6 55 SSTORE 18C7 60 PUSH1 0x29 18C9 AD AD 18CA E9 E9 18CB AB AB 18CC 56 *JUMP 18CD A6 A6 18CE 25 25 18CF EE EE 18D0 64 PUSH5 0x3c28e4b4b7 18D6 50 POP 18D7 BF BF 18D8 EE EE 18D9 C8 C8 18DA C4 C4 18DB 30 ADDRESS 18DC FD *REVERT 18DD D1 D1 18DE E6 E6 18DF 64 PUSH5 0x736f6c6343 18E5 00 *STOP 18E6 08 ADDMOD 18E7 0D 0D 18E8 00 *STOP 18E9 33 CALLER