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 0x0137 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0137, 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 0x715018a6 0026 11 GT 0027 61 PUSH2 0x00b8 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00b8, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa22cb465 0031 11 GT 0032 61 PUSH2 0x007c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xa22cb465 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xa22cb465 003C 14 EQ 003D 61 PUSH2 0x0286 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0286, if 0xa22cb465 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xb88d4fde 0047 14 EQ 0048 61 PUSH2 0x0299 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0299, if 0xb88d4fde == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xb88d4fde == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xc87b56dd 0052 14 EQ 0053 61 PUSH2 0x02ac 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ac, 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 0xd547cfb7 005D 14 EQ 005E 61 PUSH2 0x02bf 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bf, if 0xd547cfb7 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xd547cfb7 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xe985e9c5 0068 14 EQ 0069 61 PUSH2 0x02c7 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c7, if 0xe985e9c5 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xf2fde38b 0073 14 EQ 0074 61 PUSH2 0x0303 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0303, if 0xf2fde38b == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xf2fde38b == stack[-1] // Inputs[1] { @007B memory[0x00:0x00] } 0078 60 PUSH1 0x00 007A 80 DUP1 007B FD *REVERT // Stack delta = +0 // Outputs[1] { @007B revert(memory[0x00:0x00]); } // Block terminates label_007C: // Incoming jump from 0x0035, if 0xa22cb465 > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0x715018a6 0083 14 EQ 0084 61 PUSH2 0x0232 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0232, if 0x715018a6 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x715018a6 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x79df1452 008E 14 EQ 008F 61 PUSH2 0x023a 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023a, if 0x79df1452 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x79df1452 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0x8462151c 0099 14 EQ 009A 61 PUSH2 0x024d 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024d, if 0x8462151c == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0x8462151c == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0x8da5cb5b 00A4 14 EQ 00A5 61 PUSH2 0x026d 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026d, if 0x8da5cb5b == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00A9 stack[-1] } 00A9 80 DUP1 00AA 63 PUSH4 0x95d89b41 00AF 14 EQ 00B0 61 PUSH2 0x027e 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027e, if 0x95d89b41 == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00B7 memory[0x00:0x00] } 00B4 60 PUSH1 0x00 00B6 80 DUP1 00B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B7 revert(memory[0x00:0x00]); } // Block terminates label_00B8: // Incoming jump from 0x002A, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00B9 stack[-1] } 00B8 5B JUMPDEST 00B9 80 DUP1 00BA 63 PUSH4 0x23b872dd 00BF 11 GT 00C0 61 PUSH2 0x00ff 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ff, if 0x23b872dd > stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x23b872dd > stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x23b872dd 00CA 14 EQ 00CB 61 PUSH2 0x01d3 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d3, if 0x23b872dd == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x23b872dd == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x42842e0e 00D5 14 EQ 00D6 61 PUSH2 0x01e6 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e6, if 0x42842e0e == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x42842e0e == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x55f804b3 00E0 14 EQ 00E1 61 PUSH2 0x01f9 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f9, if 0x55f804b3 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x55f804b3 == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x6352211e 00EB 14 EQ 00EC 61 PUSH2 0x020c 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020c, if 0x6352211e == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x6352211e == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0x70a08231 00F6 14 EQ 00F7 61 PUSH2 0x021f 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021f, if 0x70a08231 == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0x70a08231 == stack[-1] // Inputs[1] { @00FE memory[0x00:0x00] } 00FB 60 PUSH1 0x00 00FD 80 DUP1 00FE FD *REVERT // Stack delta = +0 // Outputs[1] { @00FE revert(memory[0x00:0x00]); } // Block terminates label_00FF: // Incoming jump from 0x00C3, if 0x23b872dd > stack[-1] // Inputs[1] { @0100 stack[-1] } 00FF 5B JUMPDEST 0100 80 DUP1 0101 63 PUSH4 0x01ffc9a7 0106 14 EQ 0107 61 PUSH2 0x013c 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013c, if 0x01ffc9a7 == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x06fdde03 0111 14 EQ 0112 61 PUSH2 0x0164 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0164, if 0x06fdde03 == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0x081812fc 011C 14 EQ 011D 61 PUSH2 0x0179 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0179, if 0x081812fc == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0x081812fc == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0x095ea7b3 0127 14 EQ 0128 61 PUSH2 0x01a4 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a4, if 0x095ea7b3 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @012C stack[-1] } 012C 80 DUP1 012D 63 PUSH4 0x18160ddd 0132 14 EQ 0133 61 PUSH2 0x01b9 0136 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b9, if 0x18160ddd == stack[-1] label_0137: // Incoming jump from 0x0136, if not 0x18160ddd == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @013B memory[0x00:0x00] } 0137 5B JUMPDEST 0138 60 PUSH1 0x00 013A 80 DUP1 013B FD *REVERT // Stack delta = +0 // Outputs[1] { @013B revert(memory[0x00:0x00]); } // Block terminates label_013C: // Incoming jump from 0x010A, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0143 msg.data.length } 013C 5B JUMPDEST 013D 61 PUSH2 0x014f 0140 61 PUSH2 0x014a 0143 36 CALLDATASIZE 0144 60 PUSH1 0x04 0146 61 PUSH2 0x159b 0149 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @013D stack[0] = 0x014f // @0140 stack[1] = 0x014a // @0143 stack[2] = msg.data.length // @0144 stack[3] = 0x04 // } // Block ends with call to 0x159b, returns to 0x014A label_014A: // Incoming return from call to 0x159B at 0x0149 014A 5B JUMPDEST 014B 61 PUSH2 0x0316 014E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0316 label_014F: // Incoming return from call to 0x02D5 at 0x02D4 // Incoming return from call to 0x014A at 0x0149 // Inputs[2] // { // @0152 memory[0x40:0x60] // @0153 stack[-1] // } 014F 5B JUMPDEST 0150 60 PUSH1 0x40 0152 51 MLOAD 0153 90 SWAP1 0154 15 ISZERO 0155 15 ISZERO 0156 81 DUP2 0157 52 MSTORE 0158 60 PUSH1 0x20 015A 01 ADD // Stack delta = +0 // Outputs[2] // { // @0157 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @015A stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_015B: // Incoming jump from 0x01A3 // Incoming jump from 0x01D2 // Incoming jump from 0x01D2 // Incoming return from call to 0x16C8 at 0x026C // Incoming jump from 0x015A // Inputs[3] // { // @015E memory[0x40:0x60] // @0160 stack[-1] // @0163 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 015B 5B JUMPDEST 015C 60 PUSH1 0x40 015E 51 MLOAD 015F 80 DUP1 0160 91 SWAP2 0161 03 SUB 0162 90 SWAP1 0163 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0163 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0164: // Incoming jump from 0x0115, if 0x06fdde03 == stack[-1] 0164 5B JUMPDEST 0165 61 PUSH2 0x016c 0168 61 PUSH2 0x0368 016B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0165 stack[0] = 0x016c } // Block ends with call to 0x0368, returns to 0x016C label_016C: // Incoming return from call to 0x0368 at 0x016B // Incoming return from call to 0x08E1 at 0x02C6 // Incoming return from call to 0x076D at 0x0285 // Inputs[2] // { // @016F memory[0x40:0x60] // @0173 stack[-1] // } 016C 5B JUMPDEST 016D 60 PUSH1 0x40 016F 51 MLOAD 0170 61 PUSH2 0x015b 0173 91 SWAP2 0174 90 SWAP1 0175 61 PUSH2 0x170c 0178 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0173 stack[-1] = 0x015b // @0174 stack[1] = memory[0x40:0x60] // @0174 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x170c label_0179: // Incoming jump from 0x0120, if 0x081812fc == stack[-1] // Inputs[1] { @0180 msg.data.length } 0179 5B JUMPDEST 017A 61 PUSH2 0x018c 017D 61 PUSH2 0x0187 0180 36 CALLDATASIZE 0181 60 PUSH1 0x04 0183 61 PUSH2 0x1618 0186 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @017A stack[0] = 0x018c // @017D stack[1] = 0x0187 // @0180 stack[2] = msg.data.length // @0181 stack[3] = 0x04 // } // Block ends with call to 0x1618, returns to 0x0187 label_0187: // Incoming return from call to 0x1618 at 0x0186 0187 5B JUMPDEST 0188 61 PUSH2 0x03fa 018B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03fa label_018C: // Incoming jump from 0x027D // Incoming return from call to 0x0187 at 0x0186 // Incoming return from call to 0x021A at 0x0219 // Inputs[2] // { // @018F memory[0x40:0x60] // @0199 stack[-1] // } 018C 5B JUMPDEST 018D 60 PUSH1 0x40 018F 51 MLOAD 0190 60 PUSH1 0x01 0192 60 PUSH1 0x01 0194 60 PUSH1 0xa0 0196 1B SHL 0197 03 SUB 0198 90 SWAP1 0199 91 SWAP2 019A 16 AND 019B 81 DUP2 019C 52 MSTORE 019D 60 PUSH1 0x20 019F 01 ADD 01A0 61 PUSH2 0x015b 01A3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @019C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @019F stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x015b label_01A4: // Incoming jump from 0x012B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @01AB msg.data.length } 01A4 5B JUMPDEST 01A5 61 PUSH2 0x01b7 01A8 61 PUSH2 0x01b2 01AB 36 CALLDATASIZE 01AC 60 PUSH1 0x04 01AE 61 PUSH2 0x14b2 01B1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01A5 stack[0] = 0x01b7 // @01A8 stack[1] = 0x01b2 // @01AB stack[2] = msg.data.length // @01AC stack[3] = 0x04 // } // Block ends with call to 0x14b2, returns to 0x01B2 label_01B2: // Incoming return from call to 0x14B2 at 0x01B1 01B2 5B JUMPDEST 01B3 61 PUSH2 0x043e 01B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x043e label_01B7: // Incoming return from call to 0x0248 at 0x0247 // Incoming return from call to 0x0595 at 0x0239 // Incoming return from call to 0x0294 at 0x0293 // Incoming return from call to 0x02A7 at 0x02A6 // Incoming return from call to 0x01B2 at 0x01B1 01B7 5B JUMPDEST 01B8 00 *STOP // Stack delta = +0 // Outputs[1] { @01B8 stop(); } // Block terminates label_01B9: // Incoming jump from 0x0136, if 0x18160ddd == stack[-1] // Inputs[3] // { // @01BC storage[0x01] // @01BF storage[0x00] // @01C8 memory[0x40:0x60] // } 01B9 5B JUMPDEST 01BA 60 PUSH1 0x01 01BC 54 SLOAD 01BD 60 PUSH1 0x00 01BF 54 SLOAD 01C0 03 SUB 01C1 60 PUSH1 0x00 01C3 19 NOT 01C4 01 ADD 01C5 5B JUMPDEST 01C6 60 PUSH1 0x40 01C8 51 MLOAD 01C9 90 SWAP1 01CA 81 DUP2 01CB 52 MSTORE 01CC 60 PUSH1 0x20 01CE 01 ADD 01CF 61 PUSH2 0x015b 01D2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @01CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 + (storage[0x00] - storage[0x01]) // @01CE stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x015b label_01D3: // Incoming jump from 0x00CE, if 0x23b872dd == stack[-1] // Inputs[1] { @01DA msg.data.length } 01D3 5B JUMPDEST 01D4 61 PUSH2 0x01b7 01D7 61 PUSH2 0x01e1 01DA 36 CALLDATASIZE 01DB 60 PUSH1 0x04 01DD 61 PUSH2 0x13c5 01E0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D4 stack[0] = 0x01b7 // @01D7 stack[1] = 0x01e1 // @01DA stack[2] = msg.data.length // @01DB stack[3] = 0x04 // } // Block ends with call to 0x13c5, returns to 0x01E1 label_01E1: // Incoming return from call to 0x13C5 at 0x01E0 01E1 5B JUMPDEST 01E2 61 PUSH2 0x04c5 01E5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04c5 label_01E6: // Incoming jump from 0x00D9, if 0x42842e0e == stack[-1] // Inputs[1] { @01ED msg.data.length } 01E6 5B JUMPDEST 01E7 61 PUSH2 0x01b7 01EA 61 PUSH2 0x01f4 01ED 36 CALLDATASIZE 01EE 60 PUSH1 0x04 01F0 61 PUSH2 0x13c5 01F3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01E7 stack[0] = 0x01b7 // @01EA stack[1] = 0x01f4 // @01ED stack[2] = msg.data.length // @01EE stack[3] = 0x04 // } // Block ends with call to 0x13c5, returns to 0x01F4 label_01F4: // Incoming return from call to 0x13C5 at 0x01F3 01F4 5B JUMPDEST 01F5 61 PUSH2 0x04d0 01F8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04d0 label_01F9: // Incoming jump from 0x00E4, if 0x55f804b3 == stack[-1] // Inputs[1] { @0200 msg.data.length } 01F9 5B JUMPDEST 01FA 61 PUSH2 0x01b7 01FD 61 PUSH2 0x0207 0200 36 CALLDATASIZE 0201 60 PUSH1 0x04 0203 61 PUSH2 0x15d3 0206 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01FA stack[0] = 0x01b7 // @01FD stack[1] = 0x0207 // @0200 stack[2] = msg.data.length // @0201 stack[3] = 0x04 // } // Block ends with call to 0x15d3, returns to 0x0207 label_0207: // Incoming return from call to 0x15D3 at 0x0206 0207 5B JUMPDEST 0208 61 PUSH2 0x04eb 020B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04eb label_020C: // Incoming jump from 0x00EF, if 0x6352211e == stack[-1] // Inputs[1] { @0213 msg.data.length } 020C 5B JUMPDEST 020D 61 PUSH2 0x018c 0210 61 PUSH2 0x021a 0213 36 CALLDATASIZE 0214 60 PUSH1 0x04 0216 61 PUSH2 0x1618 0219 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @020D stack[0] = 0x018c // @0210 stack[1] = 0x021a // @0213 stack[2] = msg.data.length // @0214 stack[3] = 0x04 // } // Block ends with call to 0x1618, returns to 0x021A label_021A: // Incoming return from call to 0x1618 at 0x0219 021A 5B JUMPDEST 021B 61 PUSH2 0x0535 021E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0535 label_021F: // Incoming jump from 0x00FA, if 0x70a08231 == stack[-1] // Inputs[1] { @0226 msg.data.length } 021F 5B JUMPDEST 0220 61 PUSH2 0x01c5 0223 61 PUSH2 0x022d 0226 36 CALLDATASIZE 0227 60 PUSH1 0x04 0229 61 PUSH2 0x1379 022C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0220 stack[0] = 0x01c5 // @0223 stack[1] = 0x022d // @0226 stack[2] = msg.data.length // @0227 stack[3] = 0x04 // } // Block ends with call to 0x1379, returns to 0x022D label_022D: // Incoming return from call to 0x1379 at 0x022C 022D 5B JUMPDEST 022E 61 PUSH2 0x0547 0231 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0547 label_0232: // Incoming jump from 0x0087, if 0x715018a6 == stack[-1] 0232 5B JUMPDEST 0233 61 PUSH2 0x01b7 0236 61 PUSH2 0x0595 0239 56 *JUMP // Stack delta = +1 // Outputs[1] { @0233 stack[0] = 0x01b7 } // Block ends with call to 0x0595, returns to 0x01B7 label_023A: // Incoming jump from 0x0092, if 0x79df1452 == stack[-1] // Inputs[1] { @0241 msg.data.length } 023A 5B JUMPDEST 023B 61 PUSH2 0x01b7 023E 61 PUSH2 0x0248 0241 36 CALLDATASIZE 0242 60 PUSH1 0x04 0244 61 PUSH2 0x14db 0247 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023B stack[0] = 0x01b7 // @023E stack[1] = 0x0248 // @0241 stack[2] = msg.data.length // @0242 stack[3] = 0x04 // } // Block ends with call to 0x14db, returns to 0x0248 label_0248: // Incoming return from call to 0x14DB at 0x0247 0248 5B JUMPDEST 0249 61 PUSH2 0x05cb 024C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05cb label_024D: // Incoming jump from 0x009D, if 0x8462151c == stack[-1] // Inputs[1] { @0254 msg.data.length } 024D 5B JUMPDEST 024E 61 PUSH2 0x0260 0251 61 PUSH2 0x025b 0254 36 CALLDATASIZE 0255 60 PUSH1 0x04 0257 61 PUSH2 0x1379 025A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @024E stack[0] = 0x0260 // @0251 stack[1] = 0x025b // @0254 stack[2] = msg.data.length // @0255 stack[3] = 0x04 // } // Block ends with call to 0x1379, returns to 0x025B label_025B: // Incoming return from call to 0x1379 at 0x025A 025B 5B JUMPDEST 025C 61 PUSH2 0x066b 025F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x066b label_0260: // Incoming return from call to 0x025B at 0x025A // Inputs[2] // { // @0263 memory[0x40:0x60] // @0267 stack[-1] // } 0260 5B JUMPDEST 0261 60 PUSH1 0x40 0263 51 MLOAD 0264 61 PUSH2 0x015b 0267 91 SWAP2 0268 90 SWAP1 0269 61 PUSH2 0x16c8 026C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0267 stack[-1] = 0x015b // @0268 stack[1] = memory[0x40:0x60] // @0268 stack[0] = stack[-1] // } // Block ends with call to 0x16c8, returns to 0x015B label_026D: // Incoming jump from 0x00A8, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0270 storage[0x08] } 026D 5B JUMPDEST 026E 60 PUSH1 0x08 0270 54 SLOAD 0271 60 PUSH1 0x01 0273 60 PUSH1 0x01 0275 60 PUSH1 0xa0 0277 1B SHL 0278 03 SUB 0279 16 AND 027A 61 PUSH2 0x018c 027D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0279 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x018c label_027E: // Incoming jump from 0x00B3, if 0x95d89b41 == stack[-1] 027E 5B JUMPDEST 027F 61 PUSH2 0x016c 0282 61 PUSH2 0x076d 0285 56 *JUMP // Stack delta = +1 // Outputs[1] { @027F stack[0] = 0x016c } // Block ends with call to 0x076d, returns to 0x016C label_0286: // Incoming jump from 0x0040, if 0xa22cb465 == stack[-1] // Inputs[1] { @028D msg.data.length } 0286 5B JUMPDEST 0287 61 PUSH2 0x01b7 028A 61 PUSH2 0x0294 028D 36 CALLDATASIZE 028E 60 PUSH1 0x04 0290 61 PUSH2 0x1478 0293 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0287 stack[0] = 0x01b7 // @028A stack[1] = 0x0294 // @028D stack[2] = msg.data.length // @028E stack[3] = 0x04 // } // Block ends with call to 0x1478, returns to 0x0294 label_0294: // Incoming return from call to 0x1478 at 0x0293 0294 5B JUMPDEST 0295 61 PUSH2 0x077c 0298 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x077c label_0299: // Incoming jump from 0x004B, if 0xb88d4fde == stack[-1] // Inputs[1] { @02A0 msg.data.length } 0299 5B JUMPDEST 029A 61 PUSH2 0x01b7 029D 61 PUSH2 0x02a7 02A0 36 CALLDATASIZE 02A1 60 PUSH1 0x04 02A3 61 PUSH2 0x1400 02A6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @029A stack[0] = 0x01b7 // @029D stack[1] = 0x02a7 // @02A0 stack[2] = msg.data.length // @02A1 stack[3] = 0x04 // } // Block ends with call to 0x1400, returns to 0x02A7 label_02A7: // Incoming return from call to 0x1400 at 0x02A6 02A7 5B JUMPDEST 02A8 61 PUSH2 0x0812 02AB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0812 label_02AC: // Incoming jump from 0x0056, if 0xc87b56dd == stack[-1] // Inputs[1] { @02B3 msg.data.length } 02AC 5B JUMPDEST 02AD 61 PUSH2 0x016c 02B0 61 PUSH2 0x02ba 02B3 36 CALLDATASIZE 02B4 60 PUSH1 0x04 02B6 61 PUSH2 0x1618 02B9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AD stack[0] = 0x016c // @02B0 stack[1] = 0x02ba // @02B3 stack[2] = msg.data.length // @02B4 stack[3] = 0x04 // } // Block ends with call to 0x1618, returns to 0x02BA label_02BA: // Incoming return from call to 0x1618 at 0x02B9 02BA 5B JUMPDEST 02BB 61 PUSH2 0x085c 02BE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x085c label_02BF: // Incoming jump from 0x0061, if 0xd547cfb7 == stack[-1] 02BF 5B JUMPDEST 02C0 61 PUSH2 0x016c 02C3 61 PUSH2 0x08e1 02C6 56 *JUMP // Stack delta = +1 // Outputs[1] { @02C0 stack[0] = 0x016c } // Block ends with call to 0x08e1, returns to 0x016C label_02C7: // Incoming jump from 0x006C, if 0xe985e9c5 == stack[-1] // Inputs[1] { @02CE msg.data.length } 02C7 5B JUMPDEST 02C8 61 PUSH2 0x014f 02CB 61 PUSH2 0x02d5 02CE 36 CALLDATASIZE 02CF 60 PUSH1 0x04 02D1 61 PUSH2 0x1393 02D4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02C8 stack[0] = 0x014f // @02CB stack[1] = 0x02d5 // @02CE stack[2] = msg.data.length // @02CF stack[3] = 0x04 // } // Block ends with call to 0x1393, returns to 0x02D5 label_02D5: // Incoming call from 0x0497, returns to 0x0498 // Incoming return from call to 0x1393 at 0x02D4 // Incoming call from 0x0AFE, returns to 0x0AFF // Inputs[6] // { // @02DE stack[-2] // @02F1 memory[0x00:0x40] // @02F2 stack[-1] // @02FC memory[0x00:0x40] // @02FD storage[keccak256(memory[0x00:0x40])] // @0301 stack[-3] // } 02D5 5B JUMPDEST 02D6 60 PUSH1 0x01 02D8 60 PUSH1 0x01 02DA 60 PUSH1 0xa0 02DC 1B SHL 02DD 03 SUB 02DE 91 SWAP2 02DF 82 DUP3 02E0 16 AND 02E1 60 PUSH1 0x00 02E3 90 SWAP1 02E4 81 DUP2 02E5 52 MSTORE 02E6 60 PUSH1 0x07 02E8 60 PUSH1 0x20 02EA 90 SWAP1 02EB 81 DUP2 02EC 52 MSTORE 02ED 60 PUSH1 0x40 02EF 80 DUP1 02F0 83 DUP4 02F1 20 SHA3 02F2 93 SWAP4 02F3 90 SWAP1 02F4 94 SWAP5 02F5 16 AND 02F6 82 DUP3 02F7 52 MSTORE 02F8 91 SWAP2 02F9 90 SWAP1 02FA 91 SWAP2 02FB 52 MSTORE 02FC 20 SHA3 02FD 54 SLOAD 02FE 60 PUSH1 0xff 0300 16 AND 0301 90 SWAP1 0302 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @02E5 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @02EC memory[0x20:0x40] = 0x07 // @02F7 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @02FB memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0301 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0303: // Incoming jump from 0x0077, if 0xf2fde38b == stack[-1] // Inputs[1] { @030A msg.data.length } 0303 5B JUMPDEST 0304 61 PUSH2 0x01b7 0307 61 PUSH2 0x0311 030A 36 CALLDATASIZE 030B 60 PUSH1 0x04 030D 61 PUSH2 0x1379 0310 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0304 stack[0] = 0x01b7 // @0307 stack[1] = 0x0311 // @030A stack[2] = msg.data.length // @030B stack[3] = 0x04 // } // Block ends with call to 0x1379, returns to 0x0311 label_0311: // Incoming return from call to 0x1379 at 0x0310 0311 5B JUMPDEST 0312 61 PUSH2 0x096f 0315 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x096f label_0316: // Incoming jump from 0x014E // Inputs[1] { @0322 stack[-1] } 0316 5B JUMPDEST 0317 60 PUSH1 0x00 0319 60 PUSH1 0x01 031B 60 PUSH1 0x01 031D 60 PUSH1 0xe0 031F 1B SHL 0320 03 SUB 0321 19 NOT 0322 82 DUP3 0323 16 AND 0324 63 PUSH4 0x80ac58cd 0329 60 PUSH1 0xe0 032B 1B SHL 032C 14 EQ 032D 80 DUP1 032E 61 PUSH2 0x0347 0331 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0317 stack[0] = 0x00 // @032C stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0347, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0332: // Incoming jump from 0x0331, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @033C stack[-3] } 0332 50 POP 0333 60 PUSH1 0x01 0335 60 PUSH1 0x01 0337 60 PUSH1 0xe0 0339 1B SHL 033A 03 SUB 033B 19 NOT 033C 82 DUP3 033D 16 AND 033E 63 PUSH4 0x5b5e139f 0343 60 PUSH1 0xe0 0345 1B SHL 0346 14 EQ 0347 5B JUMPDEST 0348 80 DUP1 0349 61 PUSH2 0x0362 034C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0346 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0362, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_034D: // Incoming jump from 0x034C, if not stack[-1] // Incoming jump from 0x034C, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @035F stack[-3] } 034D 50 POP 034E 63 PUSH4 0x01ffc9a7 0353 60 PUSH1 0xe0 0355 1B SHL 0356 60 PUSH1 0x01 0358 60 PUSH1 0x01 035A 60 PUSH1 0xe0 035C 1B SHL 035D 03 SUB 035E 19 NOT 035F 83 DUP4 0360 16 AND 0361 14 EQ // Stack delta = +0 // Outputs[1] { @0361 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_0362: // Incoming jump from 0x0361 // Incoming jump from 0x0A24, if !stack[-1] // Incoming jump from 0x034C, if stack[-1] // Incoming jump from 0x0A24, if !(stack[-3] < storage[0x00]) // Incoming jump from 0x034C, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[3] // { // @0363 stack[-4] // @0363 stack[-1] // @0364 stack[-3] // } 0362 5B JUMPDEST 0363 92 SWAP3 0364 91 SWAP2 0365 50 POP 0366 50 POP 0367 56 *JUMP // Stack delta = -3 // Outputs[1] { @0363 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0368: // Incoming call from 0x016B, returns to 0x016C // Inputs[1] { @036E storage[0x02] } 0368 5B JUMPDEST 0369 60 PUSH1 0x60 036B 60 PUSH1 0x02 036D 80 DUP1 036E 54 SLOAD 036F 61 PUSH2 0x0377 0372 90 SWAP1 0373 61 PUSH2 0x1816 0376 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0369 stack[0] = 0x60 // @036B stack[1] = 0x02 // @0372 stack[2] = 0x0377 // @0372 stack[3] = storage[0x02] // } // Block ends with call to 0x1816, returns to 0x0377 label_0377: // Incoming return from call to 0x1816 at 0x077B // Incoming return from call to 0x1816 at 0x0F20 // Incoming return from call to 0x1816 at 0x0376 // Inputs[4] // { // @0378 stack[-1] // @0387 memory[0x40:0x60] // @038F stack[-2] // @039A storage[stack[-2]] // } 0377 5B JUMPDEST 0378 80 DUP1 0379 60 PUSH1 0x1f 037B 01 ADD 037C 60 PUSH1 0x20 037E 80 DUP1 037F 91 SWAP2 0380 04 DIV 0381 02 MUL 0382 60 PUSH1 0x20 0384 01 ADD 0385 60 PUSH1 0x40 0387 51 MLOAD 0388 90 SWAP1 0389 81 DUP2 038A 01 ADD 038B 60 PUSH1 0x40 038D 52 MSTORE 038E 80 DUP1 038F 92 SWAP3 0390 91 SWAP2 0391 90 SWAP1 0392 81 DUP2 0393 81 DUP2 0394 52 MSTORE 0395 60 PUSH1 0x20 0397 01 ADD 0398 82 DUP3 0399 80 DUP1 039A 54 SLOAD 039B 61 PUSH2 0x03a3 039E 90 SWAP1 039F 61 PUSH2 0x1816 03A2 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @038D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @038F stack[-2] = memory[0x40:0x60] // @0390 stack[-1] = stack[-2] // @0391 stack[0] = stack[-1] // @0394 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0397 stack[1] = 0x20 + memory[0x40:0x60] // @0398 stack[2] = stack[-2] // @039E stack[4] = storage[stack[-2]] // @039E stack[3] = 0x03a3 // } // Block ends with call to 0x1816, returns to 0x03A3 label_03A3: // Incoming return from call to 0x1816 at 0x03A2 // Inputs[1] { @03A4 stack[-1] } 03A3 5B JUMPDEST 03A4 80 DUP1 03A5 15 ISZERO 03A6 61 PUSH2 0x03f0 03A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f0, if !stack[-1] label_03AA: // Incoming jump from 0x03A9, if not !stack[-1] // Inputs[1] { @03AA stack[-1] } 03AA 80 DUP1 03AB 60 PUSH1 0x1f 03AD 10 LT 03AE 61 PUSH2 0x03c5 03B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c5, if 0x1f < stack[-1] label_03B2: // Incoming jump from 0x03B1, if not 0x1f < stack[-1] // Inputs[4] // { // @03B6 stack[-2] // @03B7 storage[stack[-2]] // @03BA stack[-3] // @03BC stack[-1] // } 03B2 61 PUSH2 0x0100 03B5 80 DUP1 03B6 83 DUP4 03B7 54 SLOAD 03B8 04 DIV 03B9 02 MUL 03BA 83 DUP4 03BB 52 MSTORE 03BC 91 SWAP2 03BD 60 PUSH1 0x20 03BF 01 ADD 03C0 91 SWAP2 03C1 61 PUSH2 0x03f0 03C4 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @03BB memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @03C0 stack[-1] = stack[-1] // @03C0 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x03f0 label_03C5: // Incoming jump from 0x03B1, if 0x1f < stack[-1] // Inputs[5] // { // @03C6 stack[-3] // @03C7 stack[-1] // @03C9 stack[-2] // @03D1 memory[0x00:0x20] // @03D5 storage[keccak256(memory[0x00:0x20])] // } 03C5 5B JUMPDEST 03C6 82 DUP3 03C7 01 ADD 03C8 91 SWAP2 03C9 90 SWAP1 03CA 60 PUSH1 0x00 03CC 52 MSTORE 03CD 60 PUSH1 0x20 03CF 60 PUSH1 0x00 03D1 20 SHA3 03D2 90 SWAP1 03D3 5B JUMPDEST 03D4 81 DUP2 03D5 54 SLOAD 03D6 81 DUP2 03D7 52 MSTORE 03D8 90 SWAP1 03D9 60 PUSH1 0x01 03DB 01 ADD 03DC 90 SWAP1 03DD 60 PUSH1 0x20 03DF 01 ADD 03E0 80 DUP1 03E1 83 DUP4 03E2 11 GT 03E3 61 PUSH2 0x03d3 03E6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @03C8 stack[-3] = stack[-3] + stack[-1] // @03CC memory[0x00:0x20] = stack[-2] // @03D7 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @03DC stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @03DF stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x03d3, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_03E7: // Incoming jump from 0x03E6, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x03E6, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @03E7 stack[-3] // @03E8 stack[-1] // } 03E7 82 DUP3 03E8 90 SWAP1 03E9 03 SUB 03EA 60 PUSH1 0x1f 03EC 16 AND 03ED 82 DUP3 03EE 01 ADD 03EF 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @03EF stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @03EF stack[-1] = stack[-3] // } // Block continues label_03F0: // Incoming jump from 0x03C4 // Incoming jump from 0x03EF // Incoming jump from 0x03A9, if !stack[-1] // Inputs[3] // { // @03F6 stack[-6] // @03F6 stack[-7] // @03F8 stack[-8] // } 03F0 5B JUMPDEST 03F1 50 POP 03F2 50 POP 03F3 50 POP 03F4 50 POP 03F5 50 POP 03F6 90 SWAP1 03F7 50 POP 03F8 90 SWAP1 03F9 56 *JUMP // Stack delta = -7 // Outputs[1] { @03F8 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_03FA: // Incoming jump from 0x018B // Incoming call from 0x0B0E, returns to 0x0B0F // Inputs[1] { @0400 stack[-1] } 03FA 5B JUMPDEST 03FB 60 PUSH1 0x00 03FD 61 PUSH2 0x0405 0400 82 DUP3 0401 61 PUSH2 0x0a0a 0404 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @03FB stack[0] = 0x00 // @03FD stack[1] = 0x0405 // @0400 stack[2] = stack[-1] // } // Block ends with call to 0x0a0a, returns to 0x0405 label_0405: // Incoming return from call to 0x0A0A at 0x0404 // Inputs[1] { @0409 stack[-1] } 0405 5B JUMPDEST 0406 61 PUSH2 0x0422 0409 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0422, if stack[-1] label_040A: // Incoming jump from 0x0409, if not stack[-1] // Inputs[3] // { // @040C memory[0x40:0x60] // @041C memory[0x40:0x60] // @0421 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 040A 60 PUSH1 0x40 040C 51 MLOAD 040D 63 PUSH4 0x33d1c039 0412 60 PUSH1 0xe2 0414 1B SHL 0415 81 DUP2 0416 52 MSTORE 0417 60 PUSH1 0x04 0419 01 ADD 041A 60 PUSH1 0x40 041C 51 MLOAD 041D 80 DUP1 041E 91 SWAP2 041F 03 SUB 0420 90 SWAP1 0421 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0416 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @0421 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0422: // Incoming jump from 0x0409, if stack[-1] // Inputs[4] // { // @0426 stack[-2] // @0431 memory[0x00:0x40] // @0432 storage[keccak256(memory[0x00:0x40])] // @043C stack[-3] // } 0422 5B JUMPDEST 0423 50 POP 0424 60 PUSH1 0x00 0426 90 SWAP1 0427 81 DUP2 0428 52 MSTORE 0429 60 PUSH1 0x06 042B 60 PUSH1 0x20 042D 52 MSTORE 042E 60 PUSH1 0x40 0430 90 SWAP1 0431 20 SHA3 0432 54 SLOAD 0433 60 PUSH1 0x01 0435 60 PUSH1 0x01 0437 60 PUSH1 0xa0 0439 1B SHL 043A 03 SUB 043B 16 AND 043C 90 SWAP1 043D 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0428 memory[0x00:0x20] = stack[-2] // @042D memory[0x20:0x40] = 0x06 // @043C stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_043E: // Incoming jump from 0x01B6 // Inputs[1] { @0444 stack[-1] } 043E 5B JUMPDEST 043F 60 PUSH1 0x00 0441 61 PUSH2 0x0449 0444 82 DUP3 0445 61 PUSH2 0x0535 0448 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @043F stack[0] = 0x00 // @0441 stack[1] = 0x0449 // @0444 stack[2] = stack[-1] // } // Block ends with call to 0x0535, returns to 0x0449 label_0449: // Incoming return from call to 0x0535 at 0x0448 // Inputs[3] // { // @044A stack[-1] // @044A stack[-2] // @0456 stack[-4] // } 0449 5B JUMPDEST 044A 90 SWAP1 044B 50 POP 044C 80 DUP1 044D 60 PUSH1 0x01 044F 60 PUSH1 0x01 0451 60 PUSH1 0xa0 0453 1B SHL 0454 03 SUB 0455 16 AND 0456 83 DUP4 0457 60 PUSH1 0x01 0459 60 PUSH1 0x01 045B 60 PUSH1 0xa0 045D 1B SHL 045E 03 SUB 045F 16 AND 0460 14 EQ 0461 15 ISZERO 0462 61 PUSH2 0x047e 0465 57 *JUMPI // Stack delta = -1 // Outputs[1] { @044A stack[-2] = stack[-1] } // Block ends with conditional jump to 0x047e, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0466: // Incoming jump from 0x0465, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @0468 memory[0x40:0x60] // @0478 memory[0x40:0x60] // @047D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0466 60 PUSH1 0x40 0468 51 MLOAD 0469 63 PUSH4 0x250fdee3 046E 60 PUSH1 0xe2 0470 1B SHL 0471 81 DUP2 0472 52 MSTORE 0473 60 PUSH1 0x04 0475 01 ADD 0476 60 PUSH1 0x40 0478 51 MLOAD 0479 80 DUP1 047A 91 SWAP2 047B 03 SUB 047C 90 SWAP1 047D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0472 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @047D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_047E: // Incoming jump from 0x0465, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @047F msg.sender // @0488 stack[-1] // } 047E 5B JUMPDEST 047F 33 CALLER 0480 60 PUSH1 0x01 0482 60 PUSH1 0x01 0484 60 PUSH1 0xa0 0486 1B SHL 0487 03 SUB 0488 82 DUP3 0489 16 AND 048A 14 EQ 048B 61 PUSH2 0x04b5 048E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b5, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_048F: // Incoming jump from 0x048E, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0492 stack[-1] // @0493 msg.sender // } 048F 61 PUSH2 0x0498 0492 81 DUP2 0493 33 CALLER 0494 61 PUSH2 0x02d5 0497 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @048F stack[0] = 0x0498 // @0492 stack[1] = stack[-1] // @0493 stack[2] = msg.sender // } // Block ends with call to 0x02d5, returns to 0x0498 label_0498: // Incoming return from call to 0x02D5 at 0x0497 // Inputs[1] { @049C stack[-1] } 0498 5B JUMPDEST 0499 61 PUSH2 0x04b5 049C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x04b5, if stack[-1] label_049D: // Incoming jump from 0x049C, if not stack[-1] // Inputs[3] // { // @049F memory[0x40:0x60] // @04AF memory[0x40:0x60] // @04B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 049D 60 PUSH1 0x40 049F 51 MLOAD 04A0 63 PUSH4 0x67d9dca1 04A5 60 PUSH1 0xe1 04A7 1B SHL 04A8 81 DUP2 04A9 52 MSTORE 04AA 60 PUSH1 0x04 04AC 01 ADD 04AD 60 PUSH1 0x40 04AF 51 MLOAD 04B0 80 DUP1 04B1 91 SWAP2 04B2 03 SUB 04B3 90 SWAP1 04B4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @04A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @04B4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_04B5: // Incoming jump from 0x049C, if stack[-1] // Incoming jump from 0x048E, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[3] // { // @04B9 stack[-3] // @04BA stack[-2] // @04BB stack[-1] // } 04B5 5B JUMPDEST 04B6 61 PUSH2 0x04c0 04B9 83 DUP4 04BA 83 DUP4 04BB 83 DUP4 04BC 61 PUSH2 0x0a43 04BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04B6 stack[0] = 0x04c0 // @04B9 stack[1] = stack[-3] // @04BA stack[2] = stack[-2] // @04BB stack[3] = stack[-1] // } // Block ends with call to 0x0a43, returns to 0x04C0 label_04C0: // Incoming jump from 0x0601, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming return from call to 0x0812 at 0x04EA // Incoming return from call to 0x0A9F at 0x04CF // Incoming return from call to 0x0A43 at 0x04BF // Inputs[1] { @04C4 stack[-4] } 04C0 5B JUMPDEST 04C1 50 POP 04C2 50 POP 04C3 50 POP 04C4 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_04C5: // Incoming jump from 0x01E5 // Inputs[3] // { // @04C9 stack[-3] // @04CA stack[-2] // @04CB stack[-1] // } 04C5 5B JUMPDEST 04C6 61 PUSH2 0x04c0 04C9 83 DUP4 04CA 83 DUP4 04CB 83 DUP4 04CC 61 PUSH2 0x0a9f 04CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04C6 stack[0] = 0x04c0 // @04C9 stack[1] = stack[-3] // @04CA stack[2] = stack[-2] // @04CB stack[3] = stack[-1] // } // Block ends with call to 0x0a9f, returns to 0x04C0 label_04D0: // Incoming jump from 0x01F8 // Inputs[4] // { // @04D4 stack[-3] // @04D5 stack[-2] // @04D6 stack[-1] // @04D9 memory[0x40:0x60] // } 04D0 5B JUMPDEST 04D1 61 PUSH2 0x04c0 04D4 83 DUP4 04D5 83 DUP4 04D6 83 DUP4 04D7 60 PUSH1 0x40 04D9 51 MLOAD 04DA 80 DUP1 04DB 60 PUSH1 0x20 04DD 01 ADD 04DE 60 PUSH1 0x40 04E0 52 MSTORE 04E1 80 DUP1 04E2 60 PUSH1 0x00 04E4 81 DUP2 04E5 52 MSTORE 04E6 50 POP 04E7 61 PUSH2 0x0812 04EA 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @04D1 stack[0] = 0x04c0 // @04D4 stack[1] = stack[-3] // @04D5 stack[2] = stack[-2] // @04D6 stack[3] = stack[-1] // @04D9 stack[4] = memory[0x40:0x60] // @04E0 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @04E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x0812, returns to 0x04C0 label_04EB: // Incoming jump from 0x020B // Inputs[2] // { // @04EE storage[0x08] // @04F8 msg.sender // } 04EB 5B JUMPDEST 04EC 60 PUSH1 0x08 04EE 54 SLOAD 04EF 60 PUSH1 0x01 04F1 60 PUSH1 0x01 04F3 60 PUSH1 0xa0 04F5 1B SHL 04F6 03 SUB 04F7 16 AND 04F8 33 CALLER 04F9 14 EQ 04FA 61 PUSH2 0x051e 04FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_04FE: // Incoming jump from 0x04FD, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0500 memory[0x40:0x60] } 04FE 60 PUSH1 0x40 0500 51 MLOAD 0501 62 PUSH3 0x461bcd 0505 60 PUSH1 0xe5 0507 1B SHL 0508 81 DUP2 0509 52 MSTORE 050A 60 PUSH1 0x04 050C 01 ADD 050D 61 PUSH2 0x0515 0510 90 SWAP1 0511 61 PUSH2 0x171f 0514 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0509 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0510 stack[0] = 0x0515 // @0510 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x171f, returns to 0x0515 label_0515: // Incoming return from call to 0x171F at 0x0998 // Incoming return from call to 0x171F at 0x05F4 // Incoming return from call to 0x171F at 0x05BE // Incoming jump from 0x09FD // Incoming return from call to 0x171F at 0x0514 // Inputs[3] // { // @0518 memory[0x40:0x60] // @051A stack[-1] // @051D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0515 5B JUMPDEST 0516 60 PUSH1 0x40 0518 51 MLOAD 0519 80 DUP1 051A 91 SWAP2 051B 03 SUB 051C 90 SWAP1 051D FD *REVERT // Stack delta = -1 // Outputs[1] { @051D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_051E: // Incoming jump from 0x04FD, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @051F stack[-1] // @0520 memory[stack[-1]:stack[-1] + 0x20] // } 051E 5B JUMPDEST 051F 80 DUP1 0520 51 MLOAD 0521 61 PUSH2 0x0531 0524 90 SWAP1 0525 60 PUSH1 0x09 0527 90 SWAP1 0528 60 PUSH1 0x20 052A 84 DUP5 052B 01 ADD 052C 90 SWAP1 052D 61 PUSH2 0x11fe 0530 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0524 stack[0] = 0x0531 // @0527 stack[1] = 0x09 // @052C stack[2] = stack[-1] + 0x20 // @052C stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x11fe 0531 5B JUMPDEST 0532 50 POP 0533 50 POP 0534 56 *JUMP label_0535: // Incoming jump from 0x021E // Incoming call from 0x06F8, returns to 0x06F9 // Incoming call from 0x0448, returns to 0x0449 // Inputs[1] { @053B stack[-1] } 0535 5B JUMPDEST 0536 60 PUSH1 0x00 0538 61 PUSH2 0x0540 053B 82 DUP3 053C 61 PUSH2 0x0c8c 053F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0536 stack[0] = 0x00 // @0538 stack[1] = 0x0540 // @053B stack[2] = stack[-1] // } // Block ends with call to 0x0c8c, returns to 0x0540 label_0540: // Incoming return from call to 0x0C8C at 0x053F // Inputs[4] // { // @0541 memory[stack[-1]:stack[-1] + 0x20] // @0541 stack[-1] // @0542 stack[-4] // @0543 stack[-3] // } 0540 5B JUMPDEST 0541 51 MLOAD 0542 92 SWAP3 0543 91 SWAP2 0544 50 POP 0545 50 POP 0546 56 *JUMP // Stack delta = -3 // Outputs[1] { @0542 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0547: // Incoming call from 0x0684, returns to 0x0685 // Incoming jump from 0x0231 // Inputs[1] { @0552 stack[-1] } 0547 5B JUMPDEST 0548 60 PUSH1 0x00 054A 60 PUSH1 0x01 054C 60 PUSH1 0x01 054E 60 PUSH1 0xa0 0550 1B SHL 0551 03 SUB 0552 82 DUP3 0553 16 AND 0554 61 PUSH2 0x0570 0557 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0548 stack[0] = 0x00 } // Block ends with conditional jump to 0x0570, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0558: // Incoming jump from 0x0557, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @055A memory[0x40:0x60] // @056A memory[0x40:0x60] // @056F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0558 60 PUSH1 0x40 055A 51 MLOAD 055B 63 PUSH4 0x23d3ad81 0560 60 PUSH1 0xe2 0562 1B SHL 0563 81 DUP2 0564 52 MSTORE 0565 60 PUSH1 0x04 0567 01 ADD 0568 60 PUSH1 0x40 056A 51 MLOAD 056B 80 DUP1 056C 91 SWAP2 056D 03 SUB 056E 90 SWAP1 056F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0564 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @056F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0570: // Incoming jump from 0x0557, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @057A stack[-2] // @0588 memory[0x00:0x40] // @0589 storage[keccak256(memory[0x00:0x40])] // @0593 stack[-3] // } 0570 5B JUMPDEST 0571 50 POP 0572 60 PUSH1 0x01 0574 60 PUSH1 0x01 0576 60 PUSH1 0xa0 0578 1B SHL 0579 03 SUB 057A 16 AND 057B 60 PUSH1 0x00 057D 90 SWAP1 057E 81 DUP2 057F 52 MSTORE 0580 60 PUSH1 0x05 0582 60 PUSH1 0x20 0584 52 MSTORE 0585 60 PUSH1 0x40 0587 90 SWAP1 0588 20 SHA3 0589 54 SLOAD 058A 60 PUSH1 0x01 058C 60 PUSH1 0x01 058E 60 PUSH1 0x40 0590 1B SHL 0591 03 SUB 0592 16 AND 0593 90 SWAP1 0594 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @057F memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0584 memory[0x20:0x40] = 0x05 // @0593 stack[-3] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0595: // Incoming call from 0x0239, returns to 0x01B7 // Inputs[2] // { // @0598 storage[0x08] // @05A2 msg.sender // } 0595 5B JUMPDEST 0596 60 PUSH1 0x08 0598 54 SLOAD 0599 60 PUSH1 0x01 059B 60 PUSH1 0x01 059D 60 PUSH1 0xa0 059F 1B SHL 05A0 03 SUB 05A1 16 AND 05A2 33 CALLER 05A3 14 EQ 05A4 61 PUSH2 0x05bf 05A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bf, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_05A8: // Incoming jump from 0x05A7, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @05AA memory[0x40:0x60] } 05A8 60 PUSH1 0x40 05AA 51 MLOAD 05AB 62 PUSH3 0x461bcd 05AF 60 PUSH1 0xe5 05B1 1B SHL 05B2 81 DUP2 05B3 52 MSTORE 05B4 60 PUSH1 0x04 05B6 01 ADD 05B7 61 PUSH2 0x0515 05BA 90 SWAP1 05BB 61 PUSH2 0x171f 05BE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05BA stack[0] = 0x0515 // @05BA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x171f, returns to 0x0515 label_05BF: // Incoming jump from 0x05A7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 05BF 5B JUMPDEST 05C0 61 PUSH2 0x05c9 05C3 60 PUSH1 0x00 05C5 61 PUSH2 0x0dae 05C8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @05C0 stack[0] = 0x05c9 // @05C3 stack[1] = 0x00 // } // Block ends with call to 0x0dae, returns to 0x05C9 label_05C9: // Incoming return from call to 0x0DAE at 0x05C8 // Inputs[1] { @05CA stack[-1] } 05C9 5B JUMPDEST 05CA 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_05CB: // Incoming jump from 0x024C // Inputs[2] // { // @05CE storage[0x08] // @05D8 msg.sender // } 05CB 5B JUMPDEST 05CC 60 PUSH1 0x08 05CE 54 SLOAD 05CF 60 PUSH1 0x01 05D1 60 PUSH1 0x01 05D3 60 PUSH1 0xa0 05D5 1B SHL 05D6 03 SUB 05D7 16 AND 05D8 33 CALLER 05D9 14 EQ 05DA 61 PUSH2 0x05f5 05DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_05DE: // Incoming jump from 0x05DD, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @05E0 memory[0x40:0x60] } 05DE 60 PUSH1 0x40 05E0 51 MLOAD 05E1 62 PUSH3 0x461bcd 05E5 60 PUSH1 0xe5 05E7 1B SHL 05E8 81 DUP2 05E9 52 MSTORE 05EA 60 PUSH1 0x04 05EC 01 ADD 05ED 61 PUSH2 0x0515 05F0 90 SWAP1 05F1 61 PUSH2 0x171f 05F4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05F0 stack[0] = 0x0515 // @05F0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x171f, returns to 0x0515 label_05F5: // Incoming jump from 0x05DD, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @05F9 stack[-2] // @05FA memory[stack[-2]:stack[-2] + 0x20] // } 05F5 5B JUMPDEST 05F6 60 PUSH1 0x00 05F8 5B JUMPDEST 05F9 82 DUP3 05FA 51 MLOAD 05FB 81 DUP2 05FC 10 LT 05FD 15 ISZERO 05FE 61 PUSH2 0x04c0 0601 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F6 stack[0] = 0x00 } // Block ends with conditional jump to 0x04c0, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0602: // Incoming jump from 0x0601, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @0605 stack[-3] // @0606 stack[-1] // @0608 memory[stack[-3]:stack[-3] + 0x20] // } 0602 61 PUSH2 0x0659 0605 83 DUP4 0606 82 DUP3 0607 81 DUP2 0608 51 MLOAD 0609 81 DUP2 060A 10 LT 060B 61 PUSH2 0x0624 060E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0602 stack[0] = 0x0659 // @0605 stack[1] = stack[-3] // @0606 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0624, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_060F: // Incoming jump from 0x060E, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[1] { @0623 memory[0x00:0x24] } 060F 63 PUSH4 0x4e487b71 0614 60 PUSH1 0xe0 0616 1B SHL 0617 60 PUSH1 0x00 0619 52 MSTORE 061A 60 PUSH1 0x32 061C 60 PUSH1 0x04 061E 52 MSTORE 061F 60 PUSH1 0x24 0621 60 PUSH1 0x00 0623 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0619 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @061E memory[0x04:0x24] = 0x32 // @0623 revert(memory[0x00:0x24]); // } // Block terminates label_0624: // Incoming jump from 0x060E, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @0627 stack[-1] // @062B stack[-2] // @062C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @062D stack[-5] // @062E stack[-4] // @0630 memory[stack[-5]:stack[-5] + 0x20] // } 0624 5B JUMPDEST 0625 60 PUSH1 0x20 0627 02 MUL 0628 60 PUSH1 0x20 062A 01 ADD 062B 01 ADD 062C 51 MLOAD 062D 83 DUP4 062E 83 DUP4 062F 81 DUP2 0630 51 MLOAD 0631 81 DUP2 0632 10 LT 0633 61 PUSH2 0x064c 0636 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @062C stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @062D stack[-1] = stack[-5] // @062E stack[0] = stack[-4] // } // Block ends with conditional jump to 0x064c, if stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_0637: // Incoming jump from 0x0636, if not stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[1] { @064B memory[0x00:0x24] } 0637 63 PUSH4 0x4e487b71 063C 60 PUSH1 0xe0 063E 1B SHL 063F 60 PUSH1 0x00 0641 52 MSTORE 0642 60 PUSH1 0x32 0644 60 PUSH1 0x04 0646 52 MSTORE 0647 60 PUSH1 0x24 0649 60 PUSH1 0x00 064B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0641 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0646 memory[0x04:0x24] = 0x32 // @064B revert(memory[0x00:0x24]); // } // Block terminates label_064C: // Incoming jump from 0x0636, if stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @064F stack[-1] // @0653 stack[-2] // @0654 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 064C 5B JUMPDEST 064D 60 PUSH1 0x20 064F 02 MUL 0650 60 PUSH1 0x20 0652 01 ADD 0653 01 ADD 0654 51 MLOAD 0655 61 PUSH2 0x0e00 0658 56 *JUMP // Stack delta = -1 // Outputs[1] { @0654 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0e00 0659 5B JUMPDEST 065A 80 DUP1 065B 61 PUSH2 0x0663 065E 81 DUP2 065F 61 PUSH2 0x1851 0662 56 *JUMP 0663 5B JUMPDEST 0664 91 SWAP2 0665 50 POP 0666 50 POP 0667 61 PUSH2 0x05f8 066A 56 *JUMP label_066B: // Incoming jump from 0x025F // Inputs[3] // { // @066E storage[0x01] // @0672 storage[0x00] // @0680 stack[-1] // } 066B 5B JUMPDEST 066C 60 PUSH1 0x01 066E 54 SLOAD 066F 60 PUSH1 0x00 0671 80 DUP1 0672 54 SLOAD 0673 60 PUSH1 0x60 0675 92 SWAP3 0676 60 PUSH1 0x00 0678 19 NOT 0679 91 SWAP2 067A 03 SUB 067B 01 ADD 067C 90 SWAP1 067D 61 PUSH2 0x0685 0680 84 DUP5 0681 61 PUSH2 0x0547 0684 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0675 stack[0] = 0x60 // @067C stack[1] = storage[0x00] - storage[0x01] + ~0x00 // @067C stack[2] = 0x00 // @067D stack[3] = 0x0685 // @0680 stack[4] = stack[-1] // } // Block ends with call to 0x0547, returns to 0x0685 label_0685: // Incoming return from call to 0x0547 at 0x0684 // Inputs[2] // { // @0686 stack[-1] // @0686 stack[-2] // } 0685 5B JUMPDEST 0686 90 SWAP1 0687 50 POP 0688 60 PUSH1 0x00 068A 81 DUP2 068B 60 PUSH1 0x01 068D 60 PUSH1 0x01 068F 60 PUSH1 0x40 0691 1B SHL 0692 03 SUB 0693 81 DUP2 0694 11 GT 0695 15 ISZERO 0696 61 PUSH2 0x06af 0699 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0686 stack[-2] = stack[-1] // @0688 stack[-1] = 0x00 // @068A stack[0] = stack[-1] // } // Block ends with conditional jump to 0x06af, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_069A: // Incoming jump from 0x0699, if not !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[1] { @06AE memory[0x00:0x24] } 069A 63 PUSH4 0x4e487b71 069F 60 PUSH1 0xe0 06A1 1B SHL 06A2 60 PUSH1 0x00 06A4 52 MSTORE 06A5 60 PUSH1 0x41 06A7 60 PUSH1 0x04 06A9 52 MSTORE 06AA 60 PUSH1 0x24 06AC 60 PUSH1 0x00 06AE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @06A4 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @06A9 memory[0x04:0x24] = 0x41 // @06AE revert(memory[0x00:0x24]); // } // Block terminates label_06AF: // Incoming jump from 0x0699, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @06B2 memory[0x40:0x60] // @06B3 stack[-1] // } 06AF 5B JUMPDEST 06B0 60 PUSH1 0x40 06B2 51 MLOAD 06B3 90 SWAP1 06B4 80 DUP1 06B5 82 DUP3 06B6 52 MSTORE 06B7 80 DUP1 06B8 60 PUSH1 0x20 06BA 02 MUL 06BB 60 PUSH1 0x20 06BD 01 ADD 06BE 82 DUP3 06BF 01 ADD 06C0 60 PUSH1 0x40 06C2 52 MSTORE 06C3 80 DUP1 06C4 15 ISZERO 06C5 61 PUSH2 0x06d8 06C8 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @06B3 stack[-1] = memory[0x40:0x60] // @06B3 stack[0] = stack[-1] // @06B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06C2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x06d8, if !stack[-1] label_06C9: // Incoming jump from 0x06C8, if not !stack[-1] // Inputs[6] // { // @06C9 stack[-2] // @06CF stack[-1] // @06D2 msg.data.length // @06D4 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @06DA stack[-3] // @06DE stack[-4] // } 06C9 81 DUP2 06CA 60 PUSH1 0x20 06CC 01 ADD 06CD 60 PUSH1 0x20 06CF 82 DUP3 06D0 02 MUL 06D1 80 DUP1 06D2 36 CALLDATASIZE 06D3 83 DUP4 06D4 37 CALLDATACOPY 06D5 01 ADD 06D6 90 SWAP1 06D7 50 POP 06D8 5B JUMPDEST 06D9 50 POP 06DA 90 SWAP1 06DB 50 POP 06DC 60 PUSH1 0x00 06DE 82 DUP3 06DF 15 ISZERO 06E0 61 PUSH2 0x0764 06E3 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @06D4 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @06DA stack[-3] = stack[-2] // @06DC stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0764, if !stack[-4] label_06E4: // Incoming jump from 0x06E3, if not !stack[-4] // Incoming jump from 0x06E3, if not !stack[-4] // Inputs[1] { @06E7 stack[-4] } 06E4 60 PUSH1 0x00 06E6 5B JUMPDEST 06E7 84 DUP5 06E8 81 DUP2 06E9 10 LT 06EA 15 ISZERO 06EB 61 PUSH2 0x0762 06EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06E4 stack[0] = 0x00 } // Block ends with conditional jump to 0x0762, if !(0x00 < stack[-4]) label_06EF: // Incoming jump from 0x06EE, if not !(stack[-1] < stack[-5]) // Incoming jump from 0x06EE, if not !(0x00 < stack[-4]) // Inputs[1] { @06F4 stack[-1] } 06EF 60 PUSH1 0x00 06F1 61 PUSH2 0x06f9 06F4 82 DUP3 06F5 61 PUSH2 0x0535 06F8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06EF stack[0] = 0x00 // @06F1 stack[1] = 0x06f9 // @06F4 stack[2] = stack[-1] // } // Block ends with call to 0x0535, returns to 0x06F9 label_06F9: // Incoming return from call to 0x0535 at 0x06F8 // Inputs[3] // { // @06FA stack[-1] // @06FA stack[-2] // @06FC stack[-9] // } 06F9 5B JUMPDEST 06FA 90 SWAP1 06FB 50 POP 06FC 87 DUP8 06FD 60 PUSH1 0x01 06FF 60 PUSH1 0x01 0701 60 PUSH1 0xa0 0703 1B SHL 0704 03 SUB 0705 16 AND 0706 81 DUP2 0707 60 PUSH1 0x01 0709 60 PUSH1 0x01 070B 60 PUSH1 0xa0 070D 1B SHL 070E 03 SUB 070F 16 AND 0710 14 EQ 0711 15 ISZERO 0712 61 PUSH2 0x074f 0715 57 *JUMPI // Stack delta = -1 // Outputs[1] { @06FA stack[-2] = stack[-1] } // Block ends with conditional jump to 0x074f, if !((0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-9]) label_0716: // Incoming jump from 0x0715, if not !((0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-9]) // Inputs[4] // { // @0716 stack[-2] // @0717 stack[-4] // @0718 stack[-3] // @071A memory[stack[-4]:stack[-4] + 0x20] // } 0716 81 DUP2 0717 84 DUP5 0718 84 DUP5 0719 81 DUP2 071A 51 MLOAD 071B 81 DUP2 071C 10 LT 071D 61 PUSH2 0x0736 0720 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0716 stack[0] = stack[-2] // @0717 stack[1] = stack[-4] // @0718 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x0736, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_0721: // Incoming jump from 0x0720, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[1] { @0735 memory[0x00:0x24] } 0721 63 PUSH4 0x4e487b71 0726 60 PUSH1 0xe0 0728 1B SHL 0729 60 PUSH1 0x00 072B 52 MSTORE 072C 60 PUSH1 0x32 072E 60 PUSH1 0x04 0730 52 MSTORE 0731 60 PUSH1 0x24 0733 60 PUSH1 0x00 0735 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @072B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0730 memory[0x04:0x24] = 0x32 // @0735 revert(memory[0x00:0x24]); // } // Block terminates label_0736: // Incoming jump from 0x0720, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @0739 stack[-1] // @073C stack[-2] // @0741 stack[-3] // @0745 stack[-6] // } 0736 5B JUMPDEST 0737 60 PUSH1 0x20 0739 90 SWAP1 073A 81 DUP2 073B 02 MUL 073C 91 SWAP2 073D 90 SWAP1 073E 91 SWAP2 073F 01 ADD 0740 01 ADD 0741 52 MSTORE 0742 61 PUSH2 0x074c 0745 83 DUP4 0746 60 PUSH1 0x01 0748 61 PUSH2 0x17a7 074B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0741 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0742 stack[-3] = 0x074c // @0745 stack[-2] = stack[-6] // @0746 stack[-1] = 0x01 // } // Block ends with call to 0x17a7, returns to 0x074C label_074C: // Incoming return from call to 0x17A7 at 0x074B // Inputs[2] // { // @074D stack[-4] // @074D stack[-1] // } 074C 5B JUMPDEST 074D 92 SWAP3 074E 50 POP // Stack delta = -1 // Outputs[1] { @074D stack[-4] = stack[-1] } // Block continues label_074F: // Incoming jump from 0x0715, if !((0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-9]) // Incoming jump from 0x074E // Inputs[1] { @0751 stack[-2] } 074F 5B JUMPDEST 0750 50 POP 0751 80 DUP1 0752 61 PUSH2 0x075a 0755 81 DUP2 0756 61 PUSH2 0x1851 0759 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0751 stack[-1] = stack[-2] // @0752 stack[0] = 0x075a // @0755 stack[1] = stack[-2] // } // Block ends with call to 0x1851, returns to 0x075A label_075A: // Incoming return from call to 0x1851 at 0x0759 // Inputs[2] // { // @075B stack[-3] // @075B stack[-1] // } 075A 5B JUMPDEST 075B 91 SWAP2 075C 50 POP 075D 50 POP 075E 61 PUSH2 0x06e6 0761 56 *JUMP // Stack delta = -2 // Outputs[1] { @075B stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x06e6 label_0762: // Incoming jump from 0x06EE, if !(stack[-1] < stack[-5]) // Incoming jump from 0x06EE, if !(0x00 < stack[-4]) 0762 5B JUMPDEST 0763 50 POP // Stack delta = -1 // Block continues label_0764: // Incoming jump from 0x0763 // Incoming jump from 0x06E3, if !stack[-4] // Incoming jump from 0x06E3, if !stack[-4] // Inputs[3] // { // @0766 stack[-7] // @0766 stack[-2] // @0767 stack[-6] // } 0764 5B JUMPDEST 0765 50 POP 0766 94 SWAP5 0767 93 SWAP4 0768 50 POP 0769 50 POP 076A 50 POP 076B 50 POP 076C 56 *JUMP // Stack delta = -6 // Outputs[1] { @0766 stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_076D: // Incoming call from 0x0285, returns to 0x016C // Inputs[1] { @0773 storage[0x03] } 076D 5B JUMPDEST 076E 60 PUSH1 0x60 0770 60 PUSH1 0x03 0772 80 DUP1 0773 54 SLOAD 0774 61 PUSH2 0x0377 0777 90 SWAP1 0778 61 PUSH2 0x1816 077B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @076E stack[0] = 0x60 // @0770 stack[1] = 0x03 // @0777 stack[2] = 0x0377 // @0777 stack[3] = storage[0x03] // } // Block ends with call to 0x1816, returns to 0x0377 label_077C: // Incoming jump from 0x0298 // Inputs[2] // { // @0785 stack[-2] // @0787 msg.sender // } 077C 5B JUMPDEST 077D 60 PUSH1 0x01 077F 60 PUSH1 0x01 0781 60 PUSH1 0xa0 0783 1B SHL 0784 03 SUB 0785 82 DUP3 0786 16 AND 0787 33 CALLER 0788 14 EQ 0789 15 ISZERO 078A 61 PUSH2 0x07a6 078D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a6, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_078E: // Incoming jump from 0x078D, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @0790 memory[0x40:0x60] // @07A0 memory[0x40:0x60] // @07A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 078E 60 PUSH1 0x40 0790 51 MLOAD 0791 63 PUSH4 0xb06307db 0796 60 PUSH1 0xe0 0798 1B SHL 0799 81 DUP2 079A 52 MSTORE 079B 60 PUSH1 0x04 079D 01 ADD 079E 60 PUSH1 0x40 07A0 51 MLOAD 07A1 80 DUP1 07A2 91 SWAP2 07A3 03 SUB 07A4 90 SWAP1 07A5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @079A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @07A5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_07A6: // Incoming jump from 0x078D, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @07A7 msg.sender // @07B8 memory[0x00:0x40] // @07C1 stack[-2] // @07CC memory[0x00:0x40] // @07CE storage[keccak256(memory[0x00:0x40])] // @07D3 stack[-1] // @07DD memory[0x40:0x60] // @0809 memory[0x40:0x60] // @080E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0811 stack[-3] // } 07A6 5B JUMPDEST 07A7 33 CALLER 07A8 60 PUSH1 0x00 07AA 81 DUP2 07AB 81 DUP2 07AC 52 MSTORE 07AD 60 PUSH1 0x07 07AF 60 PUSH1 0x20 07B1 90 SWAP1 07B2 81 DUP2 07B3 52 MSTORE 07B4 60 PUSH1 0x40 07B6 80 DUP1 07B7 83 DUP4 07B8 20 SHA3 07B9 60 PUSH1 0x01 07BB 60 PUSH1 0x01 07BD 60 PUSH1 0xa0 07BF 1B SHL 07C0 03 SUB 07C1 87 DUP8 07C2 16 AND 07C3 80 DUP1 07C4 85 DUP6 07C5 52 MSTORE 07C6 90 SWAP1 07C7 83 DUP4 07C8 52 MSTORE 07C9 92 SWAP3 07CA 81 DUP2 07CB 90 SWAP1 07CC 20 SHA3 07CD 80 DUP1 07CE 54 SLOAD 07CF 60 PUSH1 0xff 07D1 19 NOT 07D2 16 AND 07D3 86 DUP7 07D4 15 ISZERO 07D5 15 ISZERO 07D6 90 SWAP1 07D7 81 DUP2 07D8 17 OR 07D9 90 SWAP1 07DA 91 SWAP2 07DB 55 SSTORE 07DC 90 SWAP1 07DD 51 MLOAD 07DE 90 SWAP1 07DF 81 DUP2 07E0 52 MSTORE 07E1 91 SWAP2 07E2 92 SWAP3 07E3 91 SWAP2 07E4 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0805 91 SWAP2 0806 01 ADD 0807 60 PUSH1 0x40 0809 51 MLOAD 080A 80 DUP1 080B 91 SWAP2 080C 03 SUB 080D 90 SWAP1 080E A3 LOG3 080F 50 POP 0810 50 POP 0811 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @07AC memory[0x00:0x20] = msg.sender // @07B3 memory[0x20:0x40] = 0x07 // @07C5 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @07C8 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @07DB storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @07E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @080E 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_0812: // Incoming call from 0x04EA, returns to 0x04C0 // Incoming jump from 0x02AB // Inputs[3] // { // @0816 stack[-4] // @0817 stack[-3] // @0818 stack[-2] // } 0812 5B JUMPDEST 0813 61 PUSH2 0x081d 0816 84 DUP5 0817 84 DUP5 0818 84 DUP5 0819 61 PUSH2 0x0a9f 081C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0813 stack[0] = 0x081d // @0816 stack[1] = stack[-4] // @0817 stack[2] = stack[-3] // @0818 stack[3] = stack[-2] // } // Block ends with call to 0x0a9f, returns to 0x081D label_081D: // Incoming return from call to 0x0A9F at 0x081C // Inputs[2] // { // @0826 stack[-3] // @0828 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 081D 5B JUMPDEST 081E 60 PUSH1 0x01 0820 60 PUSH1 0x01 0822 60 PUSH1 0xa0 0824 1B SHL 0825 03 SUB 0826 83 DUP4 0827 16 AND 0828 3B EXTCODESIZE 0829 15 ISZERO 082A 61 PUSH2 0x0856 082D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0856, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_082E: // Incoming jump from 0x082D, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @0831 stack[-4] // @0832 stack[-3] // @0833 stack[-2] // @0834 stack[-1] // } 082E 61 PUSH2 0x0839 0831 84 DUP5 0832 84 DUP5 0833 84 DUP5 0834 84 DUP5 0835 61 PUSH2 0x0e1a 0838 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @082E stack[0] = 0x0839 // @0831 stack[1] = stack[-4] // @0832 stack[2] = stack[-3] // @0833 stack[3] = stack[-2] // @0834 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x0e1a 0839 5B JUMPDEST 083A 61 PUSH2 0x0856 083D 57 *JUMPI 083E 60 PUSH1 0x40 0840 51 MLOAD 0841 63 PUSH4 0x68d2bf6b 0846 60 PUSH1 0xe1 0848 1B SHL 0849 81 DUP2 084A 52 MSTORE 084B 60 PUSH1 0x04 084D 01 ADD 084E 60 PUSH1 0x40 0850 51 MLOAD 0851 80 DUP1 0852 91 SWAP2 0853 03 SUB 0854 90 SWAP1 0855 FD *REVERT label_0856: // Incoming call from 0x11FD, returns to 0x0856 // Incoming return from call to 0x0856 at 0x11FD // Incoming jump from 0x082D, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x180D, if !(stack[-1] > stack[-4]) // Inputs[1] { @085B stack[-5] } 0856 5B JUMPDEST 0857 50 POP 0858 50 POP 0859 50 POP 085A 50 POP 085B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_085C: // Incoming jump from 0x02BE // Inputs[1] { @0862 stack[-1] } 085C 5B JUMPDEST 085D 60 PUSH1 0x60 085F 61 PUSH2 0x0867 0862 82 DUP3 0863 61 PUSH2 0x0a0a 0866 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @085D stack[0] = 0x60 // @085F stack[1] = 0x0867 // @0862 stack[2] = stack[-1] // } // Block ends with call to 0x0a0a, returns to 0x0867 label_0867: // Incoming return from call to 0x0A0A at 0x0866 // Inputs[1] { @086B stack[-1] } 0867 5B JUMPDEST 0868 61 PUSH2 0x0884 086B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0884, if stack[-1] label_086C: // Incoming jump from 0x086B, if not stack[-1] // Inputs[3] // { // @086E memory[0x40:0x60] // @087E memory[0x40:0x60] // @0883 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 086C 60 PUSH1 0x40 086E 51 MLOAD 086F 63 PUSH4 0x0a14c4b5 0874 60 PUSH1 0xe4 0876 1B SHL 0877 81 DUP2 0878 52 MSTORE 0879 60 PUSH1 0x04 087B 01 ADD 087C 60 PUSH1 0x40 087E 51 MLOAD 087F 80 DUP1 0880 91 SWAP2 0881 03 SUB 0882 90 SWAP1 0883 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0878 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @0883 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0884: // Incoming jump from 0x086B, if stack[-1] 0884 5B JUMPDEST 0885 60 PUSH1 0x00 0887 61 PUSH2 0x088e 088A 61 PUSH2 0x0f12 088D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0885 stack[0] = 0x00 // @0887 stack[1] = 0x088e // } // Block ends with unconditional jump to 0x0f12 088E 5B JUMPDEST 088F 90 SWAP1 0890 50 POP 0891 80 DUP1 0892 51 MLOAD 0893 60 PUSH1 0x00 0895 14 EQ 0896 15 ISZERO 0897 61 PUSH2 0x08af 089A 57 *JUMPI 089B 60 PUSH1 0x40 089D 51 MLOAD 089E 80 DUP1 089F 60 PUSH1 0x20 08A1 01 ADD 08A2 60 PUSH1 0x40 08A4 52 MSTORE 08A5 80 DUP1 08A6 60 PUSH1 0x00 08A8 81 DUP2 08A9 52 MSTORE 08AA 50 POP 08AB 61 PUSH2 0x08da 08AE 56 *JUMP 08AF 5B JUMPDEST 08B0 80 DUP1 08B1 61 PUSH2 0x08b9 08B4 84 DUP5 08B5 61 PUSH2 0x0f21 08B8 56 *JUMP 08B9 5B JUMPDEST 08BA 60 PUSH1 0x40 08BC 51 MLOAD 08BD 60 PUSH1 0x20 08BF 01 ADD 08C0 61 PUSH2 0x08ca 08C3 92 SWAP3 08C4 91 SWAP2 08C5 90 SWAP1 08C6 61 PUSH2 0x165c 08C9 56 *JUMP 08CA 5B JUMPDEST 08CB 60 PUSH1 0x40 08CD 51 MLOAD 08CE 60 PUSH1 0x20 08D0 81 DUP2 08D1 83 DUP4 08D2 03 SUB 08D3 03 SUB 08D4 81 DUP2 08D5 52 MSTORE 08D6 90 SWAP1 08D7 60 PUSH1 0x40 08D9 52 MSTORE label_08DA: // Incoming return from call to 0x18C2 at 0x15B6 // Incoming return from call to 0x12EE at 0x1392 // Incoming return from call to 0x18C2 at 0x15D2 // Incoming return from call to 0x1630 at 0x171E // Inputs[3] // { // @08DB stack[-1] // @08DB stack[-5] // @08DC stack[-4] // } 08DA 5B JUMPDEST 08DB 93 SWAP4 08DC 92 SWAP3 08DD 50 POP 08DE 50 POP 08DF 50 POP 08E0 56 *JUMP // Stack delta = -4 // Outputs[1] { @08DB stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_08E1: // Incoming call from 0x02C6, returns to 0x016C // Inputs[1] { @08E5 storage[0x09] } 08E1 5B JUMPDEST 08E2 60 PUSH1 0x09 08E4 80 DUP1 08E5 54 SLOAD 08E6 61 PUSH2 0x08ee 08E9 90 SWAP1 08EA 61 PUSH2 0x1816 08ED 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08E2 stack[0] = 0x09 // @08E9 stack[1] = 0x08ee // @08E9 stack[2] = storage[0x09] // } // Block ends with call to 0x1816, returns to 0x08EE label_08EE: // Incoming return from call to 0x1816 at 0x08ED // Inputs[4] // { // @08EF stack[-1] // @08FE memory[0x40:0x60] // @0906 stack[-2] // @0911 storage[stack[-2]] // } 08EE 5B JUMPDEST 08EF 80 DUP1 08F0 60 PUSH1 0x1f 08F2 01 ADD 08F3 60 PUSH1 0x20 08F5 80 DUP1 08F6 91 SWAP2 08F7 04 DIV 08F8 02 MUL 08F9 60 PUSH1 0x20 08FB 01 ADD 08FC 60 PUSH1 0x40 08FE 51 MLOAD 08FF 90 SWAP1 0900 81 DUP2 0901 01 ADD 0902 60 PUSH1 0x40 0904 52 MSTORE 0905 80 DUP1 0906 92 SWAP3 0907 91 SWAP2 0908 90 SWAP1 0909 81 DUP2 090A 81 DUP2 090B 52 MSTORE 090C 60 PUSH1 0x20 090E 01 ADD 090F 82 DUP3 0910 80 DUP1 0911 54 SLOAD 0912 61 PUSH2 0x091a 0915 90 SWAP1 0916 61 PUSH2 0x1816 0919 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0904 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0906 stack[-2] = memory[0x40:0x60] // @0907 stack[-1] = stack[-2] // @0908 stack[0] = stack[-1] // @090B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @090E stack[1] = 0x20 + memory[0x40:0x60] // @090F stack[2] = stack[-2] // @0915 stack[4] = storage[stack[-2]] // @0915 stack[3] = 0x091a // } // Block ends with call to 0x1816, returns to 0x091A label_091A: // Incoming return from call to 0x1816 at 0x0919 // Inputs[1] { @091B stack[-1] } 091A 5B JUMPDEST 091B 80 DUP1 091C 15 ISZERO 091D 61 PUSH2 0x0967 0920 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0967, if !stack[-1] label_0921: // Incoming jump from 0x0920, if not !stack[-1] // Inputs[1] { @0921 stack[-1] } 0921 80 DUP1 0922 60 PUSH1 0x1f 0924 10 LT 0925 61 PUSH2 0x093c 0928 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x093c, if 0x1f < stack[-1] label_0929: // Incoming jump from 0x0928, if not 0x1f < stack[-1] // Inputs[4] // { // @092D stack[-2] // @092E storage[stack[-2]] // @0931 stack[-3] // @0933 stack[-1] // } 0929 61 PUSH2 0x0100 092C 80 DUP1 092D 83 DUP4 092E 54 SLOAD 092F 04 DIV 0930 02 MUL 0931 83 DUP4 0932 52 MSTORE 0933 91 SWAP2 0934 60 PUSH1 0x20 0936 01 ADD 0937 91 SWAP2 0938 61 PUSH2 0x0967 093B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0932 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0937 stack[-1] = stack[-1] // @0937 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0967 label_093C: // Incoming jump from 0x0928, if 0x1f < stack[-1] // Inputs[5] // { // @093D stack[-3] // @093E stack[-1] // @0940 stack[-2] // @0948 memory[0x00:0x20] // @094C storage[keccak256(memory[0x00:0x20])] // } 093C 5B JUMPDEST 093D 82 DUP3 093E 01 ADD 093F 91 SWAP2 0940 90 SWAP1 0941 60 PUSH1 0x00 0943 52 MSTORE 0944 60 PUSH1 0x20 0946 60 PUSH1 0x00 0948 20 SHA3 0949 90 SWAP1 094A 5B JUMPDEST 094B 81 DUP2 094C 54 SLOAD 094D 81 DUP2 094E 52 MSTORE 094F 90 SWAP1 0950 60 PUSH1 0x01 0952 01 ADD 0953 90 SWAP1 0954 60 PUSH1 0x20 0956 01 ADD 0957 80 DUP1 0958 83 DUP4 0959 11 GT 095A 61 PUSH2 0x094a 095D 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @093F stack[-3] = stack[-3] + stack[-1] // @0943 memory[0x00:0x20] = stack[-2] // @094E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0953 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0956 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x094a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_095E: // Incoming jump from 0x095D, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x095D, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @095E stack[-3] // @095F stack[-1] // } 095E 82 DUP3 095F 90 SWAP1 0960 03 SUB 0961 60 PUSH1 0x1f 0963 16 AND 0964 82 DUP3 0965 01 ADD 0966 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0966 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0966 stack[-1] = stack[-3] // } // Block continues label_0967: // Incoming jump from 0x0966 // Incoming jump from 0x0920, if !stack[-1] // Incoming jump from 0x093B // Inputs[1] { @096D stack[-7] } 0967 5B JUMPDEST 0968 50 POP 0969 50 POP 096A 50 POP 096B 50 POP 096C 50 POP 096D 81 DUP2 096E 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_096F: // Incoming jump from 0x0315 // Inputs[2] // { // @0972 storage[0x08] // @097C msg.sender // } 096F 5B JUMPDEST 0970 60 PUSH1 0x08 0972 54 SLOAD 0973 60 PUSH1 0x01 0975 60 PUSH1 0x01 0977 60 PUSH1 0xa0 0979 1B SHL 097A 03 SUB 097B 16 AND 097C 33 CALLER 097D 14 EQ 097E 61 PUSH2 0x0999 0981 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0999, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0982: // Incoming jump from 0x0981, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0984 memory[0x40:0x60] } 0982 60 PUSH1 0x40 0984 51 MLOAD 0985 62 PUSH3 0x461bcd 0989 60 PUSH1 0xe5 098B 1B SHL 098C 81 DUP2 098D 52 MSTORE 098E 60 PUSH1 0x04 0990 01 ADD 0991 61 PUSH2 0x0515 0994 90 SWAP1 0995 61 PUSH2 0x171f 0998 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @098D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0994 stack[0] = 0x0515 // @0994 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x171f, returns to 0x0515 label_0999: // Incoming jump from 0x0981, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09A2 stack[-1] } 0999 5B JUMPDEST 099A 60 PUSH1 0x01 099C 60 PUSH1 0x01 099E 60 PUSH1 0xa0 09A0 1B SHL 09A1 03 SUB 09A2 81 DUP2 09A3 16 AND 09A4 61 PUSH2 0x09fe 09A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09fe, if stack[-1] & (0x01 << 0xa0) - 0x01 label_09A8: // Incoming jump from 0x09A7, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @09AA memory[0x40:0x60] } 09A8 60 PUSH1 0x40 09AA 51 MLOAD 09AB 62 PUSH3 0x461bcd 09AF 60 PUSH1 0xe5 09B1 1B SHL 09B2 81 DUP2 09B3 52 MSTORE 09B4 60 PUSH1 0x20 09B6 60 PUSH1 0x04 09B8 82 DUP3 09B9 01 ADD 09BA 52 MSTORE 09BB 60 PUSH1 0x26 09BD 60 PUSH1 0x24 09BF 82 DUP3 09C0 01 ADD 09C1 52 MSTORE 09C2 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 09E3 60 PUSH1 0x44 09E5 82 DUP3 09E6 01 ADD 09E7 52 MSTORE 09E8 65 PUSH6 0x646472657373 09EF 60 PUSH1 0xd0 09F1 1B SHL 09F2 60 PUSH1 0x64 09F4 82 DUP3 09F5 01 ADD 09F6 52 MSTORE 09F7 60 PUSH1 0x84 09F9 01 ADD 09FA 61 PUSH2 0x0515 09FD 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @09B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09BA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09C1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @09E7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @09F6 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @09F9 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0515 label_09FE: // Incoming jump from 0x09A7, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A02 stack[-1] } 09FE 5B JUMPDEST 09FF 61 PUSH2 0x0a07 0A02 81 DUP2 0A03 61 PUSH2 0x0dae 0A06 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09FF stack[0] = 0x0a07 // @0A02 stack[1] = stack[-1] // } // Block ends with call to 0x0dae, returns to 0x0A07 label_0A07: // Incoming jump from 0x18D3, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x0DAE at 0x0A06 // Inputs[1] { @0A09 stack[-2] } 0A07 5B JUMPDEST 0A08 50 POP 0A09 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A0A: // Incoming call from 0x0404, returns to 0x0405 // Incoming call from 0x0866, returns to 0x0867 // Inputs[1] { @0A0D stack[-1] } 0A0A 5B JUMPDEST 0A0B 60 PUSH1 0x00 0A0D 81 DUP2 0A0E 60 PUSH1 0x01 0A10 11 GT 0A11 15 ISZERO 0A12 80 DUP1 0A13 15 ISZERO 0A14 61 PUSH2 0x0a1e 0A17 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0A0B stack[0] = 0x00 // @0A11 stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x0a1e, if !!(0x01 > stack[-1]) label_0A18: // Incoming jump from 0x0A17, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @0A1B storage[0x00] // @0A1C stack[-3] // } 0A18 50 POP 0A19 60 PUSH1 0x00 0A1B 54 SLOAD 0A1C 82 DUP3 0A1D 10 LT 0A1E 5B JUMPDEST 0A1F 80 DUP1 0A20 15 ISZERO 0A21 61 PUSH2 0x0362 0A24 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A1D stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x0362, if !(stack[-3] < storage[0x00]) label_0A25: // Incoming jump from 0x0A24, if not !(stack[-3] < storage[0x00]) // Incoming jump from 0x0A24, if not !stack[-1] // Inputs[4] // { // @0A29 stack[-3] // @0A34 memory[0x00:0x40] // @0A35 storage[keccak256(memory[0x00:0x40])] // @0A41 stack[-4] // } 0A25 50 POP 0A26 50 POP 0A27 60 PUSH1 0x00 0A29 90 SWAP1 0A2A 81 DUP2 0A2B 52 MSTORE 0A2C 60 PUSH1 0x04 0A2E 60 PUSH1 0x20 0A30 52 MSTORE 0A31 60 PUSH1 0x40 0A33 90 SWAP1 0A34 20 SHA3 0A35 54 SLOAD 0A36 60 PUSH1 0x01 0A38 60 PUSH1 0xe0 0A3A 1B SHL 0A3B 90 SWAP1 0A3C 04 DIV 0A3D 60 PUSH1 0xff 0A3F 16 AND 0A40 15 ISZERO 0A41 90 SWAP1 0A42 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0A2B memory[0x00:0x20] = stack[-3] // @0A30 memory[0x20:0x40] = 0x04 // @0A41 stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_0A43: // Incoming call from 0x0B6C, returns to 0x0B6D // Incoming call from 0x04BF, returns to 0x04C0 // Inputs[8] // { // @0A46 stack[-2] // @0A52 memory[0x00:0x40] // @0A54 storage[keccak256(memory[0x00:0x40])] // @0A67 stack[-3] // @0A71 memory[0x40:0x60] // @0A75 stack[-1] // @0A9A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0A9E stack[-4] // } 0A43 5B JUMPDEST 0A44 60 PUSH1 0x00 0A46 82 DUP3 0A47 81 DUP2 0A48 52 MSTORE 0A49 60 PUSH1 0x06 0A4B 60 PUSH1 0x20 0A4D 52 MSTORE 0A4E 60 PUSH1 0x40 0A50 80 DUP1 0A51 82 DUP3 0A52 20 SHA3 0A53 80 DUP1 0A54 54 SLOAD 0A55 60 PUSH1 0x01 0A57 60 PUSH1 0x01 0A59 60 PUSH1 0xa0 0A5B 1B SHL 0A5C 03 SUB 0A5D 19 NOT 0A5E 16 AND 0A5F 60 PUSH1 0x01 0A61 60 PUSH1 0x01 0A63 60 PUSH1 0xa0 0A65 1B SHL 0A66 03 SUB 0A67 87 DUP8 0A68 81 DUP2 0A69 16 AND 0A6A 91 SWAP2 0A6B 82 DUP3 0A6C 17 OR 0A6D 90 SWAP1 0A6E 92 SWAP3 0A6F 55 SSTORE 0A70 91 SWAP2 0A71 51 MLOAD 0A72 85 DUP6 0A73 93 SWAP4 0A74 91 SWAP2 0A75 85 DUP6 0A76 16 AND 0A77 91 SWAP2 0A78 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0A99 91 SWAP2 0A9A A4 LOG4 0A9B 50 POP 0A9C 50 POP 0A9D 50 POP 0A9E 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0A48 memory[0x00:0x20] = stack[-2] // @0A4D memory[0x20:0x40] = 0x06 // @0A6F storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0A9A 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_0A9F: // Incoming call from 0x04CF, returns to 0x04C0 // Incoming call from 0x081C, returns to 0x081D // Inputs[1] { @0AA5 stack[-1] } 0A9F 5B JUMPDEST 0AA0 60 PUSH1 0x00 0AA2 61 PUSH2 0x0aaa 0AA5 82 DUP3 0AA6 61 PUSH2 0x0c8c 0AA9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AA0 stack[0] = 0x00 // @0AA2 stack[1] = 0x0aaa // @0AA5 stack[2] = stack[-1] // } // Block ends with call to 0x0c8c, returns to 0x0AAA label_0AAA: // Incoming return from call to 0x0C8C at 0x0AA9 // Inputs[4] // { // @0AAB stack[-2] // @0AAB stack[-1] // @0AAD stack[-5] // @0ABB memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 0AAA 5B JUMPDEST 0AAB 90 SWAP1 0AAC 50 POP 0AAD 83 DUP4 0AAE 60 PUSH1 0x01 0AB0 60 PUSH1 0x01 0AB2 60 PUSH1 0xa0 0AB4 1B SHL 0AB5 03 SUB 0AB6 16 AND 0AB7 81 DUP2 0AB8 60 PUSH1 0x00 0ABA 01 ADD 0ABB 51 MLOAD 0ABC 60 PUSH1 0x01 0ABE 60 PUSH1 0x01 0AC0 60 PUSH1 0xa0 0AC2 1B SHL 0AC3 03 SUB 0AC4 16 AND 0AC5 14 EQ 0AC6 61 PUSH2 0x0ae1 0AC9 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0AAB stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0ae1, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_0ACA: // Incoming jump from 0x0AC9, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @0ACC memory[0x40:0x60] // @0ADB memory[0x40:0x60] // @0AE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0ACA 60 PUSH1 0x40 0ACC 51 MLOAD 0ACD 62 PUSH3 0xa11481 0AD1 60 PUSH1 0xe8 0AD3 1B SHL 0AD4 81 DUP2 0AD5 52 MSTORE 0AD6 60 PUSH1 0x04 0AD8 01 ADD 0AD9 60 PUSH1 0x40 0ADB 51 MLOAD 0ADC 80 DUP1 0ADD 91 SWAP2 0ADE 03 SUB 0ADF 90 SWAP1 0AE0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @0AE0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0AE1: // Incoming jump from 0x0AC9, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @0AE4 msg.sender // @0AED stack[-4] // } 0AE1 5B JUMPDEST 0AE2 60 PUSH1 0x00 0AE4 33 CALLER 0AE5 60 PUSH1 0x01 0AE7 60 PUSH1 0x01 0AE9 60 PUSH1 0xa0 0AEB 1B SHL 0AEC 03 SUB 0AED 86 DUP7 0AEE 16 AND 0AEF 14 EQ 0AF0 80 DUP1 0AF1 61 PUSH2 0x0aff 0AF4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0AE2 stack[0] = 0x00 // @0AEF stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x0aff, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_0AF5: // Incoming jump from 0x0AF4, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0AF9 stack[-6] // @0AFA msg.sender // } 0AF5 50 POP 0AF6 61 PUSH2 0x0aff 0AF9 85 DUP6 0AFA 33 CALLER 0AFB 61 PUSH2 0x02d5 0AFE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AF6 stack[-1] = 0x0aff // @0AF9 stack[0] = stack[-6] // @0AFA stack[1] = msg.sender // } // Block ends with call to 0x02d5, returns to 0x0AFF label_0AFF: // Incoming return from call to 0x02D5 at 0x0AFE // Incoming jump from 0x0AF4, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @0B00 stack[-1] } 0AFF 5B JUMPDEST 0B00 80 DUP1 0B01 61 PUSH2 0x0b1a 0B04 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b1a, if stack[-1] label_0B05: // Incoming jump from 0x0B04, if not stack[-1] // Inputs[2] // { // @0B06 msg.sender // @0B0A stack[-4] // } 0B05 50 POP 0B06 33 CALLER 0B07 61 PUSH2 0x0b0f 0B0A 84 DUP5 0B0B 61 PUSH2 0x03fa 0B0E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B06 stack[-1] = msg.sender // @0B07 stack[0] = 0x0b0f // @0B0A stack[1] = stack[-4] // } // Block ends with call to 0x03fa, returns to 0x0B0F label_0B0F: // Incoming return from call to 0x03FA at 0x0B0E // Inputs[2] // { // @0B18 stack[-1] // @0B19 stack[-2] // } 0B0F 5B JUMPDEST 0B10 60 PUSH1 0x01 0B12 60 PUSH1 0x01 0B14 60 PUSH1 0xa0 0B16 1B SHL 0B17 03 SUB 0B18 16 AND 0B19 14 EQ // Stack delta = -1 // Outputs[1] { @0B19 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_0B1A: // Incoming jump from 0x0B19 // Incoming jump from 0x0B04, if stack[-1] // Inputs[2] // { // @0B1B stack[-2] // @0B1B stack[-1] // } 0B1A 5B JUMPDEST 0B1B 90 SWAP1 0B1C 50 POP 0B1D 80 DUP1 0B1E 61 PUSH2 0x0b3a 0B21 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0B1B stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0b3a, if stack[-1] label_0B22: // Incoming jump from 0x0B21, if not stack[-1] // Inputs[3] // { // @0B24 memory[0x40:0x60] // @0B34 memory[0x40:0x60] // @0B39 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B22 60 PUSH1 0x40 0B24 51 MLOAD 0B25 63 PUSH4 0x2ce44b5f 0B2A 60 PUSH1 0xe1 0B2C 1B SHL 0B2D 81 DUP2 0B2E 52 MSTORE 0B2F 60 PUSH1 0x04 0B31 01 ADD 0B32 60 PUSH1 0x40 0B34 51 MLOAD 0B35 80 DUP1 0B36 91 SWAP2 0B37 03 SUB 0B38 90 SWAP1 0B39 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @0B39 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B3A: // Incoming jump from 0x0B21, if stack[-1] // Inputs[1] { @0B43 stack[-4] } 0B3A 5B JUMPDEST 0B3B 60 PUSH1 0x01 0B3D 60 PUSH1 0x01 0B3F 60 PUSH1 0xa0 0B41 1B SHL 0B42 03 SUB 0B43 84 DUP5 0B44 16 AND 0B45 61 PUSH2 0x0b61 0B48 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b61, if stack[-4] & (0x01 << 0xa0) - 0x01 label_0B49: // Incoming jump from 0x0B48, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0B4B memory[0x40:0x60] // @0B5B memory[0x40:0x60] // @0B60 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B49 60 PUSH1 0x40 0B4B 51 MLOAD 0B4C 63 PUSH4 0x3a954ecd 0B51 60 PUSH1 0xe2 0B53 1B SHL 0B54 81 DUP2 0B55 52 MSTORE 0B56 60 PUSH1 0x04 0B58 01 ADD 0B59 60 PUSH1 0x40 0B5B 51 MLOAD 0B5C 80 DUP1 0B5D 91 SWAP2 0B5E 03 SUB 0B5F 90 SWAP1 0B60 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @0B60 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B61: // Incoming jump from 0x0B48, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0B67 stack[-3] // @0B68 stack[-5] // } 0B61 5B JUMPDEST 0B62 61 PUSH2 0x0b6d 0B65 60 PUSH1 0x00 0B67 84 DUP5 0B68 87 DUP8 0B69 61 PUSH2 0x0a43 0B6C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B62 stack[0] = 0x0b6d // @0B65 stack[1] = 0x00 // @0B67 stack[2] = stack[-3] // @0B68 stack[3] = stack[-5] // } // Block ends with call to 0x0a43, returns to 0x0B6D label_0B6D: // Incoming return from call to 0x0A43 at 0x0B6C // Inputs[12] // { // @0B76 stack[-5] // @0B89 memory[0x00:0x40] // @0B8B storage[keccak256(memory[0x00:0x40])] // @0BAE stack[-4] // @0BB6 memory[0x00:0x40] // @0BB8 storage[keccak256(memory[0x00:0x40])] // @0BCC stack[-3] // @0BD6 memory[0x00:0x40] // @0BD8 storage[keccak256(memory[0x00:0x40])] // @0BEB block.timestamp // @0BFC memory[0x00:0x40] // @0BFE storage[keccak256(memory[0x00:0x40])] // } 0B6D 5B JUMPDEST 0B6E 60 PUSH1 0x01 0B70 60 PUSH1 0x01 0B72 60 PUSH1 0xa0 0B74 1B SHL 0B75 03 SUB 0B76 85 DUP6 0B77 81 DUP2 0B78 16 AND 0B79 60 PUSH1 0x00 0B7B 90 SWAP1 0B7C 81 DUP2 0B7D 52 MSTORE 0B7E 60 PUSH1 0x05 0B80 60 PUSH1 0x20 0B82 90 SWAP1 0B83 81 DUP2 0B84 52 MSTORE 0B85 60 PUSH1 0x40 0B87 80 DUP1 0B88 83 DUP4 0B89 20 SHA3 0B8A 80 DUP1 0B8B 54 SLOAD 0B8C 67 PUSH8 0xffffffffffffffff 0B95 19 NOT 0B96 80 DUP1 0B97 82 DUP3 0B98 16 AND 0B99 60 PUSH1 0x01 0B9B 60 PUSH1 0x01 0B9D 60 PUSH1 0x40 0B9F 1B SHL 0BA0 03 SUB 0BA1 92 SWAP3 0BA2 83 DUP4 0BA3 16 AND 0BA4 60 PUSH1 0x00 0BA6 19 NOT 0BA7 01 ADD 0BA8 83 DUP4 0BA9 16 AND 0BAA 17 OR 0BAB 90 SWAP1 0BAC 92 SWAP3 0BAD 55 SSTORE 0BAE 89 DUP10 0BAF 86 DUP7 0BB0 16 AND 0BB1 80 DUP1 0BB2 86 DUP7 0BB3 52 MSTORE 0BB4 83 DUP4 0BB5 86 DUP7 0BB6 20 SHA3 0BB7 80 DUP1 0BB8 54 SLOAD 0BB9 93 SWAP4 0BBA 84 DUP5 0BBB 16 AND 0BBC 93 SWAP4 0BBD 83 DUP4 0BBE 16 AND 0BBF 60 PUSH1 0x01 0BC1 90 SWAP1 0BC2 81 DUP2 0BC3 01 ADD 0BC4 84 DUP5 0BC5 16 AND 0BC6 94 SWAP5 0BC7 90 SWAP1 0BC8 94 SWAP5 0BC9 17 OR 0BCA 90 SWAP1 0BCB 55 SSTORE 0BCC 89 DUP10 0BCD 86 DUP7 0BCE 52 MSTORE 0BCF 60 PUSH1 0x04 0BD1 90 SWAP1 0BD2 94 SWAP5 0BD3 52 MSTORE 0BD4 82 DUP3 0BD5 85 DUP6 0BD6 20 SHA3 0BD7 80 DUP1 0BD8 54 SLOAD 0BD9 60 PUSH1 0x01 0BDB 60 PUSH1 0x01 0BDD 60 PUSH1 0xe0 0BDF 1B SHL 0BE0 03 SUB 0BE1 19 NOT 0BE2 16 AND 0BE3 90 SWAP1 0BE4 94 SWAP5 0BE5 17 OR 0BE6 60 PUSH1 0x01 0BE8 60 PUSH1 0xa0 0BEA 1B SHL 0BEB 42 TIMESTAMP 0BEC 90 SWAP1 0BED 92 SWAP3 0BEE 16 AND 0BEF 91 SWAP2 0BF0 90 SWAP1 0BF1 91 SWAP2 0BF2 02 MUL 0BF3 17 OR 0BF4 83 DUP4 0BF5 55 SSTORE 0BF6 87 DUP8 0BF7 01 ADD 0BF8 80 DUP1 0BF9 84 DUP5 0BFA 52 MSTORE 0BFB 92 SWAP3 0BFC 20 SHA3 0BFD 80 DUP1 0BFE 54 SLOAD 0BFF 91 SWAP2 0C00 93 SWAP4 0C01 90 SWAP1 0C02 91 SWAP2 0C03 16 AND 0C04 61 PUSH2 0x0c41 0C07 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @0B7D memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @0B84 memory[0x20:0x40] = 0x05 // @0BAD storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & ~0x00 + ((0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @0BB3 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @0BCB storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & 0x01 + ((0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @0BCE memory[0x00:0x20] = stack[-3] // @0BD3 memory[0x20:0x40] = 0x04 // @0BF5 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0BFA memory[0x00:0x20] = stack[-3] + 0x01 // @0BFB stack[1] = stack[-3] + 0x01 // @0C00 stack[0] = keccak256(memory[0x00:0x40]) // @0C02 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0c41, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_0C08: // Incoming jump from 0x0C07, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0C0A storage[0x00] // @0C0B stack[-2] // } 0C08 60 PUSH1 0x00 0C0A 54 SLOAD 0C0B 82 DUP3 0C0C 14 EQ 0C0D 61 PUSH2 0x0c41 0C10 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c41, if stack[-2] == storage[0x00] label_0C11: // Incoming jump from 0x0C10, if not stack[-2] == storage[0x00] // Inputs[5] // { // @0C11 stack[-1] // @0C12 storage[stack[-1]] // @0C15 stack[-5] // @0C17 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @0C3B stack[-8] // } 0C11 80 DUP1 0C12 54 SLOAD 0C13 60 PUSH1 0x20 0C15 86 DUP7 0C16 01 ADD 0C17 51 MLOAD 0C18 60 PUSH1 0x01 0C1A 60 PUSH1 0x01 0C1C 60 PUSH1 0x40 0C1E 1B SHL 0C1F 03 SUB 0C20 16 AND 0C21 60 PUSH1 0x01 0C23 60 PUSH1 0xa0 0C25 1B SHL 0C26 02 MUL 0C27 60 PUSH1 0x01 0C29 60 PUSH1 0x01 0C2B 60 PUSH1 0xe0 0C2D 1B SHL 0C2E 03 SUB 0C2F 19 NOT 0C30 90 SWAP1 0C31 91 SWAP2 0C32 16 AND 0C33 60 PUSH1 0x01 0C35 60 PUSH1 0x01 0C37 60 PUSH1 0xa0 0C39 1B SHL 0C3A 03 SUB 0C3B 8A DUP11 0C3C 16 AND 0C3D 17 OR 0C3E 17 OR 0C3F 81 DUP2 0C40 55 SSTORE // Stack delta = +0 // Outputs[1] { @0C40 storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * ((0x01 << 0x40) - 0x01 & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_0C41: // Incoming jump from 0x0C40 // Incoming jump from 0x0C10, if stack[-2] == storage[0x00] // Incoming jump from 0x0C07, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[7] // { // @0C45 stack[-6] // @0C46 stack[-7] // @0C50 stack[-8] // @0C7D memory[0x40:0x60] // @0C80 memory[0x40:0x60] // @0C85 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0C8B stack[-9] // } 0C41 5B JUMPDEST 0C42 50 POP 0C43 50 POP 0C44 50 POP 0C45 82 DUP3 0C46 84 DUP5 0C47 60 PUSH1 0x01 0C49 60 PUSH1 0x01 0C4B 60 PUSH1 0xa0 0C4D 1B SHL 0C4E 03 SUB 0C4F 16 AND 0C50 86 DUP7 0C51 60 PUSH1 0x01 0C53 60 PUSH1 0x01 0C55 60 PUSH1 0xa0 0C57 1B SHL 0C58 03 SUB 0C59 16 AND 0C5A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0C7B 60 PUSH1 0x40 0C7D 51 MLOAD 0C7E 60 PUSH1 0x40 0C80 51 MLOAD 0C81 80 DUP1 0C82 91 SWAP2 0C83 03 SUB 0C84 90 SWAP1 0C85 A4 LOG4 0C86 50 POP 0C87 50 POP 0C88 50 POP 0C89 50 POP 0C8A 50 POP 0C8B 56 *JUMP // Stack delta = -9 // Outputs[1] { @0C85 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_0C8C: // Incoming call from 0x0AA9, returns to 0x0AAA // Incoming call from 0x053F, returns to 0x0540 // Inputs[2] // { // @0C90 memory[0x40:0x60] // @0CAA stack[-1] // } 0C8C 5B JUMPDEST 0C8D 60 PUSH1 0x40 0C8F 80 DUP1 0C90 51 MLOAD 0C91 60 PUSH1 0x60 0C93 81 DUP2 0C94 01 ADD 0C95 82 DUP3 0C96 52 MSTORE 0C97 60 PUSH1 0x00 0C99 80 DUP1 0C9A 82 DUP3 0C9B 52 MSTORE 0C9C 60 PUSH1 0x20 0C9E 82 DUP3 0C9F 01 ADD 0CA0 81 DUP2 0CA1 90 SWAP1 0CA2 52 MSTORE 0CA3 91 SWAP2 0CA4 81 DUP2 0CA5 01 ADD 0CA6 91 SWAP2 0CA7 90 SWAP1 0CA8 91 SWAP2 0CA9 52 MSTORE 0CAA 81 DUP2 0CAB 80 DUP1 0CAC 60 PUSH1 0x01 0CAE 11 GT 0CAF 61 PUSH2 0x0d95 0CB2 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @0C96 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0C9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0CA2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0CA8 stack[0] = memory[0x40:0x60] // @0CA9 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @0CAA stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0d95, if 0x01 > stack[-1] label_0CB3: // Incoming jump from 0x0CB2, if not 0x01 > stack[-1] // Inputs[2] // { // @0CB5 storage[0x00] // @0CB6 stack[-1] // } 0CB3 60 PUSH1 0x00 0CB5 54 SLOAD 0CB6 81 DUP2 0CB7 10 LT 0CB8 15 ISZERO 0CB9 61 PUSH2 0x0d95 0CBC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d95, if !(stack[-1] < storage[0x00]) label_0CBD: // Incoming jump from 0x0CBC, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @0CBF stack[-1] // @0CCE memory[0x00:0x40] // @0CD0 memory[0x40:0x60] // @0CD8 storage[keccak256(memory[0x00:0x40])] // } 0CBD 60 PUSH1 0x00 0CBF 81 DUP2 0CC0 81 DUP2 0CC1 52 MSTORE 0CC2 60 PUSH1 0x04 0CC4 60 PUSH1 0x20 0CC6 90 SWAP1 0CC7 81 DUP2 0CC8 52 MSTORE 0CC9 60 PUSH1 0x40 0CCB 91 SWAP2 0CCC 82 DUP3 0CCD 90 SWAP1 0CCE 20 SHA3 0CCF 82 DUP3 0CD0 51 MLOAD 0CD1 60 PUSH1 0x60 0CD3 81 DUP2 0CD4 01 ADD 0CD5 84 DUP5 0CD6 52 MSTORE 0CD7 90 SWAP1 0CD8 54 SLOAD 0CD9 60 PUSH1 0x01 0CDB 60 PUSH1 0x01 0CDD 60 PUSH1 0xa0 0CDF 1B SHL 0CE0 03 SUB 0CE1 81 DUP2 0CE2 16 AND 0CE3 82 DUP3 0CE4 52 MSTORE 0CE5 60 PUSH1 0x01 0CE7 60 PUSH1 0xa0 0CE9 1B SHL 0CEA 81 DUP2 0CEB 04 DIV 0CEC 60 PUSH1 0x01 0CEE 60 PUSH1 0x01 0CF0 60 PUSH1 0x40 0CF2 1B SHL 0CF3 03 SUB 0CF4 16 AND 0CF5 92 SWAP3 0CF6 82 DUP3 0CF7 01 ADD 0CF8 92 SWAP3 0CF9 90 SWAP1 0CFA 92 SWAP3 0CFB 52 MSTORE 0CFC 60 PUSH1 0x01 0CFE 60 PUSH1 0xe0 0D00 1B SHL 0D01 90 SWAP1 0D02 91 SWAP2 0D03 04 DIV 0D04 60 PUSH1 0xff 0D06 16 AND 0D07 15 ISZERO 0D08 15 ISZERO 0D09 91 SWAP2 0D0A 81 DUP2 0D0B 01 ADD 0D0C 82 DUP3 0D0D 90 SWAP1 0D0E 52 MSTORE 0D0F 90 SWAP1 0D10 61 PUSH2 0x0d93 0D13 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @0CC1 memory[0x00:0x20] = stack[-1] // @0CC8 memory[0x20:0x40] = 0x04 // @0CD6 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0CE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0CFB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0D0E memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @0D0F stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0d93, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_0D14: // Incoming jump from 0x0D13, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @0D14 stack[-1] // @0D15 memory[stack[-1]:stack[-1] + 0x20] // } 0D14 80 DUP1 0D15 51 MLOAD 0D16 60 PUSH1 0x01 0D18 60 PUSH1 0x01 0D1A 60 PUSH1 0xa0 0D1C 1B SHL 0D1D 03 SUB 0D1E 16 AND 0D1F 15 ISZERO 0D20 61 PUSH2 0x0d2a 0D23 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d2a, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_0D24: // Incoming jump from 0x0D23, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0D24 stack[-5] // @0D24 stack[-1] // @0D25 stack[-4] // } 0D24 93 SWAP4 0D25 92 SWAP3 0D26 50 POP 0D27 50 POP 0D28 50 POP 0D29 56 *JUMP // Stack delta = -4 // Outputs[1] { @0D24 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0D2A: // Incoming jump from 0x0D92 // Incoming jump from 0x0D23, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0D2F stack[-2] // @0D41 memory[0x00:0x40] // @0D43 memory[0x40:0x60] // @0D4B storage[keccak256(memory[0x00:0x40])] // } 0D2A 5B JUMPDEST 0D2B 50 POP 0D2C 60 PUSH1 0x00 0D2E 19 NOT 0D2F 01 ADD 0D30 60 PUSH1 0x00 0D32 81 DUP2 0D33 81 DUP2 0D34 52 MSTORE 0D35 60 PUSH1 0x04 0D37 60 PUSH1 0x20 0D39 90 SWAP1 0D3A 81 DUP2 0D3B 52 MSTORE 0D3C 60 PUSH1 0x40 0D3E 91 SWAP2 0D3F 82 DUP3 0D40 90 SWAP1 0D41 20 SHA3 0D42 82 DUP3 0D43 51 MLOAD 0D44 60 PUSH1 0x60 0D46 81 DUP2 0D47 01 ADD 0D48 84 DUP5 0D49 52 MSTORE 0D4A 90 SWAP1 0D4B 54 SLOAD 0D4C 60 PUSH1 0x01 0D4E 60 PUSH1 0x01 0D50 60 PUSH1 0xa0 0D52 1B SHL 0D53 03 SUB 0D54 81 DUP2 0D55 16 AND 0D56 80 DUP1 0D57 83 DUP4 0D58 52 MSTORE 0D59 60 PUSH1 0x01 0D5B 60 PUSH1 0xa0 0D5D 1B SHL 0D5E 82 DUP3 0D5F 04 DIV 0D60 60 PUSH1 0x01 0D62 60 PUSH1 0x01 0D64 60 PUSH1 0x40 0D66 1B SHL 0D67 03 SUB 0D68 16 AND 0D69 93 SWAP4 0D6A 83 DUP4 0D6B 01 ADD 0D6C 93 SWAP4 0D6D 90 SWAP1 0D6E 93 SWAP4 0D6F 52 MSTORE 0D70 60 PUSH1 0x01 0D72 60 PUSH1 0xe0 0D74 1B SHL 0D75 90 SWAP1 0D76 04 DIV 0D77 60 PUSH1 0xff 0D79 16 AND 0D7A 15 ISZERO 0D7B 15 ISZERO 0D7C 92 SWAP3 0D7D 81 DUP2 0D7E 01 ADD 0D7F 92 SWAP3 0D80 90 SWAP1 0D81 92 SWAP3 0D82 52 MSTORE 0D83 15 ISZERO 0D84 61 PUSH2 0x0d8e 0D87 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @0D2F stack[-2] = ~0x00 + stack[-2] // @0D34 memory[0x00:0x20] = ~0x00 + stack[-2] // @0D3B memory[0x20:0x40] = 0x04 // @0D49 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0D58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0D6F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0D81 stack[-1] = memory[0x40:0x60] // @0D82 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x0d8e, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_0D88: // Incoming jump from 0x0D87, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @0D88 stack[-5] // @0D88 stack[-1] // @0D89 stack[-4] // } 0D88 93 SWAP4 0D89 92 SWAP3 0D8A 50 POP 0D8B 50 POP 0D8C 50 POP 0D8D 56 *JUMP // Stack delta = -4 // Outputs[1] { @0D88 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0D8E: // Incoming jump from 0x0D87, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 0D8E 5B JUMPDEST 0D8F 61 PUSH2 0x0d2a 0D92 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d2a label_0D93: // Incoming jump from 0x0D13, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 0D93 5B JUMPDEST 0D94 50 POP // Stack delta = -1 // Block continues label_0D95: // Incoming jump from 0x0CBC, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x0D94 // Incoming jump from 0x0CB2, if 0x01 > stack[-1] // Inputs[3] // { // @0D98 memory[0x40:0x60] // @0DA8 memory[0x40:0x60] // @0DAD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D95 5B JUMPDEST 0D96 60 PUSH1 0x40 0D98 51 MLOAD 0D99 63 PUSH4 0x6f96cda1 0D9E 60 PUSH1 0xe1 0DA0 1B SHL 0DA1 81 DUP2 0DA2 52 MSTORE 0DA3 60 PUSH1 0x04 0DA5 01 ADD 0DA6 60 PUSH1 0x40 0DA8 51 MLOAD 0DA9 80 DUP1 0DAA 91 SWAP2 0DAB 03 SUB 0DAC 90 SWAP1 0DAD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @0DAD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0DAE: // Incoming call from 0x0A06, returns to 0x0A07 // Incoming call from 0x05C8, returns to 0x05C9 // Inputs[5] // { // @0DB2 storage[0x08] // @0DBB stack[-1] // @0DD0 memory[0x40:0x60] // @0DFC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0DFF stack[-2] // } 0DAE 5B JUMPDEST 0DAF 60 PUSH1 0x08 0DB1 80 DUP1 0DB2 54 SLOAD 0DB3 60 PUSH1 0x01 0DB5 60 PUSH1 0x01 0DB7 60 PUSH1 0xa0 0DB9 1B SHL 0DBA 03 SUB 0DBB 83 DUP4 0DBC 81 DUP2 0DBD 16 AND 0DBE 60 PUSH1 0x01 0DC0 60 PUSH1 0x01 0DC2 60 PUSH1 0xa0 0DC4 1B SHL 0DC5 03 SUB 0DC6 19 NOT 0DC7 83 DUP4 0DC8 16 AND 0DC9 81 DUP2 0DCA 17 OR 0DCB 90 SWAP1 0DCC 93 SWAP4 0DCD 55 SSTORE 0DCE 60 PUSH1 0x40 0DD0 51 MLOAD 0DD1 91 SWAP2 0DD2 16 AND 0DD3 91 SWAP2 0DD4 90 SWAP1 0DD5 82 DUP3 0DD6 90 SWAP1 0DD7 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0DF8 90 SWAP1 0DF9 60 PUSH1 0x00 0DFB 90 SWAP1 0DFC A3 LOG3 0DFD 50 POP 0DFE 50 POP 0DFF 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0DCD storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @0DFC 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_0E00: // Incoming jump from 0x0658 // Inputs[3] // { // @0E04 stack[-2] // @0E05 stack[-1] // @0E08 memory[0x40:0x60] // } 0E00 5B JUMPDEST 0E01 61 PUSH2 0x0531 0E04 82 DUP3 0E05 82 DUP3 0E06 60 PUSH1 0x40 0E08 51 MLOAD 0E09 80 DUP1 0E0A 60 PUSH1 0x20 0E0C 01 ADD 0E0D 60 PUSH1 0x40 0E0F 52 MSTORE 0E10 80 DUP1 0E11 60 PUSH1 0x00 0E13 81 DUP2 0E14 52 MSTORE 0E15 50 POP 0E16 61 PUSH2 0x103a 0E19 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0E01 stack[0] = 0x0531 // @0E04 stack[1] = stack[-2] // @0E05 stack[2] = stack[-1] // @0E08 stack[3] = memory[0x40:0x60] // @0E0F memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0E14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x103a label_0E1A: // Incoming jump from 0x1171 // Incoming jump from 0x0838 // Inputs[6] // { // @0E1D memory[0x40:0x60] // @0E33 stack[-3] // @0E40 msg.sender // @0E42 stack[-4] // @0E44 stack[-2] // @0E46 stack[-1] // } 0E1A 5B JUMPDEST 0E1B 60 PUSH1 0x40 0E1D 51 MLOAD 0E1E 63 PUSH4 0x0a85bd01 0E23 60 PUSH1 0xe1 0E25 1B SHL 0E26 81 DUP2 0E27 52 MSTORE 0E28 60 PUSH1 0x00 0E2A 90 SWAP1 0E2B 60 PUSH1 0x01 0E2D 60 PUSH1 0x01 0E2F 60 PUSH1 0xa0 0E31 1B SHL 0E32 03 SUB 0E33 85 DUP6 0E34 16 AND 0E35 90 SWAP1 0E36 63 PUSH4 0x150b7a02 0E3B 90 SWAP1 0E3C 61 PUSH2 0x0e4f 0E3F 90 SWAP1 0E40 33 CALLER 0E41 90 SWAP1 0E42 89 DUP10 0E43 90 SWAP1 0E44 88 DUP9 0E45 90 SWAP1 0E46 88 DUP9 0E47 90 SWAP1 0E48 60 PUSH1 0x04 0E4A 01 ADD 0E4B 61 PUSH2 0x168b 0E4E 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @0E27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @0E2A stack[0] = 0x00 // @0E35 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0E3B stack[2] = 0x150b7a02 // @0E3F stack[3] = 0x0e4f // @0E41 stack[4] = msg.sender // @0E43 stack[5] = stack[-4] // @0E45 stack[6] = stack[-2] // @0E47 stack[7] = stack[-1] // @0E4A stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x168b, returns to 0x0E4F label_0E4F: // Incoming return from call to 0x168B at 0x0E4E // Inputs[4] // { // @0E54 memory[0x40:0x60] // @0E56 stack[-1] // @0E5B stack[-3] // @0E5D address(stack[-3]).code.length // } 0E4F 5B JUMPDEST 0E50 60 PUSH1 0x20 0E52 60 PUSH1 0x40 0E54 51 MLOAD 0E55 80 DUP1 0E56 83 DUP4 0E57 03 SUB 0E58 81 DUP2 0E59 60 PUSH1 0x00 0E5B 87 DUP8 0E5C 80 DUP1 0E5D 3B EXTCODESIZE 0E5E 15 ISZERO 0E5F 80 DUP1 0E60 15 ISZERO 0E61 61 PUSH2 0x0e69 0E64 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0E50 stack[0] = 0x20 // @0E54 stack[1] = memory[0x40:0x60] // @0E57 stack[2] = stack[-1] - memory[0x40:0x60] // @0E58 stack[3] = memory[0x40:0x60] // @0E59 stack[4] = 0x00 // @0E5B stack[5] = stack[-3] // @0E5E stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0e69, if !!address(stack[-3]).code.length label_0E65: // Incoming jump from 0x0E64, if not !!address(stack[-3]).code.length // Inputs[1] { @0E68 memory[0x00:0x00] } 0E65 60 PUSH1 0x00 0E67 80 DUP1 0E68 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E68 revert(memory[0x00:0x00]); } // Block terminates label_0E69: // Incoming jump from 0x0E64, if !!address(stack[-3]).code.length // Inputs[10] // { // @0E6B msg.gas // @0E6C address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0E6C stack[-4] // @0E6C stack[-2] // @0E6C stack[-5] // @0E6C memory[stack[-4]:stack[-4] + stack[-5]] // @0E6C stack[-3] // @0E6C stack[-6] // @0E6C stack[-7] // @0E6D stack[-10] // } 0E69 5B JUMPDEST 0E6A 50 POP 0E6B 5A GAS 0E6C F1 CALL 0E6D 92 SWAP3 0E6E 50 POP 0E6F 50 POP 0E70 50 POP 0E71 80 DUP1 0E72 15 ISZERO 0E73 61 PUSH2 0x0e99 0E76 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @0E6C memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0E6D stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0e99, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0E77: // Incoming jump from 0x0E76, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0E7B memory[0x40:0x60] // @0E7E returndata.length // } 0E77 50 POP 0E78 60 PUSH1 0x40 0E7A 80 DUP1 0E7B 51 MLOAD 0E7C 60 PUSH1 0x1f 0E7E 3D RETURNDATASIZE 0E7F 90 SWAP1 0E80 81 DUP2 0E81 01 ADD 0E82 60 PUSH1 0x1f 0E84 19 NOT 0E85 16 AND 0E86 82 DUP3 0E87 01 ADD 0E88 90 SWAP1 0E89 92 SWAP3 0E8A 52 MSTORE 0E8B 61 PUSH2 0x0e96 0E8E 91 SWAP2 0E8F 81 DUP2 0E90 01 ADD 0E91 90 SWAP1 0E92 61 PUSH2 0x15b7 0E95 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0E8A memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @0E8E stack[-1] = 0x0e96 // @0E91 stack[1] = memory[0x40:0x60] // @0E91 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x15b7 0E96 5B JUMPDEST 0E97 60 PUSH1 0x01 label_0E99: // Incoming jump from 0x0E76, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0E9D stack[-1] } 0E99 5B JUMPDEST 0E9A 61 PUSH2 0x0ef4 0E9D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ef4, if stack[-1] label_0E9E: // Incoming jump from 0x0E9D, if not stack[-1] // Inputs[1] { @0E9E returndata.length } 0E9E 3D RETURNDATASIZE 0E9F 80 DUP1 0EA0 80 DUP1 0EA1 15 ISZERO 0EA2 61 PUSH2 0x0ec7 0EA5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E9E stack[0] = returndata.length // @0E9F stack[1] = returndata.length // } // Block ends with conditional jump to 0x0ec7, if !returndata.length label_0EA6: // Incoming jump from 0x0EA5, if not !returndata.length // Inputs[6] // { // @0EA8 memory[0x40:0x60] // @0EA9 stack[-2] // @0EB0 returndata.length // @0EB8 returndata.length // @0EBB returndata.length // @0EC2 returndata[0x00:0x00 + returndata.length] // } 0EA6 60 PUSH1 0x40 0EA8 51 MLOAD 0EA9 91 SWAP2 0EAA 50 POP 0EAB 60 PUSH1 0x1f 0EAD 19 NOT 0EAE 60 PUSH1 0x3f 0EB0 3D RETURNDATASIZE 0EB1 01 ADD 0EB2 16 AND 0EB3 82 DUP3 0EB4 01 ADD 0EB5 60 PUSH1 0x40 0EB7 52 MSTORE 0EB8 3D RETURNDATASIZE 0EB9 82 DUP3 0EBA 52 MSTORE 0EBB 3D RETURNDATASIZE 0EBC 60 PUSH1 0x00 0EBE 60 PUSH1 0x20 0EC0 84 DUP5 0EC1 01 ADD 0EC2 3E RETURNDATACOPY 0EC3 61 PUSH2 0x0ecc 0EC6 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0EA9 stack[-2] = memory[0x40:0x60] // @0EB7 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0EBA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0EC2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0ecc label_0EC7: // Incoming jump from 0x0EA5, if !returndata.length // Inputs[2] // { // @0ECA stack[-2] // @0ECF memory[0x60:0x80] // } 0EC7 5B JUMPDEST 0EC8 60 PUSH1 0x60 0ECA 91 SWAP2 0ECB 50 POP 0ECC 5B JUMPDEST 0ECD 50 POP 0ECE 80 DUP1 0ECF 51 MLOAD 0ED0 61 PUSH2 0x0eec 0ED3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0ECA stack[-2] = 0x60 } // Block ends with conditional jump to 0x0eec, if memory[0x60:0x80] label_0ED4: // Incoming jump from 0x0ED3, if not memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0ED3, if not memory[0x60:0x80] // Inputs[3] // { // @0ED6 memory[0x40:0x60] // @0EE6 memory[0x40:0x60] // @0EEB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0ED4 60 PUSH1 0x40 0ED6 51 MLOAD 0ED7 63 PUSH4 0x68d2bf6b 0EDC 60 PUSH1 0xe1 0EDE 1B SHL 0EDF 81 DUP2 0EE0 52 MSTORE 0EE1 60 PUSH1 0x04 0EE3 01 ADD 0EE4 60 PUSH1 0x40 0EE6 51 MLOAD 0EE7 80 DUP1 0EE8 91 SWAP2 0EE9 03 SUB 0EEA 90 SWAP1 0EEB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @0EEB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EEC: // Incoming jump from 0x0ED3, if memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0ED3, if memory[0x60:0x80] // Inputs[3] // { // @0EED stack[-1] // @0EEE memory[stack[-1]:stack[-1] + 0x20] // @0EF3 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 0EEC 5B JUMPDEST 0EED 80 DUP1 0EEE 51 MLOAD 0EEF 81 DUP2 0EF0 60 PUSH1 0x20 0EF2 01 ADD 0EF3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EF3 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_0EF4: // Incoming jump from 0x0E9D, if stack[-1] // Inputs[2] // { // @0EFE stack[-1] // @0F08 stack[-2] // } 0EF4 5B JUMPDEST 0EF5 60 PUSH1 0x01 0EF7 60 PUSH1 0x01 0EF9 60 PUSH1 0xe0 0EFB 1B SHL 0EFC 03 SUB 0EFD 19 NOT 0EFE 16 AND 0EFF 63 PUSH4 0x0a85bd01 0F04 60 PUSH1 0xe1 0F06 1B SHL 0F07 14 EQ 0F08 90 SWAP1 0F09 50 POP // Stack delta = -1 // Outputs[1] { @0F08 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_0F0A: // Incoming return from call to 0x1297 at 0x1617 // Incoming jump from 0x0F09 // Inputs[3] // { // @0F0B stack[-6] // @0F0B stack[-1] // @0F0C stack[-5] // } 0F0A 5B JUMPDEST 0F0B 94 SWAP5 0F0C 93 SWAP4 0F0D 50 POP 0F0E 50 POP 0F0F 50 POP 0F10 50 POP 0F11 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F0B stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0F12: // Incoming jump from 0x088D // Inputs[1] { @0F18 storage[0x09] } 0F12 5B JUMPDEST 0F13 60 PUSH1 0x60 0F15 60 PUSH1 0x09 0F17 80 DUP1 0F18 54 SLOAD 0F19 61 PUSH2 0x0377 0F1C 90 SWAP1 0F1D 61 PUSH2 0x1816 0F20 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F13 stack[0] = 0x60 // @0F15 stack[1] = 0x09 // @0F1C stack[2] = 0x0377 // @0F1C stack[3] = storage[0x09] // } // Block ends with call to 0x1816, returns to 0x0377 0F21 5B JUMPDEST 0F22 60 PUSH1 0x60 0F24 81 DUP2 0F25 61 PUSH2 0x0f45 0F28 57 *JUMPI 0F29 50 POP 0F2A 50 POP 0F2B 60 PUSH1 0x40 0F2D 80 DUP1 0F2E 51 MLOAD 0F2F 80 DUP1 0F30 82 DUP3 0F31 01 ADD 0F32 90 SWAP1 0F33 91 SWAP2 0F34 52 MSTORE 0F35 60 PUSH1 0x01 0F37 81 DUP2 0F38 52 MSTORE 0F39 60 PUSH1 0x03 0F3B 60 PUSH1 0xfc 0F3D 1B SHL 0F3E 60 PUSH1 0x20 0F40 82 DUP3 0F41 01 ADD 0F42 52 MSTORE 0F43 90 SWAP1 0F44 56 *JUMP 0F45 5B JUMPDEST 0F46 81 DUP2 0F47 60 PUSH1 0x00 0F49 5B JUMPDEST 0F4A 81 DUP2 0F4B 15 ISZERO 0F4C 61 PUSH2 0x0f6f 0F4F 57 *JUMPI 0F50 80 DUP1 0F51 61 PUSH2 0x0f59 0F54 81 DUP2 0F55 61 PUSH2 0x1851 0F58 56 *JUMP 0F59 5B JUMPDEST 0F5A 91 SWAP2 0F5B 50 POP 0F5C 61 PUSH2 0x0f68 0F5F 90 SWAP1 0F60 50 POP 0F61 60 PUSH1 0x0a 0F63 83 DUP4 0F64 61 PUSH2 0x17bf 0F67 56 *JUMP 0F68 5B JUMPDEST 0F69 91 SWAP2 0F6A 50 POP 0F6B 61 PUSH2 0x0f49 0F6E 56 *JUMP 0F6F 5B JUMPDEST 0F70 60 PUSH1 0x00 0F72 81 DUP2 0F73 60 PUSH1 0x01 0F75 60 PUSH1 0x01 0F77 60 PUSH1 0x40 0F79 1B SHL 0F7A 03 SUB 0F7B 81 DUP2 0F7C 11 GT 0F7D 15 ISZERO 0F7E 61 PUSH2 0x0f97 0F81 57 *JUMPI 0F82 63 PUSH4 0x4e487b71 0F87 60 PUSH1 0xe0 0F89 1B SHL 0F8A 60 PUSH1 0x00 0F8C 52 MSTORE 0F8D 60 PUSH1 0x41 0F8F 60 PUSH1 0x04 0F91 52 MSTORE 0F92 60 PUSH1 0x24 0F94 60 PUSH1 0x00 0F96 FD *REVERT 0F97 5B JUMPDEST 0F98 60 PUSH1 0x40 0F9A 51 MLOAD 0F9B 90 SWAP1 0F9C 80 DUP1 0F9D 82 DUP3 0F9E 52 MSTORE 0F9F 80 DUP1 0FA0 60 PUSH1 0x1f 0FA2 01 ADD 0FA3 60 PUSH1 0x1f 0FA5 19 NOT 0FA6 16 AND 0FA7 60 PUSH1 0x20 0FA9 01 ADD 0FAA 82 DUP3 0FAB 01 ADD 0FAC 60 PUSH1 0x40 0FAE 52 MSTORE 0FAF 80 DUP1 0FB0 15 ISZERO 0FB1 61 PUSH2 0x0fc1 0FB4 57 *JUMPI 0FB5 60 PUSH1 0x20 0FB7 82 DUP3 0FB8 01 ADD 0FB9 81 DUP2 0FBA 80 DUP1 0FBB 36 CALLDATASIZE 0FBC 83 DUP4 0FBD 37 CALLDATACOPY 0FBE 01 ADD 0FBF 90 SWAP1 0FC0 50 POP 0FC1 5B JUMPDEST 0FC2 50 POP 0FC3 90 SWAP1 0FC4 50 POP 0FC5 5B JUMPDEST 0FC6 84 DUP5 0FC7 15 ISZERO 0FC8 61 PUSH2 0x0f0a 0FCB 57 *JUMPI 0FCC 61 PUSH2 0x0fd6 0FCF 60 PUSH1 0x01 0FD1 83 DUP4 0FD2 61 PUSH2 0x17d3 0FD5 56 *JUMP 0FD6 5B JUMPDEST 0FD7 91 SWAP2 0FD8 50 POP 0FD9 61 PUSH2 0x0fe3 0FDC 60 PUSH1 0x0a 0FDE 86 DUP7 0FDF 61 PUSH2 0x186c 0FE2 56 *JUMP 0FE3 5B JUMPDEST 0FE4 61 PUSH2 0x0fee 0FE7 90 SWAP1 0FE8 60 PUSH1 0x30 0FEA 61 PUSH2 0x17a7 0FED 56 *JUMP 0FEE 5B JUMPDEST 0FEF 60 PUSH1 0xf8 0FF1 1B SHL 0FF2 81 DUP2 0FF3 83 DUP4 0FF4 81 DUP2 0FF5 51 MLOAD 0FF6 81 DUP2 0FF7 10 LT 0FF8 61 PUSH2 0x1011 0FFB 57 *JUMPI 0FFC 63 PUSH4 0x4e487b71 1001 60 PUSH1 0xe0 1003 1B SHL 1004 60 PUSH1 0x00 1006 52 MSTORE 1007 60 PUSH1 0x32 1009 60 PUSH1 0x04 100B 52 MSTORE 100C 60 PUSH1 0x24 100E 60 PUSH1 0x00 1010 FD *REVERT 1011 5B JUMPDEST 1012 60 PUSH1 0x20 1014 01 ADD 1015 01 ADD 1016 90 SWAP1 1017 60 PUSH1 0x01 1019 60 PUSH1 0x01 101B 60 PUSH1 0xf8 101D 1B SHL 101E 03 SUB 101F 19 NOT 1020 16 AND 1021 90 SWAP1 1022 81 DUP2 1023 60 PUSH1 0x00 1025 1A BYTE 1026 90 SWAP1 1027 53 MSTORE8 1028 50 POP 1029 61 PUSH2 0x1033 102C 60 PUSH1 0x0a 102E 86 DUP7 102F 61 PUSH2 0x17bf 1032 56 *JUMP 1033 5B JUMPDEST 1034 94 SWAP5 1035 50 POP 1036 61 PUSH2 0x0fc5 1039 56 *JUMP label_103A: // Incoming jump from 0x0E19 // Inputs[2] // { // @103D storage[0x00] // @1046 stack[-3] // } 103A 5B JUMPDEST 103B 60 PUSH1 0x00 103D 54 SLOAD 103E 60 PUSH1 0x01 1040 60 PUSH1 0x01 1042 60 PUSH1 0xa0 1044 1B SHL 1045 03 SUB 1046 84 DUP5 1047 16 AND 1048 61 PUSH2 0x1063 104B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @103D stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1063, if stack[-3] & (0x01 << 0xa0) - 0x01 label_104C: // Incoming jump from 0x104B, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @104E memory[0x40:0x60] // @105D memory[0x40:0x60] // @1062 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 104C 60 PUSH1 0x40 104E 51 MLOAD 104F 62 PUSH3 0x2e0763 1053 60 PUSH1 0xe8 1055 1B SHL 1056 81 DUP2 1057 52 MSTORE 1058 60 PUSH1 0x04 105A 01 ADD 105B 60 PUSH1 0x40 105D 51 MLOAD 105E 80 DUP1 105F 91 SWAP2 1060 03 SUB 1061 90 SWAP1 1062 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1057 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @1062 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1063: // Incoming jump from 0x104B, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1064 stack[-3] } 1063 5B JUMPDEST 1064 82 DUP3 1065 61 PUSH2 0x1081 1068 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1081, if stack[-3] label_1069: // Incoming jump from 0x1068, if not stack[-3] // Inputs[3] // { // @106B memory[0x40:0x60] // @107B memory[0x40:0x60] // @1080 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1069 60 PUSH1 0x40 106B 51 MLOAD 106C 63 PUSH4 0xb562e8dd 1071 60 PUSH1 0xe0 1073 1B SHL 1074 81 DUP2 1075 52 MSTORE 1076 60 PUSH1 0x04 1078 01 ADD 1079 60 PUSH1 0x40 107B 51 MLOAD 107C 80 DUP1 107D 91 SWAP2 107E 03 SUB 107F 90 SWAP1 1080 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1075 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1080 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1081: // Incoming jump from 0x1068, if stack[-3] // Inputs[9] // { // @108A stack[-4] // @109C memory[0x00:0x40] // @109E storage[keccak256(memory[0x00:0x40])] // @10BE stack[-3] // @10EF stack[-1] // @10F9 memory[0x00:0x40] // @10FB storage[keccak256(memory[0x00:0x40])] // @110D block.timestamp // @1121 address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 1081 5B JUMPDEST 1082 60 PUSH1 0x01 1084 60 PUSH1 0x01 1086 60 PUSH1 0xa0 1088 1B SHL 1089 03 SUB 108A 84 DUP5 108B 16 AND 108C 60 PUSH1 0x00 108E 81 DUP2 108F 81 DUP2 1090 52 MSTORE 1091 60 PUSH1 0x05 1093 60 PUSH1 0x20 1095 90 SWAP1 1096 81 DUP2 1097 52 MSTORE 1098 60 PUSH1 0x40 109A 80 DUP1 109B 83 DUP4 109C 20 SHA3 109D 80 DUP1 109E 54 SLOAD 109F 6F PUSH16 0xffffffffffffffffffffffffffffffff 10B0 19 NOT 10B1 81 DUP2 10B2 16 AND 10B3 60 PUSH1 0x01 10B5 60 PUSH1 0x01 10B7 60 PUSH1 0x40 10B9 1B SHL 10BA 03 SUB 10BB 80 DUP1 10BC 83 DUP4 10BD 16 AND 10BE 8B DUP12 10BF 01 ADD 10C0 81 DUP2 10C1 16 AND 10C2 91 SWAP2 10C3 82 DUP3 10C4 17 OR 10C5 68 PUSH9 0x010000000000000000 10CF 67 PUSH8 0xffffffffffffffff 10D8 19 NOT 10D9 90 SWAP1 10DA 94 SWAP5 10DB 16 AND 10DC 90 SWAP1 10DD 92 SWAP3 10DE 17 OR 10DF 83 DUP4 10E0 90 SWAP1 10E1 04 DIV 10E2 81 DUP2 10E3 16 AND 10E4 8B DUP12 10E5 01 ADD 10E6 81 DUP2 10E7 16 AND 10E8 90 SWAP1 10E9 92 SWAP3 10EA 02 MUL 10EB 17 OR 10EC 90 SWAP1 10ED 91 SWAP2 10EE 55 SSTORE 10EF 85 DUP6 10F0 84 DUP5 10F1 52 MSTORE 10F2 60 PUSH1 0x04 10F4 90 SWAP1 10F5 92 SWAP3 10F6 52 MSTORE 10F7 90 SWAP1 10F8 91 SWAP2 10F9 20 SHA3 10FA 80 DUP1 10FB 54 SLOAD 10FC 60 PUSH1 0x01 10FE 60 PUSH1 0x01 1100 60 PUSH1 0xe0 1102 1B SHL 1103 03 SUB 1104 19 NOT 1105 16 AND 1106 83 DUP4 1107 17 OR 1108 60 PUSH1 0x01 110A 60 PUSH1 0xa0 110C 1B SHL 110D 42 TIMESTAMP 110E 90 SWAP1 110F 93 SWAP4 1110 16 AND 1111 92 SWAP3 1112 90 SWAP1 1113 92 SWAP3 1114 02 MUL 1115 91 SWAP2 1116 90 SWAP1 1117 91 SWAP2 1118 17 OR 1119 90 SWAP1 111A 55 SSTORE 111B 81 DUP2 111C 90 SWAP1 111D 81 DUP2 111E 85 DUP6 111F 01 ADD 1120 90 SWAP1 1121 3B EXTCODESIZE 1122 15 ISZERO 1123 61 PUSH2 0x11a9 1126 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @1090 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1097 memory[0x20:0x40] = 0x05 // @10EE storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * ((0x01 << 0x40) - 0x01 & stack[-3] + ((0x01 << 0x40) - 0x01 & (((0x01 << 0x40) - 0x01 & stack[-3] + (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0x40) - 0x01)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | ((0x01 << 0x40) - 0x01 & stack[-3] + (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0x40) - 0x01)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @10F1 memory[0x00:0x20] = stack[-1] // @10F6 memory[0x20:0x40] = 0x04 // @111A storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & block.timestamp) * (0x01 << 0xa0) | (stack[-4] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @111C stack[0] = stack[-1] // @1120 stack[1] = stack[-3] + stack[-1] // } // Block ends with conditional jump to 0x11a9, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_1127: // Incoming jump from 0x1126, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @112A memory[0x40:0x60] // @112B stack[-2] // @1135 stack[-6] // @115F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @116D stack[-4] // } 1127 5B JUMPDEST 1128 60 PUSH1 0x40 112A 51 MLOAD 112B 82 DUP3 112C 90 SWAP1 112D 60 PUSH1 0x01 112F 60 PUSH1 0x01 1131 60 PUSH1 0xa0 1133 1B SHL 1134 03 SUB 1135 88 DUP9 1136 16 AND 1137 90 SWAP1 1138 60 PUSH1 0x00 113A 90 SWAP1 113B 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 115C 90 SWAP1 115D 82 DUP3 115E 90 SWAP1 115F A4 LOG4 1160 61 PUSH2 0x1172 1163 60 PUSH1 0x00 1165 87 DUP8 1166 84 DUP5 1167 80 DUP1 1168 60 PUSH1 0x01 116A 01 ADD 116B 95 SWAP6 116C 50 POP 116D 87 DUP8 116E 61 PUSH2 0x0e1a 1171 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @115F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1160 stack[0] = 0x1172 // @1163 stack[1] = 0x00 // @1165 stack[2] = stack[-6] // @1166 stack[3] = stack[-2] // @116B stack[-2] = 0x01 + stack[-2] // @116D stack[4] = stack[-4] // } // Block ends with unconditional jump to 0x0e1a 1172 5B JUMPDEST 1173 61 PUSH2 0x118f 1176 57 *JUMPI 1177 60 PUSH1 0x40 1179 51 MLOAD 117A 63 PUSH4 0x68d2bf6b 117F 60 PUSH1 0xe1 1181 1B SHL 1182 81 DUP2 1183 52 MSTORE 1184 60 PUSH1 0x04 1186 01 ADD 1187 60 PUSH1 0x40 1189 51 MLOAD 118A 80 DUP1 118B 91 SWAP2 118C 03 SUB 118D 90 SWAP1 118E FD *REVERT 118F 5B JUMPDEST 1190 80 DUP1 1191 82 DUP3 1192 10 LT 1193 61 PUSH2 0x1127 1196 57 *JUMPI 1197 82 DUP3 1198 60 PUSH1 0x00 119A 54 SLOAD 119B 14 EQ 119C 61 PUSH2 0x11a4 119F 57 *JUMPI 11A0 60 PUSH1 0x00 11A2 80 DUP1 11A3 FD *REVERT 11A4 5B JUMPDEST 11A5 61 PUSH2 0x11ee 11A8 56 *JUMP label_11A9: // Incoming jump from 0x1126, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @11AD memory[0x40:0x60] // @11B0 stack[-2] // @11BC stack[-6] // @11E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @11E7 stack[-1] // } 11A9 5B JUMPDEST 11AA 5B JUMPDEST 11AB 60 PUSH1 0x40 11AD 51 MLOAD 11AE 60 PUSH1 0x01 11B0 83 DUP4 11B1 01 ADD 11B2 92 SWAP3 11B3 90 SWAP1 11B4 60 PUSH1 0x01 11B6 60 PUSH1 0x01 11B8 60 PUSH1 0xa0 11BA 1B SHL 11BB 03 SUB 11BC 88 DUP9 11BD 16 AND 11BE 90 SWAP1 11BF 60 PUSH1 0x00 11C1 90 SWAP1 11C2 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 11E3 90 SWAP1 11E4 82 DUP3 11E5 90 SWAP1 11E6 A4 LOG4 11E7 80 DUP1 11E8 82 DUP3 11E9 10 LT 11EA 61 PUSH2 0x11aa 11ED 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @11B2 stack[-2] = stack[-2] + 0x01 // @11E6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x11aa, if stack[-2] + 0x01 < stack[-1] label_11EE: // Incoming jump from 0x11ED, if not stack[-2] + 0x01 < stack[-1] // Incoming jump from 0x11ED, if not stack[-2] + 0x01 < stack[-1] // Inputs[4] // { // @11F2 stack[-2] // @11F9 stack[-6] // @11FA stack[-3] // @11FB stack[-5] // } 11EE 5B JUMPDEST 11EF 50 POP 11F0 60 PUSH1 0x00 11F2 90 SWAP1 11F3 81 DUP2 11F4 55 SSTORE 11F5 61 PUSH2 0x0856 11F8 90 SWAP1 11F9 85 DUP6 11FA 83 DUP4 11FB 86 DUP7 11FC 84 DUP5 11FD 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @11F4 storage[0x00] = stack[-2] // @11F8 stack[-2] = 0x0856 // @11F8 stack[-1] = 0x00 // @11F9 stack[0] = stack[-6] // @11FA stack[1] = stack[-3] // @11FB stack[2] = stack[-5] // } // Block ends with call to 0x0856, returns to 0x0856 label_11FE: // Incoming jump from 0x0530 // Inputs[2] // { // @11FF stack[-3] // @1201 storage[stack[-3]] // } 11FE 5B JUMPDEST 11FF 82 DUP3 1200 80 DUP1 1201 54 SLOAD 1202 61 PUSH2 0x120a 1205 90 SWAP1 1206 61 PUSH2 0x1816 1209 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11FF stack[0] = stack[-3] // @1205 stack[1] = 0x120a // @1205 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1816, returns to 0x120A label_120A: // Incoming return from call to 0x1816 at 0x1209 // Inputs[5] // { // @120B stack[-2] // @120B stack[-1] // @1213 memory[0x00:0x20] // @121E stack[-4] // @121F stack[-3] // } 120A 5B JUMPDEST 120B 90 SWAP1 120C 60 PUSH1 0x00 120E 52 MSTORE 120F 60 PUSH1 0x20 1211 60 PUSH1 0x00 1213 20 SHA3 1214 90 SWAP1 1215 60 PUSH1 0x1f 1217 01 ADD 1218 60 PUSH1 0x20 121A 90 SWAP1 121B 04 DIV 121C 81 DUP2 121D 01 ADD 121E 92 SWAP3 121F 82 DUP3 1220 61 PUSH2 0x122c 1223 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @120E memory[0x00:0x20] = stack[-2] // @1214 stack[-2] = keccak256(memory[0x00:0x20]) // @121E stack[-1] = stack[-4] // @121E stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x122c, if stack[-3] label_1224: // Incoming jump from 0x1223, if not stack[-3] // Inputs[1] { @1226 stack[-5] } 1224 60 PUSH1 0x00 1226 85 DUP6 1227 55 SSTORE 1228 61 PUSH2 0x1272 122B 56 *JUMP // Stack delta = +0 // Outputs[1] { @1227 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1272 label_122C: // Incoming jump from 0x1223, if stack[-3] // Inputs[1] { @122D stack[-3] } 122C 5B JUMPDEST 122D 82 DUP3 122E 60 PUSH1 0x1f 1230 10 LT 1231 61 PUSH2 0x1245 1234 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1245, if 0x1f < stack[-3] label_1235: // Incoming jump from 0x1234, if not 0x1f < stack[-3] // Inputs[4] // { // @1235 stack[-1] // @1236 memory[stack[-1]:stack[-1] + 0x20] // @123B stack[-3] // @123F stack[-5] // } 1235 80 DUP1 1236 51 MLOAD 1237 60 PUSH1 0xff 1239 19 NOT 123A 16 AND 123B 83 DUP4 123C 80 DUP1 123D 01 ADD 123E 17 OR 123F 85 DUP6 1240 55 SSTORE 1241 61 PUSH2 0x1272 1244 56 *JUMP // Stack delta = +0 // Outputs[1] { @1240 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1272 label_1245: // Incoming jump from 0x1234, if 0x1f < stack[-3] // Inputs[2] // { // @1246 stack[-3] // @124C stack[-5] // } 1245 5B JUMPDEST 1246 82 DUP3 1247 80 DUP1 1248 01 ADD 1249 60 PUSH1 0x01 124B 01 ADD 124C 85 DUP6 124D 55 SSTORE 124E 82 DUP3 124F 15 ISZERO 1250 61 PUSH2 0x1272 1253 57 *JUMPI // Stack delta = +0 // Outputs[1] { @124D storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1272, if !stack[-3] label_1254: // Incoming jump from 0x1253, if not !stack[-3] // Inputs[2] // { // @1254 stack[-1] // @1254 stack[-3] // } 1254 91 SWAP2 1255 82 DUP3 1256 01 ADD 1257 5B JUMPDEST 1258 82 DUP3 1259 81 DUP2 125A 11 GT 125B 15 ISZERO 125C 61 PUSH2 0x1272 125F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1254 stack[-3] = stack[-1] // @1256 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1272, if !(stack[-1] + stack[-3] > stack[-1]) label_1260: // Incoming jump from 0x125F, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x125F, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1260 stack[-3] // @1261 memory[stack[-3]:stack[-3] + 0x20] // @1262 stack[-2] // @1264 stack[-1] // } 1260 82 DUP3 1261 51 MLOAD 1262 82 DUP3 1263 55 SSTORE 1264 91 SWAP2 1265 60 PUSH1 0x20 1267 01 ADD 1268 91 SWAP2 1269 90 SWAP1 126A 60 PUSH1 0x01 126C 01 ADD 126D 90 SWAP1 126E 61 PUSH2 0x1257 1271 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1263 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1268 stack[-3] = 0x20 + stack[-3] // @126D stack[-2] = 0x01 + stack[-2] // @126D stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1257 label_1272: // Incoming jump from 0x125F, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1253, if !stack[-3] // Incoming jump from 0x125F, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1244 // Incoming jump from 0x122B // Inputs[2] // { // @1277 stack[-4] // @1278 stack[-3] // } 1272 5B JUMPDEST 1273 50 POP 1274 61 PUSH2 0x127e 1277 92 SWAP3 1278 91 SWAP2 1279 50 POP 127A 61 PUSH2 0x1282 127D 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1277 stack[-4] = 0x127e // @1278 stack[-3] = stack[-4] // } // Block ends with call to 0x1282, returns to 0x127E label_127E: // Incoming return from call to 0x1282 at 0x127D // Incoming jump from 0x128B, if !(stack[-2] > stack[-1]) // Incoming jump from 0x128B, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1280 stack[-3] // @1280 stack[-2] // } 127E 5B JUMPDEST 127F 50 POP 1280 90 SWAP1 1281 56 *JUMP // Stack delta = -2 // Outputs[1] { @1280 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1282: // Incoming call from 0x127D, returns to 0x127E // Inputs[2] // { // @1284 stack[-1] // @1285 stack[-2] // } 1282 5B JUMPDEST 1283 5B JUMPDEST 1284 80 DUP1 1285 82 DUP3 1286 11 GT 1287 15 ISZERO 1288 61 PUSH2 0x127e 128B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x127e, if !(stack[-2] > stack[-1]) label_128C: // Incoming jump from 0x128B, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x128B, if not !(stack[-2] > stack[-1]) // Inputs[1] { @128E stack[-1] } 128C 60 PUSH1 0x00 128E 81 DUP2 128F 55 SSTORE 1290 60 PUSH1 0x01 1292 01 ADD 1293 61 PUSH2 0x1283 1296 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @128F storage[stack[-1]] = 0x00 // @1292 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1283 label_1297: // Incoming call from 0x1617, returns to 0x0F0A // Incoming call from 0x146B, returns to 0x146C // Inputs[1] { @12A2 stack[-2] } 1297 5B JUMPDEST 1298 60 PUSH1 0x00 129A 60 PUSH1 0x01 129C 60 PUSH1 0x01 129E 60 PUSH1 0x40 12A0 1B SHL 12A1 03 SUB 12A2 83 DUP4 12A3 11 GT 12A4 15 ISZERO 12A5 61 PUSH2 0x12b0 12A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1298 stack[0] = 0x00 } // Block ends with conditional jump to 0x12b0, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_12A9: // Incoming jump from 0x12A8, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 12A9 61 PUSH2 0x12b0 12AC 61 PUSH2 0x18ac 12AF 56 *JUMP // Stack delta = +1 // Outputs[1] { @12A9 stack[0] = 0x12b0 } // Block ends with unconditional jump to 0x18ac label_12B0: // Incoming jump from 0x12A8, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[1] { @12B6 stack[-3] } 12B0 5B JUMPDEST 12B1 61 PUSH2 0x12c3 12B4 60 PUSH1 0x1f 12B6 84 DUP5 12B7 01 ADD 12B8 60 PUSH1 0x1f 12BA 19 NOT 12BB 16 AND 12BC 60 PUSH1 0x20 12BE 01 ADD 12BF 61 PUSH2 0x1754 12C2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12B1 stack[0] = 0x12c3 // @12BE stack[1] = 0x20 + (~0x1f & stack[-3] + 0x1f) // } // Block ends with call to 0x1754, returns to 0x12C3 label_12C3: // Incoming return from call to 0x1754 at 0x12C2 // Inputs[5] // { // @12C4 stack[-1] // @12C4 stack[-2] // @12C6 stack[-4] // @12C9 stack[-5] // @12CB stack[-3] // } 12C3 5B JUMPDEST 12C4 90 SWAP1 12C5 50 POP 12C6 82 DUP3 12C7 81 DUP2 12C8 52 MSTORE 12C9 83 DUP4 12CA 83 DUP4 12CB 83 DUP4 12CC 01 ADD 12CD 11 GT 12CE 15 ISZERO 12CF 61 PUSH2 0x12d7 12D2 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @12C4 stack[-2] = stack[-1] // @12C8 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x12d7, if !(stack[-3] + stack[-4] > stack[-5]) label_12D3: // Incoming jump from 0x12D2, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @12D6 memory[0x00:0x00] } 12D3 60 PUSH1 0x00 12D5 80 DUP1 12D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @12D6 revert(memory[0x00:0x00]); } // Block terminates label_12D7: // Incoming jump from 0x12D2, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[6] // { // @12D8 stack[-3] // @12D9 stack[-2] // @12DC stack[-1] // @12DE msg.data[stack[-2]:stack[-2] + stack[-3]] // @12E8 stack[-5] // @12E9 stack[-4] // } 12D7 5B JUMPDEST 12D8 82 DUP3 12D9 82 DUP3 12DA 60 PUSH1 0x20 12DC 83 DUP4 12DD 01 ADD 12DE 37 CALLDATACOPY 12DF 60 PUSH1 0x00 12E1 60 PUSH1 0x20 12E3 84 DUP5 12E4 83 DUP4 12E5 01 ADD 12E6 01 ADD 12E7 52 MSTORE 12E8 93 SWAP4 12E9 92 SWAP3 12EA 50 POP 12EB 50 POP 12EC 50 POP 12ED 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @12DE memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-2]:stack[-2] + stack[-3]] // @12E7 memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @12E8 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_12EE: // Incoming call from 0x141D, returns to 0x141E // Incoming call from 0x1392, returns to 0x08DA // Incoming call from 0x13AD, returns to 0x13AE // Incoming call from 0x13BB, returns to 0x13BC // Incoming call from 0x13EF, returns to 0x13F0 // Incoming call from 0x14CC, returns to 0x14CD // Incoming call from 0x1559, returns to 0x155A // Incoming call from 0x13E1, returns to 0x13E2 // Incoming call from 0x1492, returns to 0x1493 // Incoming call from 0x142B, returns to 0x142C // Inputs[2] // { // @12EF stack[-1] // @12F0 msg.data[stack[-1]:stack[-1] + 0x20] // } 12EE 5B JUMPDEST 12EF 80 DUP1 12F0 35 CALLDATALOAD 12F1 60 PUSH1 0x01 12F3 60 PUSH1 0x01 12F5 60 PUSH1 0xa0 12F7 1B SHL 12F8 03 SUB 12F9 81 DUP2 12FA 16 AND 12FB 81 DUP2 12FC 14 EQ 12FD 61 PUSH2 0x1305 1300 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12F0 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1305, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1301: // Incoming jump from 0x1300, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1304 memory[0x00:0x00] } 1301 60 PUSH1 0x00 1303 80 DUP1 1304 FD *REVERT // Stack delta = +0 // Outputs[1] { @1304 revert(memory[0x00:0x00]); } // Block terminates label_1305: // Incoming jump from 0x1300, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1306 stack[-1] // @1306 stack[-3] // @1307 stack[-2] // } 1305 5B JUMPDEST 1306 91 SWAP2 1307 90 SWAP1 1308 50 POP 1309 56 *JUMP // Stack delta = -2 // Outputs[1] { @1306 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_130A: // Incoming call from 0x1590, returns to 0x1591 // Inputs[2] // { // @130D stack[-2] // @1310 stack[-1] // } 130A 5B JUMPDEST 130B 60 PUSH1 0x00 130D 82 DUP3 130E 60 PUSH1 0x1f 1310 83 DUP4 1311 01 ADD 1312 12 SLT 1313 61 PUSH2 0x131a 1316 57 *JUMPI // Stack delta = +1 // Outputs[1] { @130B stack[0] = 0x00 } // Block ends with conditional jump to 0x131a, if stack[-1] + 0x1f i< stack[-2] label_1317: // Incoming jump from 0x1316, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1317 stack[-1] // @1319 memory[stack[-1]:stack[-1] + stack[-1]] // } 1317 80 DUP1 1318 81 DUP2 1319 FD *REVERT // Stack delta = +0 // Outputs[1] { @1319 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_131A: // Incoming jump from 0x1316, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @131B stack[-2] // @131C msg.data[stack[-2]:stack[-2] + 0x20] // } 131A 5B JUMPDEST 131B 81 DUP2 131C 35 CALLDATALOAD 131D 60 PUSH1 0x20 131F 61 PUSH2 0x132f 1322 61 PUSH2 0x132a 1325 83 DUP4 1326 61 PUSH2 0x1784 1329 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @131C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @131D stack[1] = 0x20 // @131F stack[2] = 0x132f // @1322 stack[3] = 0x132a // @1325 stack[4] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1784, returns to 0x132A label_132A: // Incoming return from call to 0x1784 at 0x1329 // Incoming return from call to 0x1784 at 0x1525 132A 5B JUMPDEST 132B 61 PUSH2 0x1754 132E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1754 label_132F: // Incoming return from call to 0x132A at 0x1329 // Inputs[5] // { // @1330 stack[-1] // @1331 stack[-3] // @1334 stack[-2] // @133A stack[-5] // @133C stack[-6] // } 132F 5B JUMPDEST 1330 80 DUP1 1331 83 DUP4 1332 82 DUP3 1333 52 MSTORE 1334 82 DUP3 1335 82 DUP3 1336 01 ADD 1337 91 SWAP2 1338 50 POP 1339 82 DUP3 133A 86 DUP7 133B 01 ADD 133C 87 DUP8 133D 84 DUP5 133E 86 DUP7 133F 60 PUSH1 0x05 1341 1B SHL 1342 89 DUP10 1343 01 ADD 1344 01 ADD 1345 11 GT 1346 15 ISZERO 1347 61 PUSH2 0x134e 134A 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1330 stack[0] = stack[-1] // @1333 memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @1337 stack[-1] = stack[-1] + stack[-2] // @133B stack[1] = stack[-5] + stack[-2] // } // Block ends with conditional jump to 0x134e, if !(stack[-5] + (stack[-3] << 0x05) + stack[-2] > stack[-6]) label_134B: // Incoming jump from 0x134A, if not !(stack[-5] + (stack[-3] << 0x05) + stack[-2] > stack[-6]) // Inputs[2] // { // @134B stack[-6] // @134D memory[stack[-6]:stack[-6] + stack[-6]] // } 134B 85 DUP6 134C 86 DUP7 134D FD *REVERT // Stack delta = +0 // Outputs[1] { @134D revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_134E: // Incoming jump from 0x134A, if !(stack[-5] + (stack[-3] << 0x05) + stack[-2] > stack[-6]) // Inputs[2] // { // @134F stack[-6] // @1351 stack[-5] // } 134E 5B JUMPDEST 134F 85 DUP6 1350 5B JUMPDEST 1351 85 DUP6 1352 81 DUP2 1353 10 LT 1354 15 ISZERO 1355 61 PUSH2 0x136c 1358 57 *JUMPI // Stack delta = +1 // Outputs[1] { @134F stack[0] = stack[-6] } // Block ends with conditional jump to 0x136c, if !(stack[-6] < stack[-5]) label_1359: // Incoming jump from 0x1358, if not !(stack[-6] < stack[-5]) // Incoming jump from 0x1358, if not !(stack[-1] < stack[-6]) // Inputs[5] // { // @1359 stack[-2] // @135A msg.data[stack[-2]:stack[-2] + 0x20] // @135B stack[-4] // @135D stack[-1] // @135E stack[-5] // } 1359 81 DUP2 135A 35 CALLDATALOAD 135B 84 DUP5 135C 52 MSTORE 135D 92 SWAP3 135E 84 DUP5 135F 01 ADD 1360 92 SWAP3 1361 90 SWAP1 1362 84 DUP5 1363 01 ADD 1364 90 SWAP1 1365 60 PUSH1 0x01 1367 01 ADD 1368 61 PUSH2 0x1350 136B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @135C memory[stack[-4]:stack[-4] + 0x20] = msg.data[stack[-2]:stack[-2] + 0x20] // @1360 stack[-4] = stack[-5] + stack[-4] // @1364 stack[-2] = stack[-5] + stack[-2] // @1367 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1350 label_136C: // Incoming jump from 0x1358, if !(stack[-6] < stack[-5]) // Incoming jump from 0x1358, if !(stack[-1] < stack[-6]) // Inputs[4] // { // @136E stack[-3] // @136E stack[-2] // @136F stack[-10] // @1370 stack[-9] // } 136C 5B JUMPDEST 136D 50 POP 136E 90 SWAP1 136F 97 SWAP8 1370 96 SWAP7 1371 50 POP 1372 50 POP 1373 50 POP 1374 50 POP 1375 50 POP 1376 50 POP 1377 50 POP 1378 56 *JUMP // Stack delta = -9 // Outputs[1] { @136F stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_1379: // Incoming call from 0x025A, returns to 0x025B // Incoming call from 0x0310, returns to 0x0311 // Incoming call from 0x022C, returns to 0x022D // Inputs[2] // { // @137E stack[-1] // @137F stack[-2] // } 1379 5B JUMPDEST 137A 60 PUSH1 0x00 137C 60 PUSH1 0x20 137E 82 DUP3 137F 84 DUP5 1380 03 SUB 1381 12 SLT 1382 15 ISZERO 1383 61 PUSH2 0x138a 1386 57 *JUMPI // Stack delta = +1 // Outputs[1] { @137A stack[0] = 0x00 } // Block ends with conditional jump to 0x138a, if !(stack[-2] - stack[-1] i< 0x20) label_1387: // Incoming jump from 0x1386, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1387 stack[-1] // @1389 memory[stack[-1]:stack[-1] + stack[-1]] // } 1387 80 DUP1 1388 81 DUP2 1389 FD *REVERT // Stack delta = +0 // Outputs[1] { @1389 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_138A: // Incoming jump from 0x1386, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @138E stack[-2] } 138A 5B JUMPDEST 138B 61 PUSH2 0x08da 138E 82 DUP3 138F 61 PUSH2 0x12ee 1392 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @138B stack[0] = 0x08da // @138E stack[1] = stack[-2] // } // Block ends with call to 0x12ee, returns to 0x08DA label_1393: // Incoming call from 0x02D4, returns to 0x02D5 // Inputs[2] // { // @1399 stack[-1] // @139A stack[-2] // } 1393 5B JUMPDEST 1394 60 PUSH1 0x00 1396 80 DUP1 1397 60 PUSH1 0x40 1399 83 DUP4 139A 85 DUP6 139B 03 SUB 139C 12 SLT 139D 15 ISZERO 139E 61 PUSH2 0x13a5 13A1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1394 stack[0] = 0x00 // @1396 stack[1] = 0x00 // } // Block ends with conditional jump to 0x13a5, if !(stack[-2] - stack[-1] i< 0x40) label_13A2: // Incoming jump from 0x13A1, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @13A2 stack[-1] // @13A4 memory[stack[-1]:stack[-1] + stack[-1]] // } 13A2 80 DUP1 13A3 81 DUP2 13A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @13A4 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_13A5: // Incoming jump from 0x13A1, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @13A9 stack[-3] } 13A5 5B JUMPDEST 13A6 61 PUSH2 0x13ae 13A9 83 DUP4 13AA 61 PUSH2 0x12ee 13AD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13A6 stack[0] = 0x13ae // @13A9 stack[1] = stack[-3] // } // Block ends with call to 0x12ee, returns to 0x13AE label_13AE: // Incoming return from call to 0x12EE at 0x13AD // Inputs[3] // { // @13AF stack[-1] // @13AF stack[-3] // @13B6 stack[-4] // } 13AE 5B JUMPDEST 13AF 91 SWAP2 13B0 50 POP 13B1 61 PUSH2 0x13bc 13B4 60 PUSH1 0x20 13B6 84 DUP5 13B7 01 ADD 13B8 61 PUSH2 0x12ee 13BB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @13AF stack[-3] = stack[-1] // @13B1 stack[-1] = 0x13bc // @13B7 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x12ee, returns to 0x13BC label_13BC: // Incoming return from call to 0x12EE at 0x13BB // Inputs[6] // { // @13BD stack[-1] // @13BD stack[-2] // @13BF stack[-5] // @13C1 stack[-3] // @13C1 stack[-6] // @13C2 stack[-4] // } 13BC 5B JUMPDEST 13BD 90 SWAP1 13BE 50 POP 13BF 92 SWAP3 13C0 50 POP 13C1 92 SWAP3 13C2 90 SWAP1 13C3 50 POP 13C4 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @13BF stack[-5] = stack[-1] // @13C1 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_13C5: // Incoming call from 0x01F3, returns to 0x01F4 // Incoming call from 0x01E0, returns to 0x01E1 // Inputs[2] // { // @13CD stack[-1] // @13CE stack[-2] // } 13C5 5B JUMPDEST 13C6 60 PUSH1 0x00 13C8 80 DUP1 13C9 60 PUSH1 0x00 13CB 60 PUSH1 0x60 13CD 84 DUP5 13CE 86 DUP7 13CF 03 SUB 13D0 12 SLT 13D1 15 ISZERO 13D2 61 PUSH2 0x13d9 13D5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @13C6 stack[0] = 0x00 // @13C8 stack[1] = 0x00 // @13C9 stack[2] = 0x00 // } // Block ends with conditional jump to 0x13d9, if !(stack[-2] - stack[-1] i< 0x60) label_13D6: // Incoming jump from 0x13D5, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @13D6 stack[-1] // @13D8 memory[stack[-1]:stack[-1] + stack[-1]] // } 13D6 80 DUP1 13D7 81 DUP2 13D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @13D8 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_13D9: // Incoming jump from 0x13D5, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @13DD stack[-4] } 13D9 5B JUMPDEST 13DA 61 PUSH2 0x13e2 13DD 84 DUP5 13DE 61 PUSH2 0x12ee 13E1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13DA stack[0] = 0x13e2 // @13DD stack[1] = stack[-4] // } // Block ends with call to 0x12ee, returns to 0x13E2 label_13E2: // Incoming return from call to 0x12EE at 0x13E1 // Inputs[3] // { // @13E3 stack[-1] // @13E3 stack[-4] // @13EA stack[-5] // } 13E2 5B JUMPDEST 13E3 92 SWAP3 13E4 50 POP 13E5 61 PUSH2 0x13f0 13E8 60 PUSH1 0x20 13EA 85 DUP6 13EB 01 ADD 13EC 61 PUSH2 0x12ee 13EF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @13E3 stack[-4] = stack[-1] // @13E5 stack[-1] = 0x13f0 // @13EB stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x12ee, returns to 0x13F0 label_13F0: // Incoming return from call to 0x12EE at 0x13EF // Inputs[8] // { // @13F1 stack[-1] // @13F1 stack[-3] // @13F5 stack[-5] // @13F7 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @13F8 stack[-2] // @13FC stack[-6] // @13FE stack[-4] // @13FE stack[-7] // } 13F0 5B JUMPDEST 13F1 91 SWAP2 13F2 50 POP 13F3 60 PUSH1 0x40 13F5 84 DUP5 13F6 01 ADD 13F7 35 CALLDATALOAD 13F8 90 SWAP1 13F9 50 POP 13FA 92 SWAP3 13FB 50 POP 13FC 92 SWAP3 13FD 50 POP 13FE 92 SWAP3 13FF 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @13FA stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @13FC stack[-6] = stack[-1] // @13FE stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1400: // Incoming call from 0x02A6, returns to 0x02A7 // Inputs[2] // { // @1409 stack[-1] // @140A stack[-2] // } 1400 5B JUMPDEST 1401 60 PUSH1 0x00 1403 80 DUP1 1404 60 PUSH1 0x00 1406 80 DUP1 1407 60 PUSH1 0x80 1409 85 DUP6 140A 87 DUP8 140B 03 SUB 140C 12 SLT 140D 15 ISZERO 140E 61 PUSH2 0x1415 1411 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1401 stack[0] = 0x00 // @1403 stack[1] = 0x00 // @1404 stack[2] = 0x00 // @1406 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1415, if !(stack[-2] - stack[-1] i< 0x80) label_1412: // Incoming jump from 0x1411, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1412 stack[-1] // @1414 memory[stack[-1]:stack[-1] + stack[-1]] // } 1412 80 DUP1 1413 81 DUP2 1414 FD *REVERT // Stack delta = +0 // Outputs[1] { @1414 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1415: // Incoming jump from 0x1411, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1419 stack[-5] } 1415 5B JUMPDEST 1416 61 PUSH2 0x141e 1419 85 DUP6 141A 61 PUSH2 0x12ee 141D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1416 stack[0] = 0x141e // @1419 stack[1] = stack[-5] // } // Block ends with call to 0x12ee, returns to 0x141E label_141E: // Incoming return from call to 0x12EE at 0x141D // Inputs[3] // { // @141F stack[-5] // @141F stack[-1] // @1426 stack[-6] // } 141E 5B JUMPDEST 141F 93 SWAP4 1420 50 POP 1421 61 PUSH2 0x142c 1424 60 PUSH1 0x20 1426 86 DUP7 1427 01 ADD 1428 61 PUSH2 0x12ee 142B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @141F stack[-5] = stack[-1] // @1421 stack[-1] = 0x142c // @1427 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x12ee, returns to 0x142C label_142C: // Incoming return from call to 0x12EE at 0x142B // Inputs[6] // { // @142D stack[-1] // @142D stack[-4] // @1431 stack[-6] // @1433 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1434 stack[-3] // @143A msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 142C 5B JUMPDEST 142D 92 SWAP3 142E 50 POP 142F 60 PUSH1 0x40 1431 85 DUP6 1432 01 ADD 1433 35 CALLDATALOAD 1434 91 SWAP2 1435 50 POP 1436 60 PUSH1 0x60 1438 85 DUP6 1439 01 ADD 143A 35 CALLDATALOAD 143B 60 PUSH1 0x01 143D 60 PUSH1 0x01 143F 60 PUSH1 0x40 1441 1B SHL 1442 03 SUB 1443 81 DUP2 1444 11 GT 1445 15 ISZERO 1446 61 PUSH2 0x144d 1449 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @142D stack[-4] = stack[-1] // @1434 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @143A stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x144d, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) label_144A: // Incoming jump from 0x1449, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @144A stack[-2] // @144C memory[stack[-2]:stack[-2] + stack[-2]] // } 144A 81 DUP2 144B 82 DUP3 144C FD *REVERT // Stack delta = +0 // Outputs[1] { @144C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_144D: // Incoming jump from 0x1449, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @144E stack[-6] // @144F stack[-1] // @1454 stack[-7] // } 144D 5B JUMPDEST 144E 85 DUP6 144F 01 ADD 1450 60 PUSH1 0x1f 1452 81 DUP2 1453 01 ADD 1454 87 DUP8 1455 13 SGT 1456 61 PUSH2 0x145d 1459 57 *JUMPI // Stack delta = +0 // Outputs[1] { @144F stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x145d, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_145A: // Incoming jump from 0x1459, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @145A stack[-2] // @145C memory[stack[-2]:stack[-2] + stack[-2]] // } 145A 81 DUP2 145B 82 DUP3 145C FD *REVERT // Stack delta = +0 // Outputs[1] { @145C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_145D: // Incoming jump from 0x1459, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @1461 stack[-7] // @1462 stack[-1] // @1463 msg.data[stack[-1]:stack[-1] + 0x20] // } 145D 5B JUMPDEST 145E 61 PUSH2 0x146c 1461 87 DUP8 1462 82 DUP3 1463 35 CALLDATALOAD 1464 60 PUSH1 0x20 1466 84 DUP5 1467 01 ADD 1468 61 PUSH2 0x1297 146B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @145E stack[0] = 0x146c // @1461 stack[1] = stack[-7] // @1463 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1467 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1297, returns to 0x146C label_146C: // Incoming return from call to 0x1297 at 0x146B // Inputs[8] // { // @146D stack[-1] // @146D stack[-3] // @1470 stack[-6] // @1471 stack[-9] // @1472 stack[-5] // @1473 stack[-8] // @1475 stack[-4] // @1475 stack[-7] // } 146C 5B JUMPDEST 146D 91 SWAP2 146E 50 POP 146F 50 POP 1470 92 SWAP3 1471 95 SWAP6 1472 91 SWAP2 1473 94 SWAP5 1474 50 POP 1475 92 SWAP3 1476 50 POP 1477 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1470 stack[-6] = stack[-1] // @1471 stack[-9] = stack[-6] // @1473 stack[-8] = stack[-5] // @1475 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1478: // Incoming call from 0x0293, returns to 0x0294 // Inputs[2] // { // @147E stack[-1] // @147F stack[-2] // } 1478 5B JUMPDEST 1479 60 PUSH1 0x00 147B 80 DUP1 147C 60 PUSH1 0x40 147E 83 DUP4 147F 85 DUP6 1480 03 SUB 1481 12 SLT 1482 15 ISZERO 1483 61 PUSH2 0x148a 1486 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1479 stack[0] = 0x00 // @147B stack[1] = 0x00 // } // Block ends with conditional jump to 0x148a, if !(stack[-2] - stack[-1] i< 0x40) label_1487: // Incoming jump from 0x1486, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1487 stack[-2] // @1489 memory[stack[-2]:stack[-2] + stack[-2]] // } 1487 81 DUP2 1488 82 DUP3 1489 FD *REVERT // Stack delta = +0 // Outputs[1] { @1489 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_148A: // Incoming jump from 0x1486, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @148E stack[-3] } 148A 5B JUMPDEST 148B 61 PUSH2 0x1493 148E 83 DUP4 148F 61 PUSH2 0x12ee 1492 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @148B stack[0] = 0x1493 // @148E stack[1] = stack[-3] // } // Block ends with call to 0x12ee, returns to 0x1493 label_1493: // Incoming return from call to 0x12EE at 0x1492 // Inputs[4] // { // @1494 stack[-3] // @1494 stack[-1] // @1498 stack[-4] // @149A msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1493 5B JUMPDEST 1494 91 SWAP2 1495 50 POP 1496 60 PUSH1 0x20 1498 83 DUP4 1499 01 ADD 149A 35 CALLDATALOAD 149B 80 DUP1 149C 15 ISZERO 149D 15 ISZERO 149E 81 DUP2 149F 14 EQ 14A0 61 PUSH2 0x14a7 14A3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1494 stack[-3] = stack[-1] // @149A stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x14a7, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_14A4: // Incoming jump from 0x14A3, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @14A4 stack[-2] // @14A6 memory[stack[-2]:stack[-2] + stack[-2]] // } 14A4 81 DUP2 14A5 82 DUP3 14A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @14A6 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_14A7: // Incoming jump from 0x14A3, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @14A8 stack[-1] // @14A9 stack[-2] // @14AC stack[-5] // @14AE stack[-3] // @14AE stack[-6] // @14AF stack[-4] // } 14A7 5B JUMPDEST 14A8 80 DUP1 14A9 91 SWAP2 14AA 50 POP 14AB 50 POP 14AC 92 SWAP3 14AD 50 POP 14AE 92 SWAP3 14AF 90 SWAP1 14B0 50 POP 14B1 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @14AC stack[-5] = stack[-1] // @14AE stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_14B2: // Incoming call from 0x01B1, returns to 0x01B2 // Inputs[2] // { // @14B8 stack[-1] // @14B9 stack[-2] // } 14B2 5B JUMPDEST 14B3 60 PUSH1 0x00 14B5 80 DUP1 14B6 60 PUSH1 0x40 14B8 83 DUP4 14B9 85 DUP6 14BA 03 SUB 14BB 12 SLT 14BC 15 ISZERO 14BD 61 PUSH2 0x14c4 14C0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14B3 stack[0] = 0x00 // @14B5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x14c4, if !(stack[-2] - stack[-1] i< 0x40) label_14C1: // Incoming jump from 0x14C0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @14C1 stack[-2] // @14C3 memory[stack[-2]:stack[-2] + stack[-2]] // } 14C1 81 DUP2 14C2 82 DUP3 14C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @14C3 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_14C4: // Incoming jump from 0x14C0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @14C8 stack[-3] } 14C4 5B JUMPDEST 14C5 61 PUSH2 0x14cd 14C8 83 DUP4 14C9 61 PUSH2 0x12ee 14CC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14C5 stack[0] = 0x14cd // @14C8 stack[1] = stack[-3] // } // Block ends with call to 0x12ee, returns to 0x14CD label_14CD: // Incoming return from call to 0x12EE at 0x14CC // Inputs[5] // { // @14CE stack[-1] // @14CE stack[-6] // @14D1 stack[-4] // @14D5 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @14D6 stack[-5] // } 14CD 5B JUMPDEST 14CE 94 SWAP5 14CF 60 PUSH1 0x20 14D1 93 SWAP4 14D2 90 SWAP1 14D3 93 SWAP4 14D4 01 ADD 14D5 35 CALLDATALOAD 14D6 93 SWAP4 14D7 50 POP 14D8 50 POP 14D9 50 POP 14DA 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @14CE stack[-6] = stack[-1] // @14D6 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_14DB: // Incoming call from 0x0247, returns to 0x0248 // Inputs[2] // { // @14E1 stack[-1] // @14E2 stack[-2] // } 14DB 5B JUMPDEST 14DC 60 PUSH1 0x00 14DE 80 DUP1 14DF 60 PUSH1 0x40 14E1 83 DUP4 14E2 85 DUP6 14E3 03 SUB 14E4 12 SLT 14E5 15 ISZERO 14E6 61 PUSH2 0x14ed 14E9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14DC stack[0] = 0x00 // @14DE stack[1] = 0x00 // } // Block ends with conditional jump to 0x14ed, if !(stack[-2] - stack[-1] i< 0x40) label_14EA: // Incoming jump from 0x14E9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @14EA stack[-2] // @14EC memory[stack[-2]:stack[-2] + stack[-2]] // } 14EA 81 DUP2 14EB 82 DUP3 14EC FD *REVERT // Stack delta = +0 // Outputs[1] { @14EC revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_14ED: // Incoming jump from 0x14E9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @14EE stack[-3] // @14EF msg.data[stack[-3]:stack[-3] + 0x20] // } 14ED 5B JUMPDEST 14EE 82 DUP3 14EF 35 CALLDATALOAD 14F0 60 PUSH1 0x01 14F2 60 PUSH1 0x01 14F4 60 PUSH1 0x40 14F6 1B SHL 14F7 03 SUB 14F8 80 DUP1 14F9 82 DUP3 14FA 11 GT 14FB 15 ISZERO 14FC 61 PUSH2 0x1503 14FF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14EF stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @14F7 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x1503, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_1500: // Incoming jump from 0x14FF, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @1500 stack[-4] // @1502 memory[stack[-4]:stack[-4] + stack[-4]] // } 1500 83 DUP4 1501 84 DUP5 1502 FD *REVERT // Stack delta = +0 // Outputs[1] { @1502 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1503: // Incoming jump from 0x14FF, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1504 stack[-2] // @1505 stack[-5] // @1509 stack[-6] // } 1503 5B JUMPDEST 1504 81 DUP2 1505 85 DUP6 1506 01 ADD 1507 91 SWAP2 1508 50 POP 1509 85 DUP6 150A 60 PUSH1 0x1f 150C 83 DUP4 150D 01 ADD 150E 12 SLT 150F 61 PUSH2 0x1516 1512 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1507 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1516, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1513: // Incoming jump from 0x1512, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1513 stack[-4] // @1515 memory[stack[-4]:stack[-4] + stack[-4]] // } 1513 83 DUP4 1514 84 DUP5 1515 FD *REVERT // Stack delta = +0 // Outputs[1] { @1515 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1516: // Incoming jump from 0x1512, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1517 stack[-2] // @1518 msg.data[stack[-2]:stack[-2] + 0x20] // } 1516 5B JUMPDEST 1517 81 DUP2 1518 35 CALLDATALOAD 1519 60 PUSH1 0x20 151B 61 PUSH2 0x1526 151E 61 PUSH2 0x132a 1521 83 DUP4 1522 61 PUSH2 0x1784 1525 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1518 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1519 stack[1] = 0x20 // @151B stack[2] = 0x1526 // @151E stack[3] = 0x132a // @1521 stack[4] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1784, returns to 0x132A label_1526: // Incoming return from call to 0x132A at 0x1525 // Inputs[5] // { // @1527 stack[-1] // @1528 stack[-3] // @152B stack[-2] // @1531 stack[-5] // @1533 stack[-9] // } 1526 5B JUMPDEST 1527 80 DUP1 1528 83 DUP4 1529 82 DUP3 152A 52 MSTORE 152B 82 DUP3 152C 82 DUP3 152D 01 ADD 152E 91 SWAP2 152F 50 POP 1530 82 DUP3 1531 86 DUP7 1532 01 ADD 1533 8A DUP11 1534 84 DUP5 1535 86 DUP7 1536 60 PUSH1 0x05 1538 1B SHL 1539 89 DUP10 153A 01 ADD 153B 01 ADD 153C 11 GT 153D 15 ISZERO 153E 61 PUSH2 0x1545 1541 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1527 stack[0] = stack[-1] // @152A memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @152E stack[-1] = stack[-1] + stack[-2] // @1532 stack[1] = stack[-5] + stack[-2] // } // Block ends with conditional jump to 0x1545, if !(stack[-5] + (stack[-3] << 0x05) + stack[-2] > stack[-9]) label_1542: // Incoming jump from 0x1541, if not !(stack[-5] + (stack[-3] << 0x05) + stack[-2] > stack[-9]) // Inputs[2] // { // @1542 stack[-9] // @1544 memory[stack[-9]:stack[-9] + stack[-9]] // } 1542 88 DUP9 1543 89 DUP10 1544 FD *REVERT // Stack delta = +0 // Outputs[1] { @1544 revert(memory[stack[-9]:stack[-9] + stack[-9]]); } // Block terminates label_1545: // Incoming jump from 0x1541, if !(stack[-5] + (stack[-3] << 0x05) + stack[-2] > stack[-9]) // Inputs[3] // { // @1546 stack[-9] // @1547 stack[-7] // @154A stack[-5] // } 1545 5B JUMPDEST 1546 88 DUP9 1547 96 SWAP7 1548 50 POP 1549 5B JUMPDEST 154A 84 DUP5 154B 87 DUP8 154C 10 LT 154D 15 ISZERO 154E 61 PUSH2 0x156e 1551 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1547 stack[-7] = stack[-9] } // Block ends with conditional jump to 0x156e, if !(stack[-9] < stack[-5]) label_1552: // Incoming jump from 0x1551, if not !(stack[-9] < stack[-5]) // Incoming jump from 0x1551, if not !(stack[-7] < stack[-5]) // Inputs[1] { @1555 stack[-1] } 1552 61 PUSH2 0x155a 1555 81 DUP2 1556 61 PUSH2 0x12ee 1559 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1552 stack[0] = 0x155a // @1555 stack[1] = stack[-1] // } // Block ends with call to 0x12ee, returns to 0x155A label_155A: // Incoming return from call to 0x12EE at 0x1559 // Inputs[5] // { // @155B stack[-4] // @155C stack[-1] // @155F stack[-8] // @1560 stack[-2] // @1565 stack[-5] // } 155A 5B JUMPDEST 155B 83 DUP4 155C 52 MSTORE 155D 60 PUSH1 0x01 155F 96 SWAP7 1560 90 SWAP1 1561 96 SWAP7 1562 01 ADD 1563 95 SWAP6 1564 91 SWAP2 1565 83 DUP4 1566 01 ADD 1567 91 SWAP2 1568 83 DUP4 1569 01 ADD 156A 61 PUSH2 0x1549 156D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @155C memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @1563 stack[-8] = 0x01 + stack[-8] // @1567 stack[-4] = stack[-5] + stack[-4] // @1569 stack[-2] = stack[-5] + stack[-2] // } // Block ends with unconditional jump to 0x1549 label_156E: // Incoming jump from 0x1551, if !(stack[-9] < stack[-5]) // Incoming jump from 0x1551, if !(stack[-7] < stack[-5]) // Inputs[7] // { // @1570 stack[-9] // @1570 stack[-2] // @1573 stack[-10] // @1574 stack[-4] // @1575 msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // @1576 stack[-7] // @1579 stack[-6] // } 156E 5B JUMPDEST 156F 50 POP 1570 96 SWAP7 1571 50 POP 1572 50 POP 1573 86 DUP7 1574 01 ADD 1575 35 CALLDATALOAD 1576 92 SWAP3 1577 50 POP 1578 50 POP 1579 80 DUP1 157A 82 DUP3 157B 11 GT 157C 15 ISZERO 157D 61 PUSH2 0x1584 1580 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1570 stack[-9] = stack[-2] // @1576 stack[-7] = msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // } // Block ends with conditional jump to 0x1584, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) label_1581: // Incoming jump from 0x1580, if not !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[2] // { // @1581 stack[-3] // @1583 memory[stack[-3]:stack[-3] + stack[-3]] // } 1581 82 DUP3 1582 83 DUP4 1583 FD *REVERT // Stack delta = +0 // Outputs[1] { @1583 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1584: // Incoming jump from 0x1580, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[3] // { // @1589 stack[-6] // @158A stack[-2] // @158B stack[-5] // } 1584 5B JUMPDEST 1585 50 POP 1586 61 PUSH2 0x1591 1589 85 DUP6 158A 82 DUP3 158B 86 DUP7 158C 01 ADD 158D 61 PUSH2 0x130a 1590 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1586 stack[-1] = 0x1591 // @1589 stack[0] = stack[-6] // @158C stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x130a, returns to 0x1591 label_1591: // Incoming return from call to 0x130A at 0x1590 // Inputs[6] // { // @1592 stack[-3] // @1592 stack[-1] // @1595 stack[-6] // @1597 stack[-4] // @1597 stack[-7] // @1598 stack[-5] // } 1591 5B JUMPDEST 1592 91 SWAP2 1593 50 POP 1594 50 POP 1595 92 SWAP3 1596 50 POP 1597 92 SWAP3 1598 90 SWAP1 1599 50 POP 159A 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1595 stack[-6] = stack[-1] // @1597 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_159B: // Incoming call from 0x0149, returns to 0x014A // Inputs[2] // { // @15A0 stack[-1] // @15A1 stack[-2] // } 159B 5B JUMPDEST 159C 60 PUSH1 0x00 159E 60 PUSH1 0x20 15A0 82 DUP3 15A1 84 DUP5 15A2 03 SUB 15A3 12 SLT 15A4 15 ISZERO 15A5 61 PUSH2 0x15ac 15A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @159C stack[0] = 0x00 } // Block ends with conditional jump to 0x15ac, if !(stack[-2] - stack[-1] i< 0x20) label_15A9: // Incoming jump from 0x15A8, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @15A9 stack[-1] // @15AB memory[stack[-1]:stack[-1] + stack[-1]] // } 15A9 80 DUP1 15AA 81 DUP2 15AB FD *REVERT // Stack delta = +0 // Outputs[1] { @15AB revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_15AC: // Incoming jump from 0x15A8, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @15AD stack[-2] // @15AE msg.data[stack[-2]:stack[-2] + 0x20] // } 15AC 5B JUMPDEST 15AD 81 DUP2 15AE 35 CALLDATALOAD 15AF 61 PUSH2 0x08da 15B2 81 DUP2 15B3 61 PUSH2 0x18c2 15B6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15AE stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @15AF stack[1] = 0x08da // @15B2 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x18c2, returns to 0x08DA label_15B7: // Incoming jump from 0x0E95 // Inputs[2] // { // @15BC stack[-1] // @15BD stack[-2] // } 15B7 5B JUMPDEST 15B8 60 PUSH1 0x00 15BA 60 PUSH1 0x20 15BC 82 DUP3 15BD 84 DUP5 15BE 03 SUB 15BF 12 SLT 15C0 15 ISZERO 15C1 61 PUSH2 0x15c8 15C4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15B8 stack[0] = 0x00 } // Block ends with conditional jump to 0x15c8, if !(stack[-2] - stack[-1] i< 0x20) label_15C5: // Incoming jump from 0x15C4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @15C5 stack[-1] // @15C7 memory[stack[-1]:stack[-1] + stack[-1]] // } 15C5 80 DUP1 15C6 81 DUP2 15C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @15C7 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_15C8: // Incoming jump from 0x15C4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @15C9 stack[-2] // @15CA memory[stack[-2]:stack[-2] + 0x20] // } 15C8 5B JUMPDEST 15C9 81 DUP2 15CA 51 MLOAD 15CB 61 PUSH2 0x08da 15CE 81 DUP2 15CF 61 PUSH2 0x18c2 15D2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15CA stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @15CB stack[1] = 0x08da // @15CE stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x18c2, returns to 0x08DA label_15D3: // Incoming call from 0x0206, returns to 0x0207 // Inputs[2] // { // @15D8 stack[-1] // @15D9 stack[-2] // } 15D3 5B JUMPDEST 15D4 60 PUSH1 0x00 15D6 60 PUSH1 0x20 15D8 82 DUP3 15D9 84 DUP5 15DA 03 SUB 15DB 12 SLT 15DC 15 ISZERO 15DD 61 PUSH2 0x15e4 15E0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15D4 stack[0] = 0x00 } // Block ends with conditional jump to 0x15e4, if !(stack[-2] - stack[-1] i< 0x20) label_15E1: // Incoming jump from 0x15E0, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @15E1 stack[-1] // @15E3 memory[stack[-1]:stack[-1] + stack[-1]] // } 15E1 80 DUP1 15E2 81 DUP2 15E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @15E3 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_15E4: // Incoming jump from 0x15E0, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @15E5 stack[-2] // @15E6 msg.data[stack[-2]:stack[-2] + 0x20] // } 15E4 5B JUMPDEST 15E5 81 DUP2 15E6 35 CALLDATALOAD 15E7 60 PUSH1 0x01 15E9 60 PUSH1 0x01 15EB 60 PUSH1 0x40 15ED 1B SHL 15EE 03 SUB 15EF 81 DUP2 15F0 11 GT 15F1 15 ISZERO 15F2 61 PUSH2 0x15f9 15F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15E6 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x15f9, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_15F6: // Incoming jump from 0x15F5, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @15F6 stack[-2] // @15F8 memory[stack[-2]:stack[-2] + stack[-2]] // } 15F6 81 DUP2 15F7 82 DUP3 15F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @15F8 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_15F9: // Incoming jump from 0x15F5, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @15FA stack[-3] // @15FB stack[-1] // @1600 stack[-4] // } 15F9 5B JUMPDEST 15FA 82 DUP3 15FB 01 ADD 15FC 60 PUSH1 0x1f 15FE 81 DUP2 15FF 01 ADD 1600 84 DUP5 1601 13 SGT 1602 61 PUSH2 0x1609 1605 57 *JUMPI // Stack delta = +0 // Outputs[1] { @15FB stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1609, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1606: // Incoming jump from 0x1605, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @1606 stack[-2] // @1608 memory[stack[-2]:stack[-2] + stack[-2]] // } 1606 81 DUP2 1607 82 DUP3 1608 FD *REVERT // Stack delta = +0 // Outputs[1] { @1608 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1609: // Incoming jump from 0x1605, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @160D stack[-4] // @160E stack[-1] // @160F msg.data[stack[-1]:stack[-1] + 0x20] // } 1609 5B JUMPDEST 160A 61 PUSH2 0x0f0a 160D 84 DUP5 160E 82 DUP3 160F 35 CALLDATALOAD 1610 60 PUSH1 0x20 1612 84 DUP5 1613 01 ADD 1614 61 PUSH2 0x1297 1617 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @160A stack[0] = 0x0f0a // @160D stack[1] = stack[-4] // @160F stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1613 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1297, returns to 0x0F0A label_1618: // Incoming call from 0x02B9, returns to 0x02BA // Incoming call from 0x0186, returns to 0x0187 // Incoming call from 0x0219, returns to 0x021A // Inputs[2] // { // @161D stack[-1] // @161E stack[-2] // } 1618 5B JUMPDEST 1619 60 PUSH1 0x00 161B 60 PUSH1 0x20 161D 82 DUP3 161E 84 DUP5 161F 03 SUB 1620 12 SLT 1621 15 ISZERO 1622 61 PUSH2 0x1629 1625 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1619 stack[0] = 0x00 } // Block ends with conditional jump to 0x1629, if !(stack[-2] - stack[-1] i< 0x20) label_1626: // Incoming jump from 0x1625, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1626 stack[-1] // @1628 memory[stack[-1]:stack[-1] + stack[-1]] // } 1626 80 DUP1 1627 81 DUP2 1628 FD *REVERT // Stack delta = +0 // Outputs[1] { @1628 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1629: // Incoming jump from 0x1625, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @162B stack[-2] // @162B msg.data[stack[-2]:stack[-2] + 0x20] // @162C stack[-4] // @162D stack[-3] // } 1629 5B JUMPDEST 162A 50 POP 162B 35 CALLDATALOAD 162C 91 SWAP2 162D 90 SWAP1 162E 50 POP 162F 56 *JUMP // Stack delta = -3 // Outputs[1] { @162C stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1630: // Incoming call from 0x16BD, returns to 0x16BE // Incoming call from 0x171E, returns to 0x08DA // Inputs[3] // { // @1633 stack[-1] // @1634 memory[stack[-1]:stack[-1] + 0x20] // @1636 stack[-2] // } 1630 5B JUMPDEST 1631 60 PUSH1 0x00 1633 81 DUP2 1634 51 MLOAD 1635 80 DUP1 1636 84 DUP5 1637 52 MSTORE 1638 61 PUSH2 0x1648 163B 81 DUP2 163C 60 PUSH1 0x20 163E 86 DUP7 163F 01 ADD 1640 60 PUSH1 0x20 1642 86 DUP7 1643 01 ADD 1644 61 PUSH2 0x17ea 1647 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1631 stack[0] = 0x00 // @1634 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1637 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1638 stack[2] = 0x1648 // @163B stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @163F stack[4] = stack[-2] + 0x20 // @1643 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x17ea, returns to 0x1648 label_1648: // Incoming return from call to 0x17EA at 0x1647 // Inputs[4] // { // @164B stack[-1] // @1650 stack[-4] // @1651 stack[-2] // @1657 stack[-5] // } 1648 5B JUMPDEST 1649 60 PUSH1 0x1f 164B 01 ADD 164C 60 PUSH1 0x1f 164E 19 NOT 164F 16 AND 1650 92 SWAP3 1651 90 SWAP1 1652 92 SWAP3 1653 01 ADD 1654 60 PUSH1 0x20 1656 01 ADD 1657 92 SWAP3 1658 91 SWAP2 1659 50 POP 165A 50 POP 165B 56 *JUMP // Stack delta = -4 // Outputs[1] { @1657 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 165C 5B JUMPDEST 165D 60 PUSH1 0x00 165F 83 DUP4 1660 51 MLOAD 1661 61 PUSH2 0x166e 1664 81 DUP2 1665 84 DUP5 1666 60 PUSH1 0x20 1668 88 DUP9 1669 01 ADD 166A 61 PUSH2 0x17ea 166D 56 *JUMP 166E 5B JUMPDEST 166F 83 DUP4 1670 51 MLOAD 1671 90 SWAP1 1672 83 DUP4 1673 01 ADD 1674 90 SWAP1 1675 61 PUSH2 0x1682 1678 81 DUP2 1679 83 DUP4 167A 60 PUSH1 0x20 167C 88 DUP9 167D 01 ADD 167E 61 PUSH2 0x17ea 1681 56 *JUMP 1682 5B JUMPDEST 1683 01 ADD 1684 94 SWAP5 1685 93 SWAP4 1686 50 POP 1687 50 POP 1688 50 POP 1689 50 POP 168A 56 *JUMP label_168B: // Incoming call from 0x0E4E, returns to 0x0E4F // Inputs[5] // { // @1694 stack[-5] // @1697 stack[-1] // @1699 stack[-4] // @16A4 stack[-3] // @16B9 stack[-2] // } 168B 5B JUMPDEST 168C 60 PUSH1 0x01 168E 60 PUSH1 0x01 1690 60 PUSH1 0xa0 1692 1B SHL 1693 03 SUB 1694 85 DUP6 1695 81 DUP2 1696 16 AND 1697 82 DUP3 1698 52 MSTORE 1699 84 DUP5 169A 16 AND 169B 60 PUSH1 0x20 169D 82 DUP3 169E 01 ADD 169F 52 MSTORE 16A0 60 PUSH1 0x40 16A2 81 DUP2 16A3 01 ADD 16A4 83 DUP4 16A5 90 SWAP1 16A6 52 MSTORE 16A7 60 PUSH1 0x80 16A9 60 PUSH1 0x60 16AB 82 DUP3 16AC 01 ADD 16AD 81 DUP2 16AE 90 SWAP1 16AF 52 MSTORE 16B0 60 PUSH1 0x00 16B2 90 SWAP1 16B3 61 PUSH2 0x16be 16B6 90 SWAP1 16B7 83 DUP4 16B8 01 ADD 16B9 84 DUP5 16BA 61 PUSH2 0x1630 16BD 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1698 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @169F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @16A6 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @16AF memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @16B2 stack[0] = 0x00 // @16B6 stack[1] = 0x16be // @16B8 stack[2] = stack[-1] + 0x80 // @16B9 stack[3] = stack[-2] // } // Block ends with call to 0x1630, returns to 0x16BE label_16BE: // Incoming return from call to 0x1630 at 0x16BD // Inputs[3] // { // @16BF stack[-1] // @16BF stack[-8] // @16C0 stack[-7] // } 16BE 5B JUMPDEST 16BF 96 SWAP7 16C0 95 SWAP6 16C1 50 POP 16C2 50 POP 16C3 50 POP 16C4 50 POP 16C5 50 POP 16C6 50 POP 16C7 56 *JUMP // Stack delta = -7 // Outputs[1] { @16BF stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_16C8: // Incoming call from 0x026C, returns to 0x015B // Inputs[3] // { // @16CC stack[-1] // @16CE stack[-2] // @16CF memory[stack[-2]:stack[-2] + 0x20] // } 16C8 5B JUMPDEST 16C9 60 PUSH1 0x20 16CB 80 DUP1 16CC 82 DUP3 16CD 52 MSTORE 16CE 82 DUP3 16CF 51 MLOAD 16D0 82 DUP3 16D1 82 DUP3 16D2 01 ADD 16D3 81 DUP2 16D4 90 SWAP1 16D5 52 MSTORE 16D6 60 PUSH1 0x00 16D8 91 SWAP2 16D9 90 SWAP1 16DA 84 DUP5 16DB 82 DUP3 16DC 01 ADD 16DD 90 SWAP1 16DE 60 PUSH1 0x40 16E0 85 DUP6 16E1 01 ADD 16E2 90 SWAP1 16E3 84 DUP5 16E4 5B JUMPDEST 16E5 81 DUP2 16E6 81 DUP2 16E7 10 LT 16E8 15 ISZERO 16E9 61 PUSH2 0x1700 16EC 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @16CD memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @16D5 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @16D8 stack[0] = 0x00 // @16D9 stack[1] = 0x20 // @16DD stack[2] = 0x20 + stack[-2] // @16E2 stack[3] = stack[-1] + 0x40 // @16E2 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @16E3 stack[5] = 0x00 // } // Block ends with conditional jump to 0x1700, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_16ED: // Incoming jump from 0x16EC, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x16EC, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @16ED stack[-4] // @16EE memory[stack[-4]:stack[-4] + 0x20] // @16EF stack[-3] // @16F1 stack[-1] // @16F2 stack[-5] // } 16ED 83 DUP4 16EE 51 MLOAD 16EF 83 DUP4 16F0 52 MSTORE 16F1 92 SWAP3 16F2 84 DUP5 16F3 01 ADD 16F4 92 SWAP3 16F5 91 SWAP2 16F6 84 DUP5 16F7 01 ADD 16F8 91 SWAP2 16F9 60 PUSH1 0x01 16FB 01 ADD 16FC 61 PUSH2 0x16e4 16FF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @16F0 memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @16F4 stack[-4] = stack[-5] + stack[-4] // @16F8 stack[-3] = stack[-5] + stack[-3] // @16FB stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x16e4 label_1700: // Incoming jump from 0x16EC, if !(stack[-1] < stack[-2]) // Incoming jump from 0x16EC, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @1702 stack[-2] // @1702 stack[-3] // @1703 stack[-9] // @1704 stack[-8] // } 1700 5B JUMPDEST 1701 50 POP 1702 90 SWAP1 1703 96 SWAP7 1704 95 SWAP6 1705 50 POP 1706 50 POP 1707 50 POP 1708 50 POP 1709 50 POP 170A 50 POP 170B 56 *JUMP // Stack delta = -8 // Outputs[1] { @1703 stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] label_170C: // Incoming jump from 0x0178 // Inputs[2] // { // @170F stack[-1] // @171A stack[-2] // } 170C 5B JUMPDEST 170D 60 PUSH1 0x20 170F 81 DUP2 1710 52 MSTORE 1711 60 PUSH1 0x00 1713 61 PUSH2 0x08da 1716 60 PUSH1 0x20 1718 83 DUP4 1719 01 ADD 171A 84 DUP5 171B 61 PUSH2 0x1630 171E 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1710 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1711 stack[0] = 0x00 // @1713 stack[1] = 0x08da // @1719 stack[2] = stack[-1] + 0x20 // @171A stack[3] = stack[-2] // } // Block ends with call to 0x1630, returns to 0x08DA label_171F: // Incoming call from 0x05BE, returns to 0x0515 // Incoming call from 0x0998, returns to 0x0515 // Incoming call from 0x0514, returns to 0x0515 // Incoming call from 0x05F4, returns to 0x0515 // Inputs[2] // { // @1723 stack[-1] // @1752 stack[-2] // } 171F 5B JUMPDEST 1720 60 PUSH1 0x20 1722 80 DUP1 1723 82 DUP3 1724 52 MSTORE 1725 81 DUP2 1726 81 DUP2 1727 01 ADD 1728 52 MSTORE 1729 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 174A 60 PUSH1 0x40 174C 82 DUP3 174D 01 ADD 174E 52 MSTORE 174F 60 PUSH1 0x60 1751 01 ADD 1752 90 SWAP1 1753 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1724 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1728 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @174E memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1752 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1754: // Incoming call from 0x12C2, returns to 0x12C3 // Incoming jump from 0x132E // Inputs[2] // { // @1757 memory[0x40:0x60] // @175A stack[-1] // } 1754 5B JUMPDEST 1755 60 PUSH1 0x40 1757 51 MLOAD 1758 60 PUSH1 0x1f 175A 82 DUP3 175B 01 ADD 175C 60 PUSH1 0x1f 175E 19 NOT 175F 16 AND 1760 81 DUP2 1761 01 ADD 1762 60 PUSH1 0x01 1764 60 PUSH1 0x01 1766 60 PUSH1 0x40 1768 1B SHL 1769 03 SUB 176A 81 DUP2 176B 11 GT 176C 82 DUP3 176D 82 DUP3 176E 10 LT 176F 17 OR 1770 15 ISZERO 1771 61 PUSH2 0x177c 1774 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1757 stack[0] = memory[0x40:0x60] // @1761 stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x177c, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) label_1775: // Incoming jump from 0x1774, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) 1775 61 PUSH2 0x177c 1778 61 PUSH2 0x18ac 177B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1775 stack[0] = 0x177c } // Block ends with unconditional jump to 0x18ac label_177C: // Incoming jump from 0x1774, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) // Inputs[4] // { // @177F stack[-1] // @1780 stack[-4] // @1780 stack[-2] // @1781 stack[-3] // } 177C 5B JUMPDEST 177D 60 PUSH1 0x40 177F 52 MSTORE 1780 91 SWAP2 1781 90 SWAP1 1782 50 POP 1783 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @177F memory[0x40:0x60] = stack[-1] // @1780 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_1784: // Incoming call from 0x1329, returns to 0x132A // Incoming call from 0x1525, returns to 0x132A // Inputs[1] { @178F stack[-1] } 1784 5B JUMPDEST 1785 60 PUSH1 0x00 1787 60 PUSH1 0x01 1789 60 PUSH1 0x01 178B 60 PUSH1 0x40 178D 1B SHL 178E 03 SUB 178F 82 DUP3 1790 11 GT 1791 15 ISZERO 1792 61 PUSH2 0x179d 1795 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1785 stack[0] = 0x00 } // Block ends with conditional jump to 0x179d, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_1796: // Incoming jump from 0x1795, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 1796 61 PUSH2 0x179d 1799 61 PUSH2 0x18ac 179C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1796 stack[0] = 0x179d } // Block ends with unconditional jump to 0x18ac label_179D: // Incoming jump from 0x1795, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @17A1 stack[-2] // @17A5 stack[-3] // } 179D 5B JUMPDEST 179E 50 POP 179F 60 PUSH1 0x05 17A1 1B SHL 17A2 60 PUSH1 0x20 17A4 01 ADD 17A5 90 SWAP1 17A6 56 *JUMP // Stack delta = -2 // Outputs[1] { @17A5 stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_17A7: // Incoming call from 0x074B, returns to 0x074C // Inputs[2] // { // @17AA stack[-2] // @17AC stack[-1] // } 17A7 5B JUMPDEST 17A8 60 PUSH1 0x00 17AA 82 DUP3 17AB 19 NOT 17AC 82 DUP3 17AD 11 GT 17AE 15 ISZERO 17AF 61 PUSH2 0x17ba 17B2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17A8 stack[0] = 0x00 } // Block ends with conditional jump to 0x17ba, if !(stack[-1] > ~stack[-2]) label_17B3: // Incoming jump from 0x17B2, if not !(stack[-1] > ~stack[-2]) 17B3 61 PUSH2 0x17ba 17B6 61 PUSH2 0x1880 17B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @17B3 stack[0] = 0x17ba } // Block ends with unconditional jump to 0x1880 label_17BA: // Incoming jump from 0x17B2, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @17BC stack[-3] // @17BC stack[-2] // @17BD stack[-4] // } 17BA 5B JUMPDEST 17BB 50 POP 17BC 01 ADD 17BD 90 SWAP1 17BE 56 *JUMP // Stack delta = -3 // Outputs[1] { @17BD stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] 17BF 5B JUMPDEST 17C0 60 PUSH1 0x00 17C2 82 DUP3 17C3 61 PUSH2 0x17ce 17C6 57 *JUMPI 17C7 61 PUSH2 0x17ce 17CA 61 PUSH2 0x1896 17CD 56 *JUMP 17CE 5B JUMPDEST 17CF 50 POP 17D0 04 DIV 17D1 90 SWAP1 17D2 56 *JUMP 17D3 5B JUMPDEST 17D4 60 PUSH1 0x00 17D6 82 DUP3 17D7 82 DUP3 17D8 10 LT 17D9 15 ISZERO 17DA 61 PUSH2 0x17e5 17DD 57 *JUMPI 17DE 61 PUSH2 0x17e5 17E1 61 PUSH2 0x1880 17E4 56 *JUMP 17E5 5B JUMPDEST 17E6 50 POP 17E7 03 SUB 17E8 90 SWAP1 17E9 56 *JUMP label_17EA: // Incoming call from 0x1647, returns to 0x1648 // Inputs[1] { @17EE stack[-3] } 17EA 5B JUMPDEST 17EB 60 PUSH1 0x00 17ED 5B JUMPDEST 17EE 83 DUP4 17EF 81 DUP2 17F0 10 LT 17F1 15 ISZERO 17F2 61 PUSH2 0x1805 17F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17EB stack[0] = 0x00 } // Block ends with conditional jump to 0x1805, if !(0x00 < stack[-3]) label_17F6: // Incoming jump from 0x17F5, if not !(0x00 < stack[-3]) // Incoming jump from 0x17F5, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @17F6 stack[-2] // @17F7 stack[-1] // @17F9 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @17FA stack[-3] // } 17F6 81 DUP2 17F7 81 DUP2 17F8 01 ADD 17F9 51 MLOAD 17FA 83 DUP4 17FB 82 DUP3 17FC 01 ADD 17FD 52 MSTORE 17FE 60 PUSH1 0x20 1800 01 ADD 1801 61 PUSH2 0x17ed 1804 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @17FD memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1800 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x17ed label_1805: // Incoming jump from 0x17F5, if !(0x00 < stack[-3]) // Incoming jump from 0x17F5, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @1806 stack[-4] // @1807 stack[-1] // } 1805 5B JUMPDEST 1806 83 DUP4 1807 81 DUP2 1808 11 GT 1809 15 ISZERO 180A 61 PUSH2 0x0856 180D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0856, if !(stack[-1] > stack[-4]) label_180E: // Incoming jump from 0x180D, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1812 stack[-4] // @1813 stack[-3] // @1815 stack[-5] // } 180E 50 POP 180F 50 POP 1810 60 PUSH1 0x00 1812 91 SWAP2 1813 01 ADD 1814 52 MSTORE 1815 56 *JUMP // Stack delta = -5 // Outputs[1] { @1814 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1816: // Incoming call from 0x077B, returns to 0x0377 // Incoming call from 0x03A2, returns to 0x03A3 // Incoming call from 0x0376, returns to 0x0377 // Incoming call from 0x0919, returns to 0x091A // Incoming call from 0x1209, returns to 0x120A // Incoming call from 0x08ED, returns to 0x08EE // Incoming call from 0x0F20, returns to 0x0377 // Inputs[1] { @1819 stack[-1] } 1816 5B JUMPDEST 1817 60 PUSH1 0x01 1819 81 DUP2 181A 81 DUP2 181B 1C SHR 181C 90 SWAP1 181D 82 DUP3 181E 16 AND 181F 80 DUP1 1820 61 PUSH2 0x182a 1823 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @181C stack[0] = stack[-1] >> 0x01 // @181E stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x182a, if stack[-1] & 0x01 label_1824: // Incoming jump from 0x1823, if not stack[-1] & 0x01 // Inputs[2] // { // @1826 stack[-2] // @182F stack[-1] // } 1824 60 PUSH1 0x7f 1826 82 DUP3 1827 16 AND 1828 91 SWAP2 1829 50 POP 182A 5B JUMPDEST 182B 60 PUSH1 0x20 182D 82 DUP3 182E 10 LT 182F 81 DUP2 1830 14 EQ 1831 15 ISZERO 1832 61 PUSH2 0x184b 1835 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1828 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x184b, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1836: // Incoming jump from 0x1835, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x1835, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @184A memory[0x00:0x24] } 1836 63 PUSH4 0x4e487b71 183B 60 PUSH1 0xe0 183D 1B SHL 183E 60 PUSH1 0x00 1840 52 MSTORE 1841 60 PUSH1 0x22 1843 60 PUSH1 0x04 1845 52 MSTORE 1846 60 PUSH1 0x24 1848 60 PUSH1 0x00 184A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1840 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1845 memory[0x04:0x24] = 0x22 // @184A revert(memory[0x00:0x24]); // } // Block terminates label_184B: // Incoming jump from 0x1835, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x1835, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @184D stack[-4] // @184D stack[-2] // @184E stack[-3] // } 184B 5B JUMPDEST 184C 50 POP 184D 91 SWAP2 184E 90 SWAP1 184F 50 POP 1850 56 *JUMP // Stack delta = -3 // Outputs[1] { @184D stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1851: // Incoming call from 0x0759, returns to 0x075A // Inputs[1] { @1857 stack[-1] } 1851 5B JUMPDEST 1852 60 PUSH1 0x00 1854 60 PUSH1 0x00 1856 19 NOT 1857 82 DUP3 1858 14 EQ 1859 15 ISZERO 185A 61 PUSH2 0x1865 185D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1852 stack[0] = 0x00 } // Block ends with conditional jump to 0x1865, if !(stack[-1] == ~0x00) label_185E: // Incoming jump from 0x185D, if not !(stack[-1] == ~0x00) 185E 61 PUSH2 0x1865 1861 61 PUSH2 0x1880 1864 56 *JUMP // Stack delta = +1 // Outputs[1] { @185E stack[0] = 0x1865 } // Block ends with unconditional jump to 0x1880 label_1865: // Incoming jump from 0x185D, if !(stack[-1] == ~0x00) // Inputs[2] // { // @1869 stack[-2] // @186A stack[-3] // } 1865 5B JUMPDEST 1866 50 POP 1867 60 PUSH1 0x01 1869 01 ADD 186A 90 SWAP1 186B 56 *JUMP // Stack delta = -2 // Outputs[1] { @186A stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] 186C 5B JUMPDEST 186D 60 PUSH1 0x00 186F 82 DUP3 1870 61 PUSH2 0x187b 1873 57 *JUMPI 1874 61 PUSH2 0x187b 1877 61 PUSH2 0x1896 187A 56 *JUMP 187B 5B JUMPDEST 187C 50 POP 187D 06 MOD 187E 90 SWAP1 187F 56 *JUMP label_1880: // Incoming jump from 0x17B9 // Incoming jump from 0x1864 // Inputs[1] { @1895 memory[0x00:0x24] } 1880 5B JUMPDEST 1881 63 PUSH4 0x4e487b71 1886 60 PUSH1 0xe0 1888 1B SHL 1889 60 PUSH1 0x00 188B 52 MSTORE 188C 60 PUSH1 0x11 188E 60 PUSH1 0x04 1890 52 MSTORE 1891 60 PUSH1 0x24 1893 60 PUSH1 0x00 1895 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @188B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1890 memory[0x04:0x24] = 0x11 // @1895 revert(memory[0x00:0x24]); // } // Block terminates 1896 5B JUMPDEST 1897 63 PUSH4 0x4e487b71 189C 60 PUSH1 0xe0 189E 1B SHL 189F 60 PUSH1 0x00 18A1 52 MSTORE 18A2 60 PUSH1 0x12 18A4 60 PUSH1 0x04 18A6 52 MSTORE 18A7 60 PUSH1 0x24 18A9 60 PUSH1 0x00 18AB FD *REVERT label_18AC: // Incoming jump from 0x12AF // Incoming jump from 0x179C // Incoming jump from 0x177B // Inputs[1] { @18C1 memory[0x00:0x24] } 18AC 5B JUMPDEST 18AD 63 PUSH4 0x4e487b71 18B2 60 PUSH1 0xe0 18B4 1B SHL 18B5 60 PUSH1 0x00 18B7 52 MSTORE 18B8 60 PUSH1 0x41 18BA 60 PUSH1 0x04 18BC 52 MSTORE 18BD 60 PUSH1 0x24 18BF 60 PUSH1 0x00 18C1 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @18B7 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @18BC memory[0x04:0x24] = 0x41 // @18C1 revert(memory[0x00:0x24]); // } // Block terminates label_18C2: // Incoming call from 0x15B6, returns to 0x08DA // Incoming call from 0x15D2, returns to 0x08DA // Inputs[1] { @18CC stack[-1] } 18C2 5B JUMPDEST 18C3 60 PUSH1 0x01 18C5 60 PUSH1 0x01 18C7 60 PUSH1 0xe0 18C9 1B SHL 18CA 03 SUB 18CB 19 NOT 18CC 81 DUP2 18CD 16 AND 18CE 81 DUP2 18CF 14 EQ 18D0 61 PUSH2 0x0a07 18D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a07, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_18D4: // Incoming jump from 0x18D3, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @18D7 memory[0x00:0x00] } 18D4 60 PUSH1 0x00 18D6 80 DUP1 18D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @18D7 revert(memory[0x00:0x00]); } // Block terminates 18D8 FE *ASSERT 18D9 A2 LOG2 18DA 64 PUSH5 0x6970667358 18E0 22 22 18E1 12 SLT 18E2 20 SHA3 18E3 DD DD 18E4 27 27 18E5 CC CC 18E6 75 PUSH22 0x78b8e1ecd5945c6f0c6a7283a5a410a38ccb5401e1d3 18FD F5 CREATE2 18FE 2C 2C 18FF 5D 5D 1900 3A GASPRICE 1901 AB AB 1902 6F PUSH16 0x64736f6c63430008040033