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 0x00f5 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00f5, 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 0x71cf372c 0026 11 GT 0027 61 PUSH2 0x0097 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0097, if 0x71cf372c > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x71cf372c > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x9b2cb5d8 0031 11 GT 0032 61 PUSH2 0x0066 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0x9b2cb5d8 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x9b2cb5d8 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0x9b2cb5d8 003C 14 EQ 003D 61 PUSH2 0x01df 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01df, if 0x9b2cb5d8 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0x9b2cb5d8 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xd18d944b 0047 14 EQ 0048 61 PUSH2 0x01e8 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e8, if 0xd18d944b == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xd18d944b == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf1215d25 0052 14 EQ 0053 61 PUSH2 0x01fb 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fb, if 0xf1215d25 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf1215d25 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x020e 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020e, if 0xf2fde38b == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0065 memory[0x00:0x00] } 0062 60 PUSH1 0x00 0064 80 DUP1 0065 FD *REVERT // Stack delta = +0 // Outputs[1] { @0065 revert(memory[0x00:0x00]); } // Block terminates label_0066: // Incoming jump from 0x0035, if 0x9b2cb5d8 > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0x71cf372c 006D 14 EQ 006E 61 PUSH2 0x01aa 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01aa, if 0x71cf372c == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x71cf372c == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0x8456cb59 0078 14 EQ 0079 61 PUSH2 0x01bd 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01bd, if 0x8456cb59 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x8456cb59 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x8b7afe2e 0083 14 EQ 0084 61 PUSH2 0x01c5 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c5, if 0x8b7afe2e == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x8b7afe2e == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x8da5cb5b 008E 14 EQ 008F 61 PUSH2 0x01ce 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ce, if 0x8da5cb5b == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0096 memory[0x00:0x00] } 0093 60 PUSH1 0x00 0095 80 DUP1 0096 FD *REVERT // Stack delta = +0 // Outputs[1] { @0096 revert(memory[0x00:0x00]); } // Block terminates label_0097: // Incoming jump from 0x002A, if 0x71cf372c > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x5c975abb 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x5c975abb > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x5c975abb > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x5c975abb 00A9 14 EQ 00AA 61 PUSH2 0x012a 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x012a, if 0x5c975abb == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x5c975abb == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x5f48f393 00B4 14 EQ 00B5 61 PUSH2 0x014c 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x014c, if 0x5f48f393 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x5f48f393 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x60de25b8 00BF 14 EQ 00C0 61 PUSH2 0x0163 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0163, if 0x60de25b8 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x60de25b8 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x715018a6 00CA 14 EQ 00CB 61 PUSH2 0x01a2 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a2, if 0x715018a6 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x715018a6 == stack[-1] // Inputs[1] { @00D2 memory[0x00:0x00] } 00CF 60 PUSH1 0x00 00D1 80 DUP1 00D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D2 revert(memory[0x00:0x00]); } // Block terminates label_00D3: // Incoming jump from 0x00A2, if 0x5c975abb > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x2e1a7d4d 00DA 14 EQ 00DB 61 PUSH2 0x00fa 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fa, if 0x2e1a7d4d == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x2e1a7d4d == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x3f4ba83a 00E5 14 EQ 00E6 61 PUSH2 0x010f 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x010f, if 0x3f4ba83a == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x5a7a7b7a 00F0 14 EQ 00F1 61 PUSH2 0x0117 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0117, if 0x5a7a7b7a == stack[-1] label_00F5: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00F4, if not 0x5a7a7b7a == stack[-1] // Inputs[1] { @00F9 memory[0x00:0x00] } 00F5 5B JUMPDEST 00F6 60 PUSH1 0x00 00F8 80 DUP1 00F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F9 revert(memory[0x00:0x00]); } // Block terminates label_00FA: // Incoming jump from 0x00DE, if 0x2e1a7d4d == stack[-1] // Inputs[1] { @0101 msg.data.length } 00FA 5B JUMPDEST 00FB 61 PUSH2 0x010d 00FE 61 PUSH2 0x0108 0101 36 CALLDATASIZE 0102 60 PUSH1 0x04 0104 61 PUSH2 0x0a84 0107 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00FB stack[0] = 0x010d // @00FE stack[1] = 0x0108 // @0101 stack[2] = msg.data.length // @0102 stack[3] = 0x04 // } // Block ends with call to 0x0a84, returns to 0x0108 label_0108: // Incoming return from call to 0x0A84 at 0x0107 0108 5B JUMPDEST 0109 61 PUSH2 0x0221 010C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0221 label_010D: // Incoming return from call to 0x0125 at 0x0124 // Incoming return from call to 0x01B8 at 0x01B7 // Incoming return from call to 0x021C at 0x021B // Incoming return from call to 0x01F6 at 0x01F5 010D 5B JUMPDEST 010E 00 *STOP // Stack delta = +0 // Outputs[1] { @010E stop(); } // Block terminates label_010F: // Incoming jump from 0x00E9, if 0x3f4ba83a == stack[-1] 010F 5B JUMPDEST 0110 61 PUSH2 0x010d 0113 61 PUSH2 0x02b4 0116 56 *JUMP // Stack delta = +1 // Outputs[1] { @0110 stack[0] = 0x010d } // Block ends with unconditional jump to 0x02b4 label_0117: // Incoming jump from 0x00F4, if 0x5a7a7b7a == stack[-1] // Inputs[1] { @011E msg.data.length } 0117 5B JUMPDEST 0118 61 PUSH2 0x010d 011B 61 PUSH2 0x0125 011E 36 CALLDATASIZE 011F 60 PUSH1 0x04 0121 61 PUSH2 0x0a84 0124 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0118 stack[0] = 0x010d // @011B stack[1] = 0x0125 // @011E stack[2] = msg.data.length // @011F stack[3] = 0x04 // } // Block ends with call to 0x0a84, returns to 0x0125 label_0125: // Incoming return from call to 0x0A84 at 0x0124 0125 5B JUMPDEST 0126 61 PUSH2 0x02c6 0129 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02c6 label_012A: // Incoming jump from 0x00AD, if 0x5c975abb == stack[-1] // Inputs[4] // { // @012D storage[0x00] // @013A memory[0x40:0x60] // @0146 memory[0x40:0x60] // @014B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 012A 5B JUMPDEST 012B 60 PUSH1 0x00 012D 54 SLOAD 012E 60 PUSH1 0x01 0130 60 PUSH1 0xa0 0132 1B SHL 0133 90 SWAP1 0134 04 DIV 0135 60 PUSH1 0xff 0137 16 AND 0138 60 PUSH1 0x40 013A 51 MLOAD 013B 90 SWAP1 013C 15 ISZERO 013D 15 ISZERO 013E 81 DUP2 013F 52 MSTORE 0140 60 PUSH1 0x20 0142 01 ADD 0143 5B JUMPDEST 0144 60 PUSH1 0x40 0146 51 MLOAD 0147 80 DUP1 0148 91 SWAP2 0149 03 SUB 014A 90 SWAP1 014B F3 *RETURN // Stack delta = +0 // Outputs[2] // { // @013F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!(0xff & storage[0x00] / (0x01 << 0xa0)) // @014B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_014C: // Incoming jump from 0x00B8, if 0x5f48f393 == stack[-1] // Inputs[1] { @0152 storage[0x03] } 014C 5B JUMPDEST 014D 61 PUSH2 0x0155 0150 60 PUSH1 0x03 0152 54 SLOAD 0153 81 DUP2 0154 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @014D stack[0] = 0x0155 // @0152 stack[1] = storage[0x03] // } // Block ends with unconditional jump to 0x0155 label_0155: // Incoming jump from 0x0154 // Incoming jump from 0x01E7 // Incoming jump from 0x01CD // Inputs[2] // { // @0158 memory[0x40:0x60] // @0159 stack[-1] // } 0155 5B JUMPDEST 0156 60 PUSH1 0x40 0158 51 MLOAD 0159 90 SWAP1 015A 81 DUP2 015B 52 MSTORE 015C 60 PUSH1 0x20 015E 01 ADD 015F 61 PUSH2 0x0143 0162 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @015B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @015E stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0143 label_0163: // Incoming jump from 0x00C3, if 0x60de25b8 == stack[-1] 0163 5B JUMPDEST 0164 61 PUSH2 0x018a 0167 7F PUSH32 0x000000000000000000000000f629cbd94d3791c9250152bd8dfbdf380e2a3b9c 0188 81 DUP2 0189 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0164 stack[0] = 0x018a // @0167 stack[1] = 0x000000000000000000000000f629cbd94d3791c9250152bd8dfbdf380e2a3b9c // } // Block ends with unconditional jump to 0x018a label_018A: // Incoming jump from 0x01DE // Incoming jump from 0x0189 // Inputs[2] // { // @018D memory[0x40:0x60] // @0197 stack[-1] // } 018A 5B JUMPDEST 018B 60 PUSH1 0x40 018D 51 MLOAD 018E 60 PUSH1 0x01 0190 60 PUSH1 0x01 0192 60 PUSH1 0xa0 0194 1B SHL 0195 03 SUB 0196 90 SWAP1 0197 91 SWAP2 0198 16 AND 0199 81 DUP2 019A 52 MSTORE 019B 60 PUSH1 0x20 019D 01 ADD 019E 61 PUSH2 0x0143 01A1 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @019A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @019D stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0143 label_01A2: // Incoming jump from 0x00CE, if 0x715018a6 == stack[-1] 01A2 5B JUMPDEST 01A3 61 PUSH2 0x010d 01A6 61 PUSH2 0x02f6 01A9 56 *JUMP // Stack delta = +1 // Outputs[1] { @01A3 stack[0] = 0x010d } // Block ends with unconditional jump to 0x02f6 label_01AA: // Incoming jump from 0x0071, if 0x71cf372c == stack[-1] // Inputs[1] { @01B1 msg.data.length } 01AA 5B JUMPDEST 01AB 61 PUSH2 0x010d 01AE 61 PUSH2 0x01b8 01B1 36 CALLDATASIZE 01B2 60 PUSH1 0x04 01B4 61 PUSH2 0x0a84 01B7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01AB stack[0] = 0x010d // @01AE stack[1] = 0x01b8 // @01B1 stack[2] = msg.data.length // @01B2 stack[3] = 0x04 // } // Block ends with call to 0x0a84, returns to 0x01B8 label_01B8: // Incoming return from call to 0x0A84 at 0x01B7 01B8 5B JUMPDEST 01B9 61 PUSH2 0x0308 01BC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0308 label_01BD: // Incoming jump from 0x007C, if 0x8456cb59 == stack[-1] 01BD 5B JUMPDEST 01BE 61 PUSH2 0x010d 01C1 61 PUSH2 0x0338 01C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @01BE stack[0] = 0x010d } // Block ends with unconditional jump to 0x0338 label_01C5: // Incoming jump from 0x0087, if 0x8b7afe2e == stack[-1] // Inputs[1] { @01CB storage[0x04] } 01C5 5B JUMPDEST 01C6 61 PUSH2 0x0155 01C9 60 PUSH1 0x04 01CB 54 SLOAD 01CC 81 DUP2 01CD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @01C6 stack[0] = 0x0155 // @01CB stack[1] = storage[0x04] // } // Block ends with unconditional jump to 0x0155 label_01CE: // Incoming jump from 0x0092, if 0x8da5cb5b == stack[-1] // Inputs[1] { @01D1 storage[0x00] } 01CE 5B JUMPDEST 01CF 60 PUSH1 0x00 01D1 54 SLOAD 01D2 60 PUSH1 0x01 01D4 60 PUSH1 0x01 01D6 60 PUSH1 0xa0 01D8 1B SHL 01D9 03 SUB 01DA 16 AND 01DB 61 PUSH2 0x018a 01DE 56 *JUMP // Stack delta = +1 // Outputs[1] { @01DA stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to 0x018a label_01DF: // Incoming jump from 0x0040, if 0x9b2cb5d8 == stack[-1] // Inputs[1] { @01E5 storage[0x02] } 01DF 5B JUMPDEST 01E0 61 PUSH2 0x0155 01E3 60 PUSH1 0x02 01E5 54 SLOAD 01E6 81 DUP2 01E7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @01E0 stack[0] = 0x0155 // @01E5 stack[1] = storage[0x02] // } // Block ends with unconditional jump to 0x0155 label_01E8: // Incoming jump from 0x004B, if 0xd18d944b == stack[-1] // Inputs[1] { @01EF msg.data.length } 01E8 5B JUMPDEST 01E9 61 PUSH2 0x010d 01EC 61 PUSH2 0x01f6 01EF 36 CALLDATASIZE 01F0 60 PUSH1 0x04 01F2 61 PUSH2 0x0a84 01F5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01E9 stack[0] = 0x010d // @01EC stack[1] = 0x01f6 // @01EF stack[2] = msg.data.length // @01F0 stack[3] = 0x04 // } // Block ends with call to 0x0a84, returns to 0x01F6 label_01F6: // Incoming return from call to 0x0A84 at 0x01F5 01F6 5B JUMPDEST 01F7 61 PUSH2 0x0348 01FA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0348 label_01FB: // Incoming jump from 0x0056, if 0xf1215d25 == stack[-1] // Inputs[1] { @0202 msg.data.length } 01FB 5B JUMPDEST 01FC 61 PUSH2 0x010d 01FF 61 PUSH2 0x0209 0202 36 CALLDATASIZE 0203 60 PUSH1 0x04 0205 61 PUSH2 0x0a9d 0208 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01FC stack[0] = 0x010d // @01FF stack[1] = 0x0209 // @0202 stack[2] = msg.data.length // @0203 stack[3] = 0x04 // } // Block ends with call to 0x0a9d, returns to 0x0209 label_0209: // Incoming return from call to 0x0A9D at 0x0208 0209 5B JUMPDEST 020A 61 PUSH2 0x0355 020D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0355 label_020E: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @0215 msg.data.length } 020E 5B JUMPDEST 020F 61 PUSH2 0x010d 0212 61 PUSH2 0x021c 0215 36 CALLDATASIZE 0216 60 PUSH1 0x04 0218 61 PUSH2 0x0b19 021B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @020F stack[0] = 0x010d // @0212 stack[1] = 0x021c // @0215 stack[2] = msg.data.length // @0216 stack[3] = 0x04 // } // Block ends with call to 0x0b19, returns to 0x021C label_021C: // Incoming return from call to 0x0B19 at 0x021B 021C 5B JUMPDEST 021D 61 PUSH2 0x04a5 0220 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04a5 label_0221: // Incoming jump from 0x010C 0221 5B JUMPDEST 0222 61 PUSH2 0x0229 0225 61 PUSH2 0x0520 0228 56 *JUMP // Stack delta = +1 // Outputs[1] { @0222 stack[0] = 0x0229 } // Block ends with call to 0x0520, returns to 0x0229 label_0229: // Incoming return from call to 0x0520 at 0x0228 0229 5B JUMPDEST 022A 61 PUSH2 0x0231 022D 61 PUSH2 0x0579 0230 56 *JUMP // Stack delta = +1 // Outputs[1] { @022A stack[0] = 0x0231 } // Block ends with call to 0x0579, returns to 0x0231 label_0231: // Incoming return from call to 0x0579 at 0x0230 // Inputs[1] { @0235 msg.sender } 0231 5B JUMPDEST 0232 61 PUSH2 0x023a 0235 33 CALLER 0236 61 PUSH2 0x05d3 0239 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0232 stack[0] = 0x023a // @0235 stack[1] = msg.sender // } // Block ends with call to 0x05d3, returns to 0x023A label_023A: // Incoming return from call to 0x05D3 at 0x0239 // Inputs[1] { @023B stack[-1] } 023A 5B JUMPDEST 023B 15 ISZERO 023C 15 ISZERO 023D 60 PUSH1 0x01 023F 03 SUB 0240 61 PUSH2 0x025c 0243 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x025c, if 0x01 - !!stack[-1] label_0244: // Incoming jump from 0x0243, if not 0x01 - !!stack[-1] // Inputs[3] // { // @0246 memory[0x40:0x60] // @0256 memory[0x40:0x60] // @025B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0244 60 PUSH1 0x40 0246 51 MLOAD 0247 63 PUSH4 0xe6c4247b 024C 60 PUSH1 0xe0 024E 1B SHL 024F 81 DUP2 0250 52 MSTORE 0251 60 PUSH1 0x04 0253 01 ADD 0254 60 PUSH1 0x40 0256 51 MLOAD 0257 80 DUP1 0258 91 SWAP2 0259 03 SUB 025A 90 SWAP1 025B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0250 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe6c4247b << 0xe0 // @025B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_025C: // Incoming jump from 0x0243, if 0x01 - !!stack[-1] // Inputs[2] // { // @025D stack[-1] // @0264 storage[0x04] // } 025C 5B JUMPDEST 025D 80 DUP1 025E 60 PUSH1 0x04 0260 60 PUSH1 0x00 0262 82 DUP3 0263 82 DUP3 0264 54 SLOAD 0265 61 PUSH2 0x026e 0268 91 SWAP2 0269 90 SWAP1 026A 61 PUSH2 0x0b5f 026D 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @025D stack[0] = stack[-1] // @025E stack[1] = 0x04 // @0260 stack[2] = 0x00 // @0268 stack[3] = 0x026e // @0269 stack[4] = stack[-1] // @0269 stack[5] = storage[0x04] // } // Block ends with call to 0x0b5f, returns to 0x026E label_026E: // Incoming return from call to 0x0B5F at 0x026D // Inputs[6] // { // @026F stack[-2] // @026F stack[-1] // @0270 stack[-3] // @0276 stack[-4] // @02A2 msg.sender // @02A3 stack[-5] // } 026E 5B JUMPDEST 026F 90 SWAP1 0270 91 SWAP2 0271 55 SSTORE 0272 50 POP 0273 61 PUSH2 0x02a8 0276 90 SWAP1 0277 50 POP 0278 60 PUSH1 0x01 027A 60 PUSH1 0x01 027C 60 PUSH1 0xa0 027E 1B SHL 027F 03 SUB 0280 7F PUSH32 0x000000000000000000000000f629cbd94d3791c9250152bd8dfbdf380e2a3b9c 02A1 16 AND 02A2 33 CALLER 02A3 83 DUP4 02A4 61 PUSH2 0x05f9 02A7 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @0271 storage[stack[-3]] = stack[-1] // @0276 stack[-4] = 0x02a8 // @02A1 stack[-3] = 0x000000000000000000000000f629cbd94d3791c9250152bd8dfbdf380e2a3b9c & (0x01 << 0xa0) - 0x01 // @02A2 stack[-2] = msg.sender // @02A3 stack[-1] = stack[-5] // } // Block ends with unconditional jump to 0x05f9 02A8 5B JUMPDEST 02A9 61 PUSH2 0x02b1 02AC 60 PUSH1 0x01 02AE 80 DUP1 02AF 55 SSTORE 02B0 56 *JUMP label_02B1: // Incoming return from call to 0x06B1 at 0x051F // Inputs[1] { @02B3 stack[-2] } 02B1 5B JUMPDEST 02B2 50 POP 02B3 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_02B4: // Incoming jump from 0x0116 02B4 5B JUMPDEST 02B5 61 PUSH2 0x02bc 02B8 61 PUSH2 0x0579 02BB 56 *JUMP // Stack delta = +1 // Outputs[1] { @02B5 stack[0] = 0x02bc } // Block ends with call to 0x0579, returns to 0x02BC label_02BC: // Incoming return from call to 0x0579 at 0x02BB 02BC 5B JUMPDEST 02BD 61 PUSH2 0x02c4 02C0 61 PUSH2 0x065c 02C3 56 *JUMP // Stack delta = +1 // Outputs[1] { @02BD stack[0] = 0x02c4 } // Block ends with call to 0x065c, returns to 0x02C4 label_02C4: // Incoming jump from 0x08B5, if 0xff & storage[0x00] / (0x01 << 0xa0) // Incoming return from call to 0x0701 at 0x0347 // Incoming jump from 0x0756, if !(0xff & storage[0x00] / (0x01 << 0xa0)) // Incoming return from call to 0x065C at 0x02C3 // Incoming return from call to 0x06B1 at 0x0307 // Incoming jump from 0x058B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @02C5 stack[-1] } 02C4 5B JUMPDEST 02C5 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_02C6: // Incoming jump from 0x0129 02C6 5B JUMPDEST 02C7 61 PUSH2 0x02ce 02CA 61 PUSH2 0x0579 02CD 56 *JUMP // Stack delta = +1 // Outputs[1] { @02C7 stack[0] = 0x02ce } // Block ends with call to 0x0579, returns to 0x02CE label_02CE: // Incoming return from call to 0x0579 at 0x02CD // Inputs[2] // { // @02D1 storage[0x02] // @02D2 stack[-1] // } 02CE 5B JUMPDEST 02CF 60 PUSH1 0x02 02D1 54 SLOAD 02D2 81 DUP2 02D3 10 LT 02D4 15 ISZERO 02D5 61 PUSH2 0x02f1 02D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f1, if !(stack[-1] < storage[0x02]) label_02D9: // Incoming jump from 0x02D8, if not !(stack[-1] < storage[0x02]) // Inputs[3] // { // @02DB memory[0x40:0x60] // @02EB memory[0x40:0x60] // @02F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02D9 60 PUSH1 0x40 02DB 51 MLOAD 02DC 63 PUSH4 0x52211707 02E1 60 PUSH1 0xe1 02E3 1B SHL 02E4 81 DUP2 02E5 52 MSTORE 02E6 60 PUSH1 0x04 02E8 01 ADD 02E9 60 PUSH1 0x40 02EB 51 MLOAD 02EC 80 DUP1 02ED 91 SWAP2 02EE 03 SUB 02EF 90 SWAP1 02F0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @02E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x52211707 << 0xe1 // @02F0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_02F1: // Incoming jump from 0x02D8, if !(stack[-1] < storage[0x02]) // Inputs[2] // { // @02F4 stack[-1] // @02F5 stack[-2] // } 02F1 5B JUMPDEST 02F2 60 PUSH1 0x03 02F4 55 SSTORE 02F5 56 *JUMP // Stack delta = -2 // Outputs[1] { @02F4 storage[0x03] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_02F6: // Incoming jump from 0x01A9 02F6 5B JUMPDEST 02F7 61 PUSH2 0x02fe 02FA 61 PUSH2 0x0579 02FD 56 *JUMP // Stack delta = +1 // Outputs[1] { @02F7 stack[0] = 0x02fe } // Block ends with call to 0x0579, returns to 0x02FE label_02FE: // Incoming return from call to 0x0579 at 0x02FD 02FE 5B JUMPDEST 02FF 61 PUSH2 0x02c4 0302 60 PUSH1 0x00 0304 61 PUSH2 0x06b1 0307 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02FF stack[0] = 0x02c4 // @0302 stack[1] = 0x00 // } // Block ends with call to 0x06b1, returns to 0x02C4 label_0308: // Incoming jump from 0x01BC 0308 5B JUMPDEST 0309 61 PUSH2 0x0310 030C 61 PUSH2 0x0579 030F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0309 stack[0] = 0x0310 } // Block ends with call to 0x0579, returns to 0x0310 label_0310: // Incoming return from call to 0x0579 at 0x030F // Inputs[2] // { // @0313 storage[0x03] // @0314 stack[-1] // } 0310 5B JUMPDEST 0311 60 PUSH1 0x03 0313 54 SLOAD 0314 81 DUP2 0315 11 GT 0316 15 ISZERO 0317 61 PUSH2 0x0333 031A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0333, if !(stack[-1] > storage[0x03]) label_031B: // Incoming jump from 0x031A, if not !(stack[-1] > storage[0x03]) // Inputs[3] // { // @031D memory[0x40:0x60] // @032D memory[0x40:0x60] // @0332 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 031B 60 PUSH1 0x40 031D 51 MLOAD 031E 63 PUSH4 0x4e8717ff 0323 60 PUSH1 0xe1 0325 1B SHL 0326 81 DUP2 0327 52 MSTORE 0328 60 PUSH1 0x04 032A 01 ADD 032B 60 PUSH1 0x40 032D 51 MLOAD 032E 80 DUP1 032F 91 SWAP2 0330 03 SUB 0331 90 SWAP1 0332 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0327 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4e8717ff << 0xe1 // @0332 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0333: // Incoming jump from 0x031A, if !(stack[-1] > storage[0x03]) // Inputs[2] // { // @0336 stack[-1] // @0337 stack[-2] // } 0333 5B JUMPDEST 0334 60 PUSH1 0x02 0336 55 SSTORE 0337 56 *JUMP // Stack delta = -2 // Outputs[1] { @0336 storage[0x02] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0338: // Incoming jump from 0x01C4 0338 5B JUMPDEST 0339 61 PUSH2 0x0340 033C 61 PUSH2 0x0579 033F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0339 stack[0] = 0x0340 } // Block ends with call to 0x0579, returns to 0x0340 label_0340: // Incoming return from call to 0x0579 at 0x033F 0340 5B JUMPDEST 0341 61 PUSH2 0x02c4 0344 61 PUSH2 0x0701 0347 56 *JUMP // Stack delta = +1 // Outputs[1] { @0341 stack[0] = 0x02c4 } // Block ends with call to 0x0701, returns to 0x02C4 label_0348: // Incoming jump from 0x01FA 0348 5B JUMPDEST 0349 61 PUSH2 0x0350 034C 61 PUSH2 0x0579 034F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0349 stack[0] = 0x0350 } // Block ends with call to 0x0579, returns to 0x0350 label_0350: // Incoming return from call to 0x0579 at 0x034F // Inputs[2] // { // @0353 stack[-1] // @0354 stack[-2] // } 0350 5B JUMPDEST 0351 60 PUSH1 0x05 0353 55 SSTORE 0354 56 *JUMP // Stack delta = -2 // Outputs[1] { @0353 storage[0x05] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0355: // Incoming jump from 0x020D 0355 5B JUMPDEST 0356 61 PUSH2 0x035d 0359 61 PUSH2 0x0744 035C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0356 stack[0] = 0x035d } // Block ends with call to 0x0744, returns to 0x035D label_035D: // Incoming return from call to 0x0744 at 0x035C 035D 5B JUMPDEST 035E 61 PUSH2 0x0365 0361 61 PUSH2 0x0520 0364 56 *JUMP // Stack delta = +1 // Outputs[1] { @035E stack[0] = 0x0365 } // Block ends with call to 0x0520, returns to 0x0365 label_0365: // Incoming return from call to 0x0520 at 0x0364 // Inputs[2] // { // @0366 stack[-3] // @0369 storage[0x04] // } 0365 5B JUMPDEST 0366 82 DUP3 0367 60 PUSH1 0x04 0369 54 SLOAD 036A 61 PUSH2 0x0373 036D 91 SWAP2 036E 90 SWAP1 036F 61 PUSH2 0x0b72 0372 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @036D stack[0] = 0x0373 // @036E stack[1] = stack[-3] // @036E stack[2] = storage[0x04] // } // Block ends with call to 0x0b72, returns to 0x0373 label_0373: // Incoming return from call to 0x0B72 at 0x0372 // Inputs[2] // { // @0376 storage[0x05] // @0377 stack[-1] // } 0373 5B JUMPDEST 0374 60 PUSH1 0x05 0376 54 SLOAD 0377 10 LT 0378 15 ISZERO 0379 61 PUSH2 0x0395 037C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0395, if !(storage[0x05] < stack[-1]) label_037D: // Incoming jump from 0x037C, if not !(storage[0x05] < stack[-1]) // Inputs[3] // { // @037F memory[0x40:0x60] // @038F memory[0x40:0x60] // @0394 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 037D 60 PUSH1 0x40 037F 51 MLOAD 0380 63 PUSH4 0x4bc461a1 0385 60 PUSH1 0xe1 0387 1B SHL 0388 81 DUP2 0389 52 MSTORE 038A 60 PUSH1 0x04 038C 01 ADD 038D 60 PUSH1 0x40 038F 51 MLOAD 0390 80 DUP1 0391 91 SWAP2 0392 03 SUB 0393 90 SWAP1 0394 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0389 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4bc461a1 << 0xe1 // @0394 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0395: // Incoming jump from 0x037C, if !(storage[0x05] < stack[-1]) // Inputs[1] { @0399 msg.sender } 0395 5B JUMPDEST 0396 61 PUSH2 0x039e 0399 33 CALLER 039A 61 PUSH2 0x05d3 039D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0396 stack[0] = 0x039e // @0399 stack[1] = msg.sender // } // Block ends with call to 0x05d3, returns to 0x039E label_039E: // Incoming return from call to 0x05D3 at 0x039D // Inputs[1] { @039F stack[-1] } 039E 5B JUMPDEST 039F 15 ISZERO 03A0 15 ISZERO 03A1 60 PUSH1 0x01 03A3 03 SUB 03A4 61 PUSH2 0x03c0 03A7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x03c0, if 0x01 - !!stack[-1] label_03A8: // Incoming jump from 0x03A7, if not 0x01 - !!stack[-1] // Inputs[3] // { // @03AA memory[0x40:0x60] // @03BA memory[0x40:0x60] // @03BF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03A8 60 PUSH1 0x40 03AA 51 MLOAD 03AB 63 PUSH4 0xe6c4247b 03B0 60 PUSH1 0xe0 03B2 1B SHL 03B3 81 DUP2 03B4 52 MSTORE 03B5 60 PUSH1 0x04 03B7 01 ADD 03B8 60 PUSH1 0x40 03BA 51 MLOAD 03BB 80 DUP1 03BC 91 SWAP2 03BD 03 SUB 03BE 90 SWAP1 03BF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @03B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe6c4247b << 0xe0 // @03BF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_03C0: // Incoming jump from 0x03A7, if 0x01 - !!stack[-1] // Inputs[2] // { // @03C3 storage[0x02] // @03C4 stack[-3] // } 03C0 5B JUMPDEST 03C1 60 PUSH1 0x02 03C3 54 SLOAD 03C4 83 DUP4 03C5 10 LT 03C6 15 ISZERO 03C7 61 PUSH2 0x03e3 03CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e3, if !(stack[-3] < storage[0x02]) label_03CB: // Incoming jump from 0x03CA, if not !(stack[-3] < storage[0x02]) // Inputs[3] // { // @03CD memory[0x40:0x60] // @03DD memory[0x40:0x60] // @03E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03CB 60 PUSH1 0x40 03CD 51 MLOAD 03CE 63 PUSH4 0x52211707 03D3 60 PUSH1 0xe1 03D5 1B SHL 03D6 81 DUP2 03D7 52 MSTORE 03D8 60 PUSH1 0x04 03DA 01 ADD 03DB 60 PUSH1 0x40 03DD 51 MLOAD 03DE 80 DUP1 03DF 91 SWAP2 03E0 03 SUB 03E1 90 SWAP1 03E2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @03D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x52211707 << 0xe1 // @03E2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_03E3: // Incoming jump from 0x03CA, if !(stack[-3] < storage[0x02]) // Inputs[2] // { // @03E6 storage[0x03] // @03E7 stack[-3] // } 03E3 5B JUMPDEST 03E4 60 PUSH1 0x03 03E6 54 SLOAD 03E7 83 DUP4 03E8 11 GT 03E9 15 ISZERO 03EA 61 PUSH2 0x0406 03ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0406, if !(stack[-3] > storage[0x03]) label_03EE: // Incoming jump from 0x03ED, if not !(stack[-3] > storage[0x03]) // Inputs[3] // { // @03F0 memory[0x40:0x60] // @0400 memory[0x40:0x60] // @0405 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03EE 60 PUSH1 0x40 03F0 51 MLOAD 03F1 63 PUSH4 0x4e8717ff 03F6 60 PUSH1 0xe1 03F8 1B SHL 03F9 81 DUP2 03FA 52 MSTORE 03FB 60 PUSH1 0x04 03FD 01 ADD 03FE 60 PUSH1 0x40 0400 51 MLOAD 0401 80 DUP1 0402 91 SWAP2 0403 03 SUB 0404 90 SWAP1 0405 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @03FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4e8717ff << 0xe1 // @0405 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0406: // Incoming jump from 0x03ED, if !(stack[-3] > storage[0x03]) // Inputs[2] // { // @0407 stack[-3] // @040E storage[0x04] // } 0406 5B JUMPDEST 0407 82 DUP3 0408 60 PUSH1 0x04 040A 60 PUSH1 0x00 040C 82 DUP3 040D 82 DUP3 040E 54 SLOAD 040F 61 PUSH2 0x0418 0412 91 SWAP2 0413 90 SWAP1 0414 61 PUSH2 0x0b72 0417 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0407 stack[0] = stack[-3] // @0408 stack[1] = 0x04 // @040A stack[2] = 0x00 // @0412 stack[3] = 0x0418 // @0413 stack[4] = stack[-3] // @0413 stack[5] = storage[0x04] // } // Block ends with call to 0x0b72, returns to 0x0418 label_0418: // Incoming return from call to 0x0B72 at 0x0417 // Inputs[7] // { // @0419 stack[-2] // @0419 stack[-1] // @041A stack[-3] // @0420 stack[-4] // @044C msg.sender // @044D address(this) // @044E stack[-7] // } 0418 5B JUMPDEST 0419 90 SWAP1 041A 91 SWAP2 041B 55 SSTORE 041C 50 POP 041D 61 PUSH2 0x0453 0420 90 SWAP1 0421 50 POP 0422 60 PUSH1 0x01 0424 60 PUSH1 0x01 0426 60 PUSH1 0xa0 0428 1B SHL 0429 03 SUB 042A 7F PUSH32 0x000000000000000000000000f629cbd94d3791c9250152bd8dfbdf380e2a3b9c 044B 16 AND 044C 33 CALLER 044D 30 ADDRESS 044E 86 DUP7 044F 61 PUSH2 0x0791 0452 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @041B storage[stack[-3]] = stack[-1] // @0420 stack[-4] = 0x0453 // @044B stack[-3] = 0x000000000000000000000000f629cbd94d3791c9250152bd8dfbdf380e2a3b9c & (0x01 << 0xa0) - 0x01 // @044C stack[-2] = msg.sender // @044D stack[-1] = address(this) // @044E stack[0] = stack[-7] // } // Block ends with unconditional jump to 0x0791 0453 5B JUMPDEST 0454 81 DUP2 0455 81 DUP2 0456 60 PUSH1 0x40 0458 51 MLOAD 0459 61 PUSH2 0x0463 045C 92 SWAP3 045D 91 SWAP2 045E 90 SWAP1 045F 61 PUSH2 0x0b85 0462 56 *JUMP 0463 5B JUMPDEST 0464 60 PUSH1 0x40 0466 51 MLOAD 0467 90 SWAP1 0468 81 DUP2 0469 90 SWAP1 046A 03 SUB 046B 81 DUP2 046C 20 SHA3 046D 90 SWAP1 046E 84 DUP5 046F 90 SWAP1 0470 33 CALLER 0471 90 SWAP1 0472 7F PUSH32 0x643e927b32d5bfd08eccd2fcbd97057ad413850f857a2359639114e8e8dd3d7b 0493 90 SWAP1 0494 60 PUSH1 0x00 0496 90 SWAP1 0497 A4 LOG4 0498 61 PUSH2 0x04a0 049B 60 PUSH1 0x01 049D 80 DUP1 049E 55 SSTORE 049F 56 *JUMP 04A0 5B JUMPDEST 04A1 50 POP 04A2 50 POP 04A3 50 POP 04A4 56 *JUMP label_04A5: // Incoming jump from 0x0220 04A5 5B JUMPDEST 04A6 61 PUSH2 0x04ad 04A9 61 PUSH2 0x0579 04AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @04A6 stack[0] = 0x04ad } // Block ends with call to 0x0579, returns to 0x04AD label_04AD: // Incoming return from call to 0x0579 at 0x04AC // Inputs[1] { @04B6 stack[-1] } 04AD 5B JUMPDEST 04AE 60 PUSH1 0x01 04B0 60 PUSH1 0x01 04B2 60 PUSH1 0xa0 04B4 1B SHL 04B5 03 SUB 04B6 81 DUP2 04B7 16 AND 04B8 61 PUSH2 0x0517 04BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0517, if stack[-1] & (0x01 << 0xa0) - 0x01 label_04BC: // Incoming jump from 0x04BB, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @04BE memory[0x40:0x60] } 04BC 60 PUSH1 0x40 04BE 51 MLOAD 04BF 62 PUSH3 0x461bcd 04C3 60 PUSH1 0xe5 04C5 1B SHL 04C6 81 DUP2 04C7 52 MSTORE 04C8 60 PUSH1 0x20 04CA 60 PUSH1 0x04 04CC 82 DUP3 04CD 01 ADD 04CE 52 MSTORE 04CF 60 PUSH1 0x26 04D1 60 PUSH1 0x24 04D3 82 DUP3 04D4 01 ADD 04D5 52 MSTORE 04D6 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 04F7 60 PUSH1 0x44 04F9 82 DUP3 04FA 01 ADD 04FB 52 MSTORE 04FC 65 PUSH6 0x646472657373 0503 60 PUSH1 0xd0 0505 1B SHL 0506 60 PUSH1 0x64 0508 82 DUP3 0509 01 ADD 050A 52 MSTORE 050B 60 PUSH1 0x84 050D 01 ADD // Stack delta = +1 // Outputs[6] // { // @04C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @04CE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @04D5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @04FB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @050A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @050D stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_050E: // Incoming jump from 0x08F3 // Incoming return from call to 0x0BF7 at 0x0A83 // Incoming jump from 0x05D2 // Incoming jump from 0x0571 // Incoming jump from 0x0790 // Incoming jump from 0x096B // Incoming jump from 0x0A4D // Incoming jump from 0x050D // Inputs[3] // { // @0511 memory[0x40:0x60] // @0513 stack[-1] // @0516 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 050E 5B JUMPDEST 050F 60 PUSH1 0x40 0511 51 MLOAD 0512 80 DUP1 0513 91 SWAP2 0514 03 SUB 0515 90 SWAP1 0516 FD *REVERT // Stack delta = -1 // Outputs[1] { @0516 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0517: // Incoming jump from 0x04BB, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @051B stack[-1] } 0517 5B JUMPDEST 0518 61 PUSH2 0x02b1 051B 81 DUP2 051C 61 PUSH2 0x06b1 051F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0518 stack[0] = 0x02b1 // @051B stack[1] = stack[-1] // } // Block ends with call to 0x06b1, returns to 0x02B1 label_0520: // Incoming call from 0x0364, returns to 0x0365 // Incoming call from 0x0228, returns to 0x0229 // Inputs[1] { @0525 storage[0x01] } 0520 5B JUMPDEST 0521 60 PUSH1 0x02 0523 60 PUSH1 0x01 0525 54 SLOAD 0526 03 SUB 0527 61 PUSH2 0x0572 052A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0572, if storage[0x01] - 0x02 label_052B: // Incoming jump from 0x052A, if not storage[0x01] - 0x02 // Inputs[1] { @052D memory[0x40:0x60] } 052B 60 PUSH1 0x40 052D 51 MLOAD 052E 62 PUSH3 0x461bcd 0532 60 PUSH1 0xe5 0534 1B SHL 0535 81 DUP2 0536 52 MSTORE 0537 60 PUSH1 0x20 0539 60 PUSH1 0x04 053B 82 DUP3 053C 01 ADD 053D 52 MSTORE 053E 60 PUSH1 0x1f 0540 60 PUSH1 0x24 0542 82 DUP3 0543 01 ADD 0544 52 MSTORE 0545 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 0566 60 PUSH1 0x44 0568 82 DUP3 0569 01 ADD 056A 52 MSTORE 056B 60 PUSH1 0x64 056D 01 ADD 056E 61 PUSH2 0x050e 0571 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0536 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @053D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0544 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @056A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @056D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x050e label_0572: // Incoming jump from 0x052A, if storage[0x01] - 0x02 // Inputs[1] { @0578 stack[-1] } 0572 5B JUMPDEST 0573 60 PUSH1 0x02 0575 60 PUSH1 0x01 0577 55 SSTORE 0578 56 *JUMP // Stack delta = -1 // Outputs[1] { @0577 storage[0x01] = 0x02 } // Block ends with unconditional jump to stack[-1] label_0579: // Incoming call from 0x02FD, returns to 0x02FE // Incoming call from 0x034F, returns to 0x0350 // Incoming call from 0x030F, returns to 0x0310 // Incoming call from 0x033F, returns to 0x0340 // Incoming call from 0x02BB, returns to 0x02BC // Incoming call from 0x02CD, returns to 0x02CE // Incoming call from 0x04AC, returns to 0x04AD // Incoming call from 0x0230, returns to 0x0231 // Inputs[2] // { // @057C storage[0x00] // @0586 msg.sender // } 0579 5B JUMPDEST 057A 60 PUSH1 0x00 057C 54 SLOAD 057D 60 PUSH1 0x01 057F 60 PUSH1 0x01 0581 60 PUSH1 0xa0 0583 1B SHL 0584 03 SUB 0585 16 AND 0586 33 CALLER 0587 14 EQ 0588 61 PUSH2 0x02c4 058B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_058C: // Incoming jump from 0x058B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @058E memory[0x40:0x60] } 058C 60 PUSH1 0x40 058E 51 MLOAD 058F 62 PUSH3 0x461bcd 0593 60 PUSH1 0xe5 0595 1B SHL 0596 81 DUP2 0597 52 MSTORE 0598 60 PUSH1 0x20 059A 60 PUSH1 0x04 059C 82 DUP3 059D 01 ADD 059E 81 DUP2 059F 90 SWAP1 05A0 52 MSTORE 05A1 60 PUSH1 0x24 05A3 82 DUP3 05A4 01 ADD 05A5 52 MSTORE 05A6 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 05C7 60 PUSH1 0x44 05C9 82 DUP3 05CA 01 ADD 05CB 52 MSTORE 05CC 60 PUSH1 0x64 05CE 01 ADD 05CF 61 PUSH2 0x050e 05D2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0597 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05A0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05A5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @05CB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @05CE stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x050e label_05D3: // Incoming call from 0x039D, returns to 0x039E // Incoming call from 0x0239, returns to 0x023A // Inputs[2] // { // @05DE stack[-1] // @05E0 address(this) // } 05D3 5B JUMPDEST 05D4 60 PUSH1 0x00 05D6 60 PUSH1 0x01 05D8 60 PUSH1 0x01 05DA 60 PUSH1 0xa0 05DC 1B SHL 05DD 03 SUB 05DE 82 DUP3 05DF 16 AND 05E0 30 ADDRESS 05E1 14 EQ 05E2 80 DUP1 05E3 61 PUSH2 0x05f3 05E6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @05D4 stack[0] = 0x00 // @05E1 stack[1] = address(this) == stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with conditional jump to 0x05f3, if address(this) == stack[-1] & (0x01 << 0xa0) - 0x01 label_05E7: // Incoming jump from 0x05E6, if not address(this) == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @05F0 stack[-3] // @05F4 stack[-4] // } 05E7 50 POP 05E8 60 PUSH1 0x01 05EA 60 PUSH1 0x01 05EC 60 PUSH1 0xa0 05EE 1B SHL 05EF 03 SUB 05F0 82 DUP3 05F1 16 AND 05F2 15 ISZERO 05F3 5B JUMPDEST 05F4 92 SWAP3 05F5 91 SWAP2 05F6 50 POP 05F7 50 POP 05F8 56 *JUMP // Stack delta = -3 // Outputs[1] { @05F4 stack[-4] = !(stack[-3] & (0x01 << 0xa0) - 0x01) } // Block ends with unconditional jump to stack[-4] label_05F9: // Incoming jump from 0x02A7 // Inputs[6] // { // @05FC memory[0x40:0x60] // @0605 stack[-2] // @0610 stack[-1] // @0617 stack[-3] // @0629 memory[0x40:0x60] // @063B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // } 05F9 5B JUMPDEST 05FA 60 PUSH1 0x40 05FC 51 MLOAD 05FD 60 PUSH1 0x01 05FF 60 PUSH1 0x01 0601 60 PUSH1 0xa0 0603 1B SHL 0604 03 SUB 0605 83 DUP4 0606 16 AND 0607 60 PUSH1 0x24 0609 82 DUP3 060A 01 ADD 060B 52 MSTORE 060C 60 PUSH1 0x44 060E 81 DUP2 060F 01 ADD 0610 82 DUP3 0611 90 SWAP1 0612 52 MSTORE 0613 61 PUSH2 0x04a0 0616 90 SWAP1 0617 84 DUP5 0618 90 SWAP1 0619 63 PUSH4 0xa9059cbb 061E 60 PUSH1 0xe0 0620 1B SHL 0621 90 SWAP1 0622 60 PUSH1 0x64 0624 01 ADD 0625 5B JUMPDEST 0626 60 PUSH1 0x40 0628 80 DUP1 0629 51 MLOAD 062A 60 PUSH1 0x1f 062C 19 NOT 062D 81 DUP2 062E 84 DUP5 062F 03 SUB 0630 01 ADD 0631 81 DUP2 0632 52 MSTORE 0633 91 SWAP2 0634 90 SWAP1 0635 52 MSTORE 0636 60 PUSH1 0x20 0638 81 DUP2 0639 01 ADD 063A 80 DUP1 063B 51 MLOAD 063C 60 PUSH1 0x01 063E 60 PUSH1 0x01 0640 60 PUSH1 0xe0 0642 1B SHL 0643 03 SUB 0644 16 AND 0645 60 PUSH1 0x01 0647 60 PUSH1 0x01 0649 60 PUSH1 0xe0 064B 1B SHL 064C 03 SUB 064D 19 NOT 064E 90 SWAP1 064F 93 SWAP4 0650 16 AND 0651 92 SWAP3 0652 90 SWAP1 0653 92 SWAP3 0654 17 OR 0655 90 SWAP1 0656 91 SWAP2 0657 52 MSTORE 0658 61 PUSH2 0x07cf 065B 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @060B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0612 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @0616 stack[0] = 0x04a0 // @0618 stack[1] = stack[-3] // @0632 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x64 + memory[0x40:0x60]) - memory[0x40:0x60] + ~0x1f // @0635 memory[0x40:0x60] = 0x64 + memory[0x40:0x60] // @0656 stack[2] = memory[0x40:0x60] // @0657 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = ((0xa9059cbb << 0xe0) & ~((0x01 << 0xe0) - 0x01)) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // } // Block ends with unconditional jump to 0x07cf label_065C: // Incoming call from 0x02C3, returns to 0x02C4 065C 5B JUMPDEST 065D 61 PUSH2 0x0664 0660 61 PUSH2 0x08a4 0663 56 *JUMP // Stack delta = +1 // Outputs[1] { @065D stack[0] = 0x0664 } // Block ends with call to 0x08a4, returns to 0x0664 label_0664: // Incoming return from call to 0x08A4 at 0x0663 // Inputs[6] // { // @0668 storage[0x00] // @0693 msg.sender // @0697 memory[0x40:0x60] // @06AA memory[0x40:0x60] // @06AF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @06B0 stack[-1] // } 0664 5B JUMPDEST 0665 60 PUSH1 0x00 0667 80 DUP1 0668 54 SLOAD 0669 60 PUSH1 0xff 066B 60 PUSH1 0xa0 066D 1B SHL 066E 19 NOT 066F 16 AND 0670 90 SWAP1 0671 55 SSTORE 0672 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 0693 33 CALLER 0694 5B JUMPDEST 0695 60 PUSH1 0x40 0697 51 MLOAD 0698 60 PUSH1 0x01 069A 60 PUSH1 0x01 069C 60 PUSH1 0xa0 069E 1B SHL 069F 03 SUB 06A0 90 SWAP1 06A1 91 SWAP2 06A2 16 AND 06A3 81 DUP2 06A4 52 MSTORE 06A5 60 PUSH1 0x20 06A7 01 ADD 06A8 60 PUSH1 0x40 06AA 51 MLOAD 06AB 80 DUP1 06AC 91 SWAP2 06AD 03 SUB 06AE 90 SWAP1 06AF A1 LOG1 06B0 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0671 storage[0x00] = ~(0xff << 0xa0) & storage[0x00] // @06A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender & (0x01 << 0xa0) - 0x01 // @06AF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa]); // } // Block ends with unconditional jump to stack[-1] label_06B1: // Incoming call from 0x0307, returns to 0x02C4 // Incoming call from 0x051F, returns to 0x02B1 // Inputs[5] // { // @06B5 storage[0x00] // @06BE stack[-1] // @06D2 memory[0x40:0x60] // @06FD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0700 stack[-2] // } 06B1 5B JUMPDEST 06B2 60 PUSH1 0x00 06B4 80 DUP1 06B5 54 SLOAD 06B6 60 PUSH1 0x01 06B8 60 PUSH1 0x01 06BA 60 PUSH1 0xa0 06BC 1B SHL 06BD 03 SUB 06BE 83 DUP4 06BF 81 DUP2 06C0 16 AND 06C1 60 PUSH1 0x01 06C3 60 PUSH1 0x01 06C5 60 PUSH1 0xa0 06C7 1B SHL 06C8 03 SUB 06C9 19 NOT 06CA 83 DUP4 06CB 16 AND 06CC 81 DUP2 06CD 17 OR 06CE 84 DUP5 06CF 55 SSTORE 06D0 60 PUSH1 0x40 06D2 51 MLOAD 06D3 91 SWAP2 06D4 90 SWAP1 06D5 92 SWAP3 06D6 16 AND 06D7 92 SWAP3 06D8 83 DUP4 06D9 91 SWAP2 06DA 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 06FB 91 SWAP2 06FC 90 SWAP1 06FD A3 LOG3 06FE 50 POP 06FF 50 POP 0700 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @06CF storage[0x00] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x00] & ~((0x01 << 0xa0) - 0x01)) // @06FD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_0701: // Incoming call from 0x0347, returns to 0x02C4 0701 5B JUMPDEST 0702 61 PUSH2 0x0709 0705 61 PUSH2 0x0744 0708 56 *JUMP // Stack delta = +1 // Outputs[1] { @0702 stack[0] = 0x0709 } // Block ends with call to 0x0744, returns to 0x0709 label_0709: // Incoming return from call to 0x0744 at 0x0708 // Inputs[2] // { // @070D storage[0x00] // @0741 msg.sender // } 0709 5B JUMPDEST 070A 60 PUSH1 0x00 070C 80 DUP1 070D 54 SLOAD 070E 60 PUSH1 0xff 0710 60 PUSH1 0xa0 0712 1B SHL 0713 19 NOT 0714 16 AND 0715 60 PUSH1 0x01 0717 60 PUSH1 0xa0 0719 1B SHL 071A 17 OR 071B 90 SWAP1 071C 55 SSTORE 071D 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 073E 61 PUSH2 0x0694 0741 33 CALLER 0742 90 SWAP1 0743 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @071C storage[0x00] = (0x01 << 0xa0) | (~(0xff << 0xa0) & storage[0x00]) // @071D stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @0742 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x0694 label_0744: // Incoming call from 0x035C, returns to 0x035D // Incoming call from 0x0708, returns to 0x0709 // Inputs[1] { @0747 storage[0x00] } 0744 5B JUMPDEST 0745 60 PUSH1 0x00 0747 54 SLOAD 0748 60 PUSH1 0x01 074A 60 PUSH1 0xa0 074C 1B SHL 074D 90 SWAP1 074E 04 DIV 074F 60 PUSH1 0xff 0751 16 AND 0752 15 ISZERO 0753 61 PUSH2 0x02c4 0756 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c4, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_0757: // Incoming jump from 0x0756, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[1] { @0759 memory[0x40:0x60] } 0757 60 PUSH1 0x40 0759 51 MLOAD 075A 62 PUSH3 0x461bcd 075E 60 PUSH1 0xe5 0760 1B SHL 0761 81 DUP2 0762 52 MSTORE 0763 60 PUSH1 0x20 0765 60 PUSH1 0x04 0767 82 DUP3 0768 01 ADD 0769 52 MSTORE 076A 60 PUSH1 0x10 076C 60 PUSH1 0x24 076E 82 DUP3 076F 01 ADD 0770 52 MSTORE 0771 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 0782 60 PUSH1 0x82 0784 1B SHL 0785 60 PUSH1 0x44 0787 82 DUP3 0788 01 ADD 0789 52 MSTORE 078A 60 PUSH1 0x64 078C 01 ADD 078D 61 PUSH2 0x050e 0790 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0762 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0769 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0770 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0789 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @078C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x050e label_0791: // Incoming jump from 0x0452 // Inputs[5] // { // @0794 memory[0x40:0x60] // @079E stack[-3] // @07A5 stack[-2] // @07B0 stack[-1] // @07B7 stack[-4] // } 0791 5B JUMPDEST 0792 60 PUSH1 0x40 0794 51 MLOAD 0795 60 PUSH1 0x01 0797 60 PUSH1 0x01 0799 60 PUSH1 0xa0 079B 1B SHL 079C 03 SUB 079D 80 DUP1 079E 85 DUP6 079F 16 AND 07A0 60 PUSH1 0x24 07A2 83 DUP4 07A3 01 ADD 07A4 52 MSTORE 07A5 83 DUP4 07A6 16 AND 07A7 60 PUSH1 0x44 07A9 82 DUP3 07AA 01 ADD 07AB 52 MSTORE 07AC 60 PUSH1 0x64 07AE 81 DUP2 07AF 01 ADD 07B0 82 DUP3 07B1 90 SWAP1 07B2 52 MSTORE 07B3 61 PUSH2 0x07c9 07B6 90 SWAP1 07B7 85 DUP6 07B8 90 SWAP1 07B9 63 PUSH4 0x23b872dd 07BE 60 PUSH1 0xe0 07C0 1B SHL 07C1 90 SWAP1 07C2 60 PUSH1 0x84 07C4 01 ADD 07C5 61 PUSH2 0x0625 07C8 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @07A4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @07AB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @07B2 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-1] // @07B6 stack[0] = 0x07c9 // @07B8 stack[1] = stack[-4] // @07C1 stack[2] = 0x23b872dd << 0xe0 // @07C4 stack[3] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 07C9 5B JUMPDEST 07CA 50 POP 07CB 50 POP 07CC 50 POP 07CD 50 POP 07CE 56 *JUMP label_07CF: // Incoming jump from 0x065B // Incoming jump from 0x065B // Inputs[3] // { // @07D5 stack[-1] // @07D8 memory[0x40:0x60] // @080C stack[-2] // } 07CF 5B JUMPDEST 07D0 60 PUSH1 0x00 07D2 61 PUSH2 0x0824 07D5 82 DUP3 07D6 60 PUSH1 0x40 07D8 51 MLOAD 07D9 80 DUP1 07DA 60 PUSH1 0x40 07DC 01 ADD 07DD 60 PUSH1 0x40 07DF 52 MSTORE 07E0 80 DUP1 07E1 60 PUSH1 0x20 07E3 81 DUP2 07E4 52 MSTORE 07E5 60 PUSH1 0x20 07E7 01 ADD 07E8 7F PUSH32 0x5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564 0809 81 DUP2 080A 52 MSTORE 080B 50 POP 080C 85 DUP6 080D 60 PUSH1 0x01 080F 60 PUSH1 0x01 0811 60 PUSH1 0xa0 0813 1B SHL 0814 03 SUB 0815 16 AND 0816 61 PUSH2 0x08f4 0819 90 SWAP1 081A 92 SWAP3 081B 91 SWAP2 081C 90 SWAP1 081D 63 PUSH4 0xffffffff 0822 16 AND 0823 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @07D0 stack[0] = 0x00 // @07D2 stack[1] = 0x0824 // @07DF memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @07E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @080A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564 // @081A stack[2] = (0x01 << 0xa0) - 0x01 & stack[-2] // @081B stack[3] = stack[-1] // @081C stack[4] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0xffffffff & 0x08f4 0824 5B JUMPDEST 0825 90 SWAP1 0826 50 POP 0827 80 DUP1 0828 51 MLOAD 0829 60 PUSH1 0x00 082B 14 EQ 082C 80 DUP1 082D 61 PUSH2 0x0845 0830 57 *JUMPI 0831 50 POP 0832 80 DUP1 0833 80 DUP1 0834 60 PUSH1 0x20 0836 01 ADD 0837 90 SWAP1 0838 51 MLOAD 0839 81 DUP2 083A 01 ADD 083B 90 SWAP1 083C 61 PUSH2 0x0845 083F 91 SWAP2 0840 90 SWAP1 0841 61 PUSH2 0x0b95 0844 56 *JUMP 0845 5B JUMPDEST 0846 61 PUSH2 0x04a0 0849 57 *JUMPI 084A 60 PUSH1 0x40 084C 51 MLOAD 084D 62 PUSH3 0x461bcd 0851 60 PUSH1 0xe5 0853 1B SHL 0854 81 DUP2 0855 52 MSTORE 0856 60 PUSH1 0x20 0858 60 PUSH1 0x04 085A 82 DUP3 085B 01 ADD 085C 52 MSTORE 085D 60 PUSH1 0x2a 085F 60 PUSH1 0x24 0861 82 DUP3 0862 01 ADD 0863 52 MSTORE 0864 7F PUSH32 0x5361666545524332303a204552433230206f7065726174696f6e20646964206e 0885 60 PUSH1 0x44 0887 82 DUP3 0888 01 ADD 0889 52 MSTORE 088A 69 PUSH10 0x1bdd081cdd58d8d95959 0895 60 PUSH1 0xb2 0897 1B SHL 0898 60 PUSH1 0x64 089A 82 DUP3 089B 01 ADD 089C 52 MSTORE 089D 60 PUSH1 0x84 089F 01 ADD 08A0 61 PUSH2 0x050e 08A3 56 *JUMP label_08A4: // Incoming call from 0x0663, returns to 0x0664 // Inputs[1] { @08A7 storage[0x00] } 08A4 5B JUMPDEST 08A5 60 PUSH1 0x00 08A7 54 SLOAD 08A8 60 PUSH1 0x01 08AA 60 PUSH1 0xa0 08AC 1B SHL 08AD 90 SWAP1 08AE 04 DIV 08AF 60 PUSH1 0xff 08B1 16 AND 08B2 61 PUSH2 0x02c4 08B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c4, if 0xff & storage[0x00] / (0x01 << 0xa0) label_08B6: // Incoming jump from 0x08B5, if not 0xff & storage[0x00] / (0x01 << 0xa0) // Inputs[1] { @08B8 memory[0x40:0x60] } 08B6 60 PUSH1 0x40 08B8 51 MLOAD 08B9 62 PUSH3 0x461bcd 08BD 60 PUSH1 0xe5 08BF 1B SHL 08C0 81 DUP2 08C1 52 MSTORE 08C2 60 PUSH1 0x20 08C4 60 PUSH1 0x04 08C6 82 DUP3 08C7 01 ADD 08C8 52 MSTORE 08C9 60 PUSH1 0x14 08CB 60 PUSH1 0x24 08CD 82 DUP3 08CE 01 ADD 08CF 52 MSTORE 08D0 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 08E5 60 PUSH1 0x62 08E7 1B SHL 08E8 60 PUSH1 0x44 08EA 82 DUP3 08EB 01 ADD 08EC 52 MSTORE 08ED 60 PUSH1 0x64 08EF 01 ADD 08F0 61 PUSH2 0x050e 08F3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @08C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08C8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08CF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @08EC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881b9bdd081c185d5cd959 << 0x62 // @08EF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x050e label_08F4: // Incoming jump from 0x0823 // Inputs[3] // { // @08FA stack[-3] // @08FB stack[-2] // @08FE stack[-1] // } 08F4 5B JUMPDEST 08F5 60 PUSH1 0x60 08F7 61 PUSH2 0x0903 08FA 84 DUP5 08FB 84 DUP5 08FC 60 PUSH1 0x00 08FE 85 DUP6 08FF 61 PUSH2 0x090b 0902 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @08F5 stack[0] = 0x60 // @08F7 stack[1] = 0x0903 // @08FA stack[2] = stack[-3] // @08FB stack[3] = stack[-2] // @08FC stack[4] = 0x00 // @08FE stack[5] = stack[-1] // } // Block ends with call to 0x090b, returns to 0x0903 label_0903: // Incoming jump from 0x0A54 // Incoming return from call to 0x090B at 0x0902 // Inputs[3] // { // @0904 stack[-1] // @0904 stack[-6] // @0905 stack[-5] // } 0903 5B JUMPDEST 0904 94 SWAP5 0905 93 SWAP4 0906 50 POP 0907 50 POP 0908 50 POP 0909 50 POP 090A 56 *JUMP // Stack delta = -5 // Outputs[1] { @0904 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_090B: // Incoming call from 0x0902, returns to 0x0903 // Inputs[3] // { // @090E stack[-2] // @090F address(this).balance // @090F address(this) // } 090B 5B JUMPDEST 090C 60 PUSH1 0x60 090E 82 DUP3 090F 47 SELFBALANCE 0910 10 LT 0911 15 ISZERO 0912 61 PUSH2 0x096c 0915 57 *JUMPI // Stack delta = +1 // Outputs[1] { @090C stack[0] = 0x60 } // Block ends with conditional jump to 0x096c, if !(address(this).balance < stack[-2]) label_0916: // Incoming jump from 0x0915, if not !(address(this).balance < stack[-2]) // Inputs[1] { @0918 memory[0x40:0x60] } 0916 60 PUSH1 0x40 0918 51 MLOAD 0919 62 PUSH3 0x461bcd 091D 60 PUSH1 0xe5 091F 1B SHL 0920 81 DUP2 0921 52 MSTORE 0922 60 PUSH1 0x20 0924 60 PUSH1 0x04 0926 82 DUP3 0927 01 ADD 0928 52 MSTORE 0929 60 PUSH1 0x26 092B 60 PUSH1 0x24 092D 82 DUP3 092E 01 ADD 092F 52 MSTORE 0930 7F PUSH32 0x416464726573733a20696e73756666696369656e742062616c616e636520666f 0951 60 PUSH1 0x44 0953 82 DUP3 0954 01 ADD 0955 52 MSTORE 0956 65 PUSH6 0x1c8818d85b1b 095D 60 PUSH1 0xd2 095F 1B SHL 0960 60 PUSH1 0x64 0962 82 DUP3 0963 01 ADD 0964 52 MSTORE 0965 60 PUSH1 0x84 0967 01 ADD 0968 61 PUSH2 0x050e 096B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0921 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0928 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @092F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0955 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573733a20696e73756666696369656e742062616c616e636520666f // @0964 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1c8818d85b1b << 0xd2 // @0967 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x050e label_096C: // Incoming jump from 0x0915, if !(address(this).balance < stack[-2]) // Inputs[4] // { // @0970 stack[-5] // @097A stack[-3] // @097B stack[-4] // @097E memory[0x40:0x60] // } 096C 5B JUMPDEST 096D 60 PUSH1 0x00 096F 80 DUP1 0970 86 DUP7 0971 60 PUSH1 0x01 0973 60 PUSH1 0x01 0975 60 PUSH1 0xa0 0977 1B SHL 0978 03 SUB 0979 16 AND 097A 85 DUP6 097B 87 DUP8 097C 60 PUSH1 0x40 097E 51 MLOAD 097F 61 PUSH2 0x0988 0982 91 SWAP2 0983 90 SWAP1 0984 61 PUSH2 0x0bdb 0987 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @096D stack[0] = 0x00 // @096F stack[1] = 0x00 // @0979 stack[2] = (0x01 << 0xa0) - 0x01 & stack[-5] // @097A stack[3] = stack[-3] // @0982 stack[4] = 0x0988 // @0983 stack[5] = stack[-4] // @0983 stack[6] = memory[0x40:0x60] // } // Block ends with call to 0x0bdb, returns to 0x0988 label_0988: // Incoming return from call to 0x0BDB at 0x0987 // Inputs[8] // { // @098D memory[0x40:0x60] // @098F stack[-1] // @0992 stack[-2] // @0993 stack[-3] // @0994 msg.gas // @0995 address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0995 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @099A returndata.length // } 0988 5B JUMPDEST 0989 60 PUSH1 0x00 098B 60 PUSH1 0x40 098D 51 MLOAD 098E 80 DUP1 098F 83 DUP4 0990 03 SUB 0991 81 DUP2 0992 85 DUP6 0993 87 DUP8 0994 5A GAS 0995 F1 CALL 0996 92 SWAP3 0997 50 POP 0998 50 POP 0999 50 POP 099A 3D RETURNDATASIZE 099B 80 DUP1 099C 60 PUSH1 0x00 099E 81 DUP2 099F 14 EQ 09A0 61 PUSH2 0x09c5 09A3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0995 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0996 stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @099A stack[-2] = returndata.length // @099B stack[-1] = returndata.length // } // Block ends with conditional jump to 0x09c5, if returndata.length == 0x00 label_09A4: // Incoming jump from 0x09A3, if not returndata.length == 0x00 // Inputs[6] // { // @09A6 memory[0x40:0x60] // @09A7 stack[-2] // @09AE returndata.length // @09B6 returndata.length // @09B9 returndata.length // @09C0 returndata[0x00:0x00 + returndata.length] // } 09A4 60 PUSH1 0x40 09A6 51 MLOAD 09A7 91 SWAP2 09A8 50 POP 09A9 60 PUSH1 0x1f 09AB 19 NOT 09AC 60 PUSH1 0x3f 09AE 3D RETURNDATASIZE 09AF 01 ADD 09B0 16 AND 09B1 82 DUP3 09B2 01 ADD 09B3 60 PUSH1 0x40 09B5 52 MSTORE 09B6 3D RETURNDATASIZE 09B7 82 DUP3 09B8 52 MSTORE 09B9 3D RETURNDATASIZE 09BA 60 PUSH1 0x00 09BC 60 PUSH1 0x20 09BE 84 DUP5 09BF 01 ADD 09C0 3E RETURNDATACOPY 09C1 61 PUSH2 0x09ca 09C4 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @09A7 stack[-2] = memory[0x40:0x60] // @09B5 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @09B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @09C0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x09ca label_09C5: // Incoming jump from 0x09A3, if returndata.length == 0x00 // Inputs[6] // { // @09C8 stack[-2] // @09CC stack[-4] // @09CE stack[-5] // @09CE stack[-3] // @09D3 stack[-10] // @09D6 stack[-7] // } 09C5 5B JUMPDEST 09C6 60 PUSH1 0x60 09C8 91 SWAP2 09C9 50 POP 09CA 5B JUMPDEST 09CB 50 POP 09CC 91 SWAP2 09CD 50 POP 09CE 91 SWAP2 09CF 50 POP 09D0 61 PUSH2 0x09db 09D3 87 DUP8 09D4 83 DUP4 09D5 83 DUP4 09D6 87 DUP8 09D7 61 PUSH2 0x09e6 09DA 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @09CC stack[-4] = 0x60 // @09CE stack[-5] = stack[-3] // @09D0 stack[-3] = 0x09db // @09D3 stack[-2] = stack[-10] // @09D4 stack[-1] = stack[-3] // @09D5 stack[0] = 0x60 // @09D6 stack[1] = stack[-7] // } // Block ends with call to 0x09e6, returns to 0x09DB label_09DB: // Incoming return from call to 0x09E6 at 0x09DA // Incoming return from call to 0x09E6 at 0x09DA // Inputs[3] // { // @09DC stack[-9] // @09DC stack[-1] // @09DD stack[-8] // } 09DB 5B JUMPDEST 09DC 97 SWAP8 09DD 96 SWAP7 09DE 50 POP 09DF 50 POP 09E0 50 POP 09E1 50 POP 09E2 50 POP 09E3 50 POP 09E4 50 POP 09E5 56 *JUMP // Stack delta = -8 // Outputs[1] { @09DC stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_09E6: // Incoming call from 0x09DA, returns to 0x09DB // Incoming call from 0x09DA, returns to 0x09DB // Inputs[1] { @09E9 stack[-3] } 09E6 5B JUMPDEST 09E7 60 PUSH1 0x60 09E9 83 DUP4 09EA 15 ISZERO 09EB 61 PUSH2 0x0a55 09EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09E7 stack[0] = 0x60 } // Block ends with conditional jump to 0x0a55, if !stack[-3] label_09EF: // Incoming jump from 0x09EE, if not !stack[-3] // Inputs[2] // { // @09EF stack[-3] // @09F0 memory[stack[-3]:stack[-3] + 0x20] // } 09EF 82 DUP3 09F0 51 MLOAD 09F1 60 PUSH1 0x00 09F3 03 SUB 09F4 61 PUSH2 0x0a4e 09F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a4e, if 0x00 - memory[stack[-3]:stack[-3] + 0x20] label_09F8: // Incoming jump from 0x09F7, if not 0x00 - memory[stack[-3]:stack[-3] + 0x20] // Inputs[2] // { // @0A00 stack[-5] // @0A02 address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // } 09F8 60 PUSH1 0x01 09FA 60 PUSH1 0x01 09FC 60 PUSH1 0xa0 09FE 1B SHL 09FF 03 SUB 0A00 85 DUP6 0A01 16 AND 0A02 3B EXTCODESIZE 0A03 61 PUSH2 0x0a4e 0A06 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a4e, if address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length label_0A07: // Incoming jump from 0x0A06, if not address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0A09 memory[0x40:0x60] } 0A07 60 PUSH1 0x40 0A09 51 MLOAD 0A0A 62 PUSH3 0x461bcd 0A0E 60 PUSH1 0xe5 0A10 1B SHL 0A11 81 DUP2 0A12 52 MSTORE 0A13 60 PUSH1 0x20 0A15 60 PUSH1 0x04 0A17 82 DUP3 0A18 01 ADD 0A19 52 MSTORE 0A1A 60 PUSH1 0x1d 0A1C 60 PUSH1 0x24 0A1E 82 DUP3 0A1F 01 ADD 0A20 52 MSTORE 0A21 7F PUSH32 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 0A42 60 PUSH1 0x44 0A44 82 DUP3 0A45 01 ADD 0A46 52 MSTORE 0A47 60 PUSH1 0x64 0A49 01 ADD 0A4A 61 PUSH2 0x050e 0A4D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A19 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A20 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @0A46 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 // @0A49 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x050e label_0A4E: // Incoming jump from 0x0A06, if address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x09F7, if 0x00 - memory[stack[-3]:stack[-3] + 0x20] // Inputs[1] { @0A50 stack[-3] } 0A4E 5B JUMPDEST 0A4F 50 POP 0A50 81 DUP2 0A51 61 PUSH2 0x0903 0A54 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A50 stack[-1] = stack[-3] } // Block ends with unconditional jump to 0x0903 label_0A55: // Incoming jump from 0x09EE, if !stack[-3] // Inputs[3] // { // @0A59 stack[-3] // @0A5A stack[-2] // @0A5C memory[stack[-3]:stack[-3] + 0x20] // } 0A55 5B JUMPDEST 0A56 61 PUSH2 0x0903 0A59 83 DUP4 0A5A 83 DUP4 0A5B 81 DUP2 0A5C 51 MLOAD 0A5D 15 ISZERO 0A5E 61 PUSH2 0x0a6a 0A61 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A56 stack[0] = 0x0903 // @0A59 stack[1] = stack[-3] // @0A5A stack[2] = stack[-2] // } // Block ends with conditional jump to 0x0a6a, if !memory[stack[-3]:stack[-3] + 0x20] label_0A62: // Incoming jump from 0x0A61, if not !memory[stack[-3]:stack[-3] + 0x20] // Inputs[3] // { // @0A62 stack[-2] // @0A63 memory[stack[-2]:stack[-2] + 0x20] // @0A69 memory[0x20 + stack[-2]:0x20 + stack[-2] + memory[stack[-2]:stack[-2] + 0x20]] // } 0A62 81 DUP2 0A63 51 MLOAD 0A64 80 DUP1 0A65 83 DUP4 0A66 60 PUSH1 0x20 0A68 01 ADD 0A69 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @0A63 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @0A69 revert(memory[0x20 + stack[-2]:0x20 + stack[-2] + memory[stack[-2]:stack[-2] + 0x20]]); // } // Block terminates label_0A6A: // Incoming jump from 0x0A61, if !memory[stack[-3]:stack[-3] + 0x20] // Inputs[2] // { // @0A6B stack[-1] // @0A6E memory[0x40:0x60] // } 0A6A 5B JUMPDEST 0A6B 80 DUP1 0A6C 60 PUSH1 0x40 0A6E 51 MLOAD 0A6F 62 PUSH3 0x461bcd 0A73 60 PUSH1 0xe5 0A75 1B SHL 0A76 81 DUP2 0A77 52 MSTORE 0A78 60 PUSH1 0x04 0A7A 01 ADD 0A7B 61 PUSH2 0x050e 0A7E 91 SWAP2 0A7F 90 SWAP1 0A80 61 PUSH2 0x0bf7 0A83 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0A77 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A7E stack[0] = 0x050e // @0A7F stack[1] = stack[-1] // @0A7F stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x0bf7, returns to 0x050E label_0A84: // Incoming call from 0x0107, returns to 0x0108 // Incoming call from 0x01B7, returns to 0x01B8 // Incoming call from 0x0124, returns to 0x0125 // Incoming call from 0x01F5, returns to 0x01F6 // Inputs[2] // { // @0A89 stack[-1] // @0A8A stack[-2] // } 0A84 5B JUMPDEST 0A85 60 PUSH1 0x00 0A87 60 PUSH1 0x20 0A89 82 DUP3 0A8A 84 DUP5 0A8B 03 SUB 0A8C 12 SLT 0A8D 15 ISZERO 0A8E 61 PUSH2 0x0a96 0A91 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A85 stack[0] = 0x00 } // Block ends with conditional jump to 0x0a96, if !(stack[-2] - stack[-1] i< 0x20) label_0A92: // Incoming jump from 0x0A91, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0A95 memory[0x00:0x00] } 0A92 60 PUSH1 0x00 0A94 80 DUP1 0A95 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A95 revert(memory[0x00:0x00]); } // Block terminates label_0A96: // Incoming jump from 0x0A91, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @0A98 stack[-2] // @0A98 msg.data[stack[-2]:stack[-2] + 0x20] // @0A99 stack[-4] // @0A9A stack[-3] // } 0A96 5B JUMPDEST 0A97 50 POP 0A98 35 CALLDATALOAD 0A99 91 SWAP2 0A9A 90 SWAP1 0A9B 50 POP 0A9C 56 *JUMP // Stack delta = -3 // Outputs[1] { @0A99 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0A9D: // Incoming call from 0x0208, returns to 0x0209 // Inputs[2] // { // @0AA5 stack[-1] // @0AA6 stack[-2] // } 0A9D 5B JUMPDEST 0A9E 60 PUSH1 0x00 0AA0 80 DUP1 0AA1 60 PUSH1 0x00 0AA3 60 PUSH1 0x40 0AA5 84 DUP5 0AA6 86 DUP7 0AA7 03 SUB 0AA8 12 SLT 0AA9 15 ISZERO 0AAA 61 PUSH2 0x0ab2 0AAD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A9E stack[0] = 0x00 // @0AA0 stack[1] = 0x00 // @0AA1 stack[2] = 0x00 // } // Block ends with conditional jump to 0x0ab2, if !(stack[-2] - stack[-1] i< 0x40) label_0AAE: // Incoming jump from 0x0AAD, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0AB1 memory[0x00:0x00] } 0AAE 60 PUSH1 0x00 0AB0 80 DUP1 0AB1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AB1 revert(memory[0x00:0x00]); } // Block terminates label_0AB2: // Incoming jump from 0x0AAD, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @0AB3 stack[-4] // @0AB4 msg.data[stack[-4]:stack[-4] + 0x20] // @0AB5 stack[-3] // @0ABB msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 0AB2 5B JUMPDEST 0AB3 83 DUP4 0AB4 35 CALLDATALOAD 0AB5 92 SWAP3 0AB6 50 POP 0AB7 60 PUSH1 0x20 0AB9 84 DUP5 0ABA 01 ADD 0ABB 35 CALLDATALOAD 0ABC 67 PUSH8 0xffffffffffffffff 0AC5 80 DUP1 0AC6 82 DUP3 0AC7 11 GT 0AC8 15 ISZERO 0AC9 61 PUSH2 0x0ad1 0ACC 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0AB5 stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @0ABB stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @0ABC stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x0ad1, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_0ACD: // Incoming jump from 0x0ACC, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0AD0 memory[0x00:0x00] } 0ACD 60 PUSH1 0x00 0ACF 80 DUP1 0AD0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AD0 revert(memory[0x00:0x00]); } // Block terminates label_0AD1: // Incoming jump from 0x0ACC, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0AD2 stack[-2] // @0AD3 stack[-6] // @0AD7 stack[-7] // } 0AD1 5B JUMPDEST 0AD2 81 DUP2 0AD3 86 DUP7 0AD4 01 ADD 0AD5 91 SWAP2 0AD6 50 POP 0AD7 86 DUP7 0AD8 60 PUSH1 0x1f 0ADA 83 DUP4 0ADB 01 ADD 0ADC 12 SLT 0ADD 61 PUSH2 0x0ae5 0AE0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0AD5 stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x0ae5, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_0AE1: // Incoming jump from 0x0AE0, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @0AE4 memory[0x00:0x00] } 0AE1 60 PUSH1 0x00 0AE3 80 DUP1 0AE4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AE4 revert(memory[0x00:0x00]); } // Block terminates label_0AE5: // Incoming jump from 0x0AE0, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @0AE6 stack[-2] // @0AE7 msg.data[stack[-2]:stack[-2] + 0x20] // @0AE8 stack[-1] // } 0AE5 5B JUMPDEST 0AE6 81 DUP2 0AE7 35 CALLDATALOAD 0AE8 81 DUP2 0AE9 81 DUP2 0AEA 11 GT 0AEB 15 ISZERO 0AEC 61 PUSH2 0x0af4 0AEF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AE7 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0af4, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_0AF0: // Incoming jump from 0x0AEF, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @0AF3 memory[0x00:0x00] } 0AF0 60 PUSH1 0x00 0AF2 80 DUP1 0AF3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AF3 revert(memory[0x00:0x00]); } // Block terminates label_0AF4: // Incoming jump from 0x0AEF, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @0AF5 stack[-8] // @0AF8 stack[-1] // @0AF9 stack[-3] // } 0AF4 5B JUMPDEST 0AF5 87 DUP8 0AF6 60 PUSH1 0x20 0AF8 82 DUP3 0AF9 85 DUP6 0AFA 01 ADD 0AFB 01 ADD 0AFC 11 GT 0AFD 15 ISZERO 0AFE 61 PUSH2 0x0b06 0B01 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b06, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) label_0B02: // Incoming jump from 0x0B01, if not !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[1] { @0B05 memory[0x00:0x00] } 0B02 60 PUSH1 0x00 0B04 80 DUP1 0B05 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B05 revert(memory[0x00:0x00]); } // Block terminates label_0B06: // Incoming jump from 0x0B01, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[8] // { // @0B09 stack[-3] // @0B0B stack[-5] // @0B0D stack[-1] // @0B0E stack[-4] // @0B13 stack[-7] // @0B15 stack[-8] // @0B17 stack[-9] // @0B17 stack[-6] // } 0B06 5B JUMPDEST 0B07 60 PUSH1 0x20 0B09 83 DUP4 0B0A 01 ADD 0B0B 94 SWAP5 0B0C 50 POP 0B0D 80 DUP1 0B0E 93 SWAP4 0B0F 50 POP 0B10 50 POP 0B11 50 POP 0B12 50 POP 0B13 92 SWAP3 0B14 50 POP 0B15 92 SWAP3 0B16 50 POP 0B17 92 SWAP3 0B18 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @0B13 stack[-7] = stack[-1] // @0B15 stack[-8] = stack[-3] + 0x20 // @0B17 stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] label_0B19: // Incoming call from 0x021B, returns to 0x021C // Inputs[2] // { // @0B1E stack[-1] // @0B1F stack[-2] // } 0B19 5B JUMPDEST 0B1A 60 PUSH1 0x00 0B1C 60 PUSH1 0x20 0B1E 82 DUP3 0B1F 84 DUP5 0B20 03 SUB 0B21 12 SLT 0B22 15 ISZERO 0B23 61 PUSH2 0x0b2b 0B26 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B1A stack[0] = 0x00 } // Block ends with conditional jump to 0x0b2b, if !(stack[-2] - stack[-1] i< 0x20) label_0B27: // Incoming jump from 0x0B26, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0B2A memory[0x00:0x00] } 0B27 60 PUSH1 0x00 0B29 80 DUP1 0B2A FD *REVERT // Stack delta = +0 // Outputs[1] { @0B2A revert(memory[0x00:0x00]); } // Block terminates label_0B2B: // Incoming jump from 0x0B26, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0B2C stack[-2] // @0B2D msg.data[stack[-2]:stack[-2] + 0x20] // } 0B2B 5B JUMPDEST 0B2C 81 DUP2 0B2D 35 CALLDATALOAD 0B2E 60 PUSH1 0x01 0B30 60 PUSH1 0x01 0B32 60 PUSH1 0xa0 0B34 1B SHL 0B35 03 SUB 0B36 81 DUP2 0B37 16 AND 0B38 81 DUP2 0B39 14 EQ 0B3A 61 PUSH2 0x0b42 0B3D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B2D stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0b42, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 label_0B3E: // Incoming jump from 0x0B3D, if not msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B41 memory[0x00:0x00] } 0B3E 60 PUSH1 0x00 0B40 80 DUP1 0B41 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B41 revert(memory[0x00:0x00]); } // Block terminates label_0B42: // Incoming jump from 0x0B3D, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0B43 stack[-1] // @0B43 stack[-5] // @0B44 stack[-4] // } 0B42 5B JUMPDEST 0B43 93 SWAP4 0B44 92 SWAP3 0B45 50 POP 0B46 50 POP 0B47 50 POP 0B48 56 *JUMP // Stack delta = -4 // Outputs[1] { @0B43 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0B49: // Incoming jump from 0x0B84 // Incoming jump from 0x0B71 // Inputs[1] { @0B5E memory[0x00:0x24] } 0B49 5B JUMPDEST 0B4A 63 PUSH4 0x4e487b71 0B4F 60 PUSH1 0xe0 0B51 1B SHL 0B52 60 PUSH1 0x00 0B54 52 MSTORE 0B55 60 PUSH1 0x11 0B57 60 PUSH1 0x04 0B59 52 MSTORE 0B5A 60 PUSH1 0x24 0B5C 60 PUSH1 0x00 0B5E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0B54 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0B59 memory[0x04:0x24] = 0x11 // @0B5E revert(memory[0x00:0x24]); // } // Block terminates label_0B5F: // Incoming call from 0x026D, returns to 0x026E // Inputs[2] // { // @0B60 stack[-2] // @0B61 stack[-1] // } 0B5F 5B JUMPDEST 0B60 81 DUP2 0B61 81 DUP2 0B62 03 SUB 0B63 81 DUP2 0B64 81 DUP2 0B65 11 GT 0B66 15 ISZERO 0B67 61 PUSH2 0x05f3 0B6A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B62 stack[0] = stack[-1] - stack[-2] } // Block ends with conditional jump to 0x05f3, if !(stack[-1] - stack[-2] > stack[-1]) label_0B6B: // Incoming jump from 0x0B6A, if not !(stack[-1] - stack[-2] > stack[-1]) 0B6B 61 PUSH2 0x05f3 0B6E 61 PUSH2 0x0b49 0B71 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B6B stack[0] = 0x05f3 } // Block ends with unconditional jump to 0x0b49 label_0B72: // Incoming call from 0x0417, returns to 0x0418 // Incoming call from 0x0372, returns to 0x0373 // Inputs[2] // { // @0B73 stack[-1] // @0B74 stack[-2] // } 0B72 5B JUMPDEST 0B73 80 DUP1 0B74 82 DUP3 0B75 01 ADD 0B76 80 DUP1 0B77 82 DUP3 0B78 11 GT 0B79 15 ISZERO 0B7A 61 PUSH2 0x05f3 0B7D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B75 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x05f3, if !(stack[-1] > stack[-2] + stack[-1]) label_0B7E: // Incoming jump from 0x0B7D, if not !(stack[-1] > stack[-2] + stack[-1]) 0B7E 61 PUSH2 0x05f3 0B81 61 PUSH2 0x0b49 0B84 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B7E stack[0] = 0x05f3 } // Block ends with unconditional jump to 0x0b49 0B85 5B JUMPDEST 0B86 81 DUP2 0B87 83 DUP4 0B88 82 DUP3 0B89 37 CALLDATACOPY 0B8A 60 PUSH1 0x00 0B8C 91 SWAP2 0B8D 01 ADD 0B8E 90 SWAP1 0B8F 81 DUP2 0B90 52 MSTORE 0B91 91 SWAP2 0B92 90 SWAP1 0B93 50 POP 0B94 56 *JUMP 0B95 5B JUMPDEST 0B96 60 PUSH1 0x00 0B98 60 PUSH1 0x20 0B9A 82 DUP3 0B9B 84 DUP5 0B9C 03 SUB 0B9D 12 SLT 0B9E 15 ISZERO 0B9F 61 PUSH2 0x0ba7 0BA2 57 *JUMPI 0BA3 60 PUSH1 0x00 0BA5 80 DUP1 0BA6 FD *REVERT 0BA7 5B JUMPDEST 0BA8 81 DUP2 0BA9 51 MLOAD 0BAA 80 DUP1 0BAB 15 ISZERO 0BAC 15 ISZERO 0BAD 81 DUP2 0BAE 14 EQ 0BAF 61 PUSH2 0x0b42 0BB2 57 *JUMPI 0BB3 60 PUSH1 0x00 0BB5 80 DUP1 0BB6 FD *REVERT label_0BB7: // Incoming call from 0x0C15, returns to 0x0C16 // Incoming call from 0x0BEC, returns to 0x0BED // Inputs[1] { @0BBB stack[-3] } 0BB7 5B JUMPDEST 0BB8 60 PUSH1 0x00 0BBA 5B JUMPDEST 0BBB 83 DUP4 0BBC 81 DUP2 0BBD 10 LT 0BBE 15 ISZERO 0BBF 61 PUSH2 0x0bd2 0BC2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BB8 stack[0] = 0x00 } // Block ends with conditional jump to 0x0bd2, if !(0x00 < stack[-3]) label_0BC3: // Incoming jump from 0x0BC2, if not !(0x00 < stack[-3]) // Incoming jump from 0x0BC2, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0BC3 stack[-2] // @0BC4 stack[-1] // @0BC6 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0BC7 stack[-3] // } 0BC3 81 DUP2 0BC4 81 DUP2 0BC5 01 ADD 0BC6 51 MLOAD 0BC7 83 DUP4 0BC8 82 DUP3 0BC9 01 ADD 0BCA 52 MSTORE 0BCB 60 PUSH1 0x20 0BCD 01 ADD 0BCE 61 PUSH2 0x0bba 0BD1 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0BCA memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0BCD stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0bba label_0BD2: // Incoming jump from 0x0BC2, if !(0x00 < stack[-3]) // Incoming jump from 0x0BC2, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0BD7 stack[-4] // @0BD8 stack[-3] // @0BDA stack[-5] // } 0BD2 5B JUMPDEST 0BD3 50 POP 0BD4 50 POP 0BD5 60 PUSH1 0x00 0BD7 91 SWAP2 0BD8 01 ADD 0BD9 52 MSTORE 0BDA 56 *JUMP // Stack delta = -5 // Outputs[1] { @0BD9 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_0BDB: // Incoming call from 0x0987, returns to 0x0988 // Inputs[3] // { // @0BDE stack[-2] // @0BDF memory[stack[-2]:stack[-2] + 0x20] // @0BE4 stack[-1] // } 0BDB 5B JUMPDEST 0BDC 60 PUSH1 0x00 0BDE 82 DUP3 0BDF 51 MLOAD 0BE0 61 PUSH2 0x0bed 0BE3 81 DUP2 0BE4 84 DUP5 0BE5 60 PUSH1 0x20 0BE7 87 DUP8 0BE8 01 ADD 0BE9 61 PUSH2 0x0bb7 0BEC 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0BDC stack[0] = 0x00 // @0BDF stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @0BE0 stack[2] = 0x0bed // @0BE3 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0BE4 stack[4] = stack[-1] // @0BE8 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x0bb7, returns to 0x0BED label_0BED: // Incoming return from call to 0x0BB7 at 0x0BEC // Inputs[5] // { // @0BEE stack[-1] // @0BEE stack[-3] // @0BEF stack[-2] // @0BF2 stack[-5] // @0BF3 stack[-4] // } 0BED 5B JUMPDEST 0BEE 91 SWAP2 0BEF 90 SWAP1 0BF0 91 SWAP2 0BF1 01 ADD 0BF2 92 SWAP3 0BF3 91 SWAP2 0BF4 50 POP 0BF5 50 POP 0BF6 56 *JUMP // Stack delta = -4 // Outputs[1] { @0BF2 stack[-5] = stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] label_0BF7: // Incoming call from 0x0A83, returns to 0x050E // Inputs[3] // { // @0BFA stack[-1] // @0BFE stack[-2] // @0BFF memory[stack[-2]:stack[-2] + 0x20] // } 0BF7 5B JUMPDEST 0BF8 60 PUSH1 0x20 0BFA 81 DUP2 0BFB 52 MSTORE 0BFC 60 PUSH1 0x00 0BFE 82 DUP3 0BFF 51 MLOAD 0C00 80 DUP1 0C01 60 PUSH1 0x20 0C03 84 DUP5 0C04 01 ADD 0C05 52 MSTORE 0C06 61 PUSH2 0x0c16 0C09 81 DUP2 0C0A 60 PUSH1 0x40 0C0C 85 DUP6 0C0D 01 ADD 0C0E 60 PUSH1 0x20 0C10 87 DUP8 0C11 01 ADD 0C12 61 PUSH2 0x0bb7 0C15 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0BFB memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @0BFC stack[0] = 0x00 // @0BFF stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @0C05 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0C06 stack[2] = 0x0c16 // @0C09 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0C0D stack[4] = stack[-1] + 0x40 // @0C11 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x0bb7, returns to 0x0C16 label_0C16: // Incoming return from call to 0x0BB7 at 0x0C15 // Inputs[5] // { // @0C19 stack[-1] // @0C1E stack[-3] // @0C1F stack[-2] // @0C25 stack[-5] // @0C26 stack[-4] // } 0C16 5B JUMPDEST 0C17 60 PUSH1 0x1f 0C19 01 ADD 0C1A 60 PUSH1 0x1f 0C1C 19 NOT 0C1D 16 AND 0C1E 91 SWAP2 0C1F 90 SWAP1 0C20 91 SWAP2 0C21 01 ADD 0C22 60 PUSH1 0x40 0C24 01 ADD 0C25 92 SWAP3 0C26 91 SWAP2 0C27 50 POP 0C28 50 POP 0C29 56 *JUMP // Stack delta = -4 // Outputs[1] { @0C25 stack[-5] = 0x40 + (~0x1f & 0x1f + stack[-1]) + stack[-3] } // Block ends with unconditional jump to stack[-5] 0C2A FE *ASSERT 0C2B A2 LOG2 0C2C 64 PUSH5 0x6970667358 0C32 22 22 0C33 12 SLT 0C34 20 SHA3 0C35 CA CA 0C36 AE AE 0C37 F0 CREATE 0C38 F0 CREATE 0C39 D6 D6 0C3A 25 25 0C3B F9 F9 0C3C 47 SELFBALANCE 0C3D 55 SSTORE 0C3E E0 E0 0C3F BD BD 0C40 C7 C7 0C41 C9 C9 0C42 A1 LOG1 0C43 4F 4F 0C44 00 *STOP 0C45 F2 CALLCODE 0C46 B9 B9 0C47 61 PUSH2 0x009e 0C4A 67 PUSH8 0x8254f1114a83f583 0C53 0C 0C 0C54 75 PUSH22 0x64736f6c63430008130033