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 0x01e4 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01e4, 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 0x731133e9 0026 11 GT 0027 61 PUSH2 0x010f 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x010f, if 0x731133e9 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x731133e9 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xd547741f 0031 11 GT 0032 61 PUSH2 0x00a2 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a2, if 0xd547741f > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xd547741f > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xf242432a 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xf242432a > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xf242432a > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xf242432a 0047 14 EQ 0048 61 PUSH2 0x04f1 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f1, if 0xf242432a == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xf242432a == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf2fde38b 0052 14 EQ 0053 61 PUSH2 0x0504 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0504, if 0xf2fde38b == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf5298aca 005D 14 EQ 005E 61 PUSH2 0x0517 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0517, if 0xf5298aca == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf5298aca == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xfaf21c7f 0068 14 EQ 0069 61 PUSH2 0x052a 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052a, if 0xfaf21c7f == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xfaf21c7f == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x0040, if 0xf242432a > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xd547741f 0078 14 EQ 0079 61 PUSH2 0x0468 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0468, if 0xd547741f == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xd547741f == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xe2e784d5 0083 14 EQ 0084 61 PUSH2 0x047b 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047b, if 0xe2e784d5 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xe2e784d5 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xe985e9c5 008E 14 EQ 008F 61 PUSH2 0x048e 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048e, if 0xe985e9c5 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xe9a9c850 0099 14 EQ 009A 61 PUSH2 0x04ca 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ca, if 0xe9a9c850 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xe9a9c850 == stack[-1] // Inputs[1] { @00A1 memory[0x00:0x00] } 009E 60 PUSH1 0x00 00A0 80 DUP1 00A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A1 revert(memory[0x00:0x00]); } // Block terminates label_00A2: // Incoming jump from 0x0035, if 0xd547741f > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0x91d14854 00A9 11 GT 00AA 61 PUSH2 0x00de 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00de, if 0x91d14854 > stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x91d14854 > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x91d14854 00B4 14 EQ 00B5 61 PUSH2 0x03f4 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f4, if 0x91d14854 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x91d14854 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0xa217fddf 00BF 14 EQ 00C0 61 PUSH2 0x042d 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042d, if 0xa217fddf == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xa217fddf == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xa22cb465 00CA 14 EQ 00CB 61 PUSH2 0x0435 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0435, if 0xa22cb465 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xbd85b039 00D5 14 EQ 00D6 61 PUSH2 0x0448 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0448, if 0xbd85b039 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xbd85b039 == stack[-1] // Inputs[1] { @00DD memory[0x00:0x00] } 00DA 60 PUSH1 0x00 00DC 80 DUP1 00DD FD *REVERT // Stack delta = +0 // Outputs[1] { @00DD revert(memory[0x00:0x00]); } // Block terminates label_00DE: // Incoming jump from 0x00AD, if 0x91d14854 > stack[-1] // Inputs[1] { @00DF stack[-1] } 00DE 5B JUMPDEST 00DF 80 DUP1 00E0 63 PUSH4 0x731133e9 00E5 14 EQ 00E6 61 PUSH2 0x03a0 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a0, if 0x731133e9 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x731133e9 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x862440e2 00F0 14 EQ 00F1 61 PUSH2 0x03b3 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b3, if 0x862440e2 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x862440e2 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x88e3c8d6 00FB 14 EQ 00FC 61 PUSH2 0x03c6 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c6, if 0x88e3c8d6 == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x88e3c8d6 == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0x8da5cb5b 0106 14 EQ 0107 61 PUSH2 0x03d9 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d9, if 0x8da5cb5b == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @010E memory[0x00:0x00] } 010B 60 PUSH1 0x00 010D 80 DUP1 010E FD *REVERT // Stack delta = +0 // Outputs[1] { @010E revert(memory[0x00:0x00]); } // Block terminates label_010F: // Incoming jump from 0x002A, if 0x731133e9 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0110 stack[-1] } 010F 5B JUMPDEST 0110 80 DUP1 0111 63 PUSH4 0x2eb2c2d6 0116 11 GT 0117 61 PUSH2 0x0187 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0187, if 0x2eb2c2d6 > stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x2eb2c2d6 > stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x4f558e79 0121 11 GT 0122 61 PUSH2 0x0156 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0156, if 0x4f558e79 > stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x4f558e79 > stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x4f558e79 012C 14 EQ 012D 61 PUSH2 0x0350 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0350, if 0x4f558e79 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x4f558e79 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x55732e9b 0137 14 EQ 0138 61 PUSH2 0x0372 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0372, if 0x55732e9b == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x55732e9b == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x6b20c454 0142 14 EQ 0143 61 PUSH2 0x0385 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0385, if 0x6b20c454 == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x6b20c454 == stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x715018a6 014D 14 EQ 014E 61 PUSH2 0x0398 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0398, if 0x715018a6 == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x715018a6 == stack[-1] // Inputs[1] { @0155 memory[0x00:0x00] } 0152 60 PUSH1 0x00 0154 80 DUP1 0155 FD *REVERT // Stack delta = +0 // Outputs[1] { @0155 revert(memory[0x00:0x00]); } // Block terminates label_0156: // Incoming jump from 0x0125, if 0x4f558e79 > stack[-1] // Inputs[1] { @0157 stack[-1] } 0156 5B JUMPDEST 0157 80 DUP1 0158 63 PUSH4 0x2eb2c2d6 015D 14 EQ 015E 61 PUSH2 0x02f5 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f5, if 0x2eb2c2d6 == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0162 stack[-1] } 0162 80 DUP1 0163 63 PUSH4 0x2f2ff15d 0168 14 EQ 0169 61 PUSH2 0x030a 016C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030a, if 0x2f2ff15d == stack[-1] label_016D: // Incoming jump from 0x016C, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @016D stack[-1] } 016D 80 DUP1 016E 63 PUSH4 0x36568abe 0173 14 EQ 0174 61 PUSH2 0x031d 0177 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031d, if 0x36568abe == stack[-1] label_0178: // Incoming jump from 0x0177, if not 0x36568abe == stack[-1] // Inputs[1] { @0178 stack[-1] } 0178 80 DUP1 0179 63 PUSH4 0x4e1273f4 017E 14 EQ 017F 61 PUSH2 0x0330 0182 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0330, if 0x4e1273f4 == stack[-1] label_0183: // Incoming jump from 0x0182, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @0186 memory[0x00:0x00] } 0183 60 PUSH1 0x00 0185 80 DUP1 0186 FD *REVERT // Stack delta = +0 // Outputs[1] { @0186 revert(memory[0x00:0x00]); } // Block terminates label_0187: // Incoming jump from 0x011A, if 0x2eb2c2d6 > stack[-1] // Inputs[1] { @0188 stack[-1] } 0187 5B JUMPDEST 0188 80 DUP1 0189 63 PUSH4 0x0e89341c 018E 11 GT 018F 61 PUSH2 0x01c3 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c3, if 0x0e89341c > stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x0e89341c > stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x0e89341c 0199 14 EQ 019A 61 PUSH2 0x0259 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0259, if 0x0e89341c == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x0e89341c == stack[-1] // Inputs[1] { @019E stack[-1] } 019E 80 DUP1 019F 63 PUSH4 0x248a9ca3 01A4 14 EQ 01A5 61 PUSH2 0x0279 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0279, if 0x248a9ca3 == stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @01A9 stack[-1] } 01A9 80 DUP1 01AA 63 PUSH4 0x282c51f3 01AF 14 EQ 01B0 61 PUSH2 0x029c 01B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029c, if 0x282c51f3 == stack[-1] label_01B4: // Incoming jump from 0x01B3, if not 0x282c51f3 == stack[-1] // Inputs[1] { @01B4 stack[-1] } 01B4 80 DUP1 01B5 63 PUSH4 0x2a55205a 01BA 14 EQ 01BB 61 PUSH2 0x02c3 01BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c3, if 0x2a55205a == stack[-1] label_01BF: // Incoming jump from 0x01BE, if not 0x2a55205a == stack[-1] // Inputs[1] { @01C2 memory[0x00:0x00] } 01BF 60 PUSH1 0x00 01C1 80 DUP1 01C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C2 revert(memory[0x00:0x00]); } // Block terminates label_01C3: // Incoming jump from 0x0192, if 0x0e89341c > stack[-1] // Inputs[1] { @01C4 stack[-1] } 01C3 5B JUMPDEST 01C4 80 DUP1 01C5 62 PUSH3 0xfdd58e 01C9 14 EQ 01CA 61 PUSH2 0x01e9 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e9, if 0xfdd58e == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0xfdd58e == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x01ffc9a7 01D4 14 EQ 01D5 61 PUSH2 0x020f 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020f, if 0x01ffc9a7 == stack[-1] label_01D9: // Incoming jump from 0x01D8, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01D9 stack[-1] } 01D9 80 DUP1 01DA 63 PUSH4 0x0ab5f32a 01DF 14 EQ 01E0 61 PUSH2 0x0232 01E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0232, if 0x0ab5f32a == stack[-1] label_01E4: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x01E3, if not 0x0ab5f32a == stack[-1] // Inputs[1] { @01E8 memory[0x00:0x00] } 01E4 5B JUMPDEST 01E5 60 PUSH1 0x00 01E7 80 DUP1 01E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E8 revert(memory[0x00:0x00]); } // Block terminates label_01E9: // Incoming jump from 0x01CD, if 0xfdd58e == stack[-1] // Inputs[1] { @01F0 msg.data.length } 01E9 5B JUMPDEST 01EA 61 PUSH2 0x01fc 01ED 61 PUSH2 0x01f7 01F0 36 CALLDATASIZE 01F1 60 PUSH1 0x04 01F3 61 PUSH2 0x2347 01F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01EA stack[0] = 0x01fc // @01ED stack[1] = 0x01f7 // @01F0 stack[2] = msg.data.length // @01F1 stack[3] = 0x04 // } // Block ends with call to 0x2347, returns to 0x01F7 label_01F7: // Incoming return from call to 0x2347 at 0x01F6 01F7 5B JUMPDEST 01F8 61 PUSH2 0x053d 01FB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x053d label_01FC: // Incoming jump from 0x0434 // Incoming return from call to 0x0456 at 0x0455 // Incoming return from call to 0x0287 at 0x0286 // Incoming jump from 0x04F0 // Incoming jump from 0x02C2 // Incoming return from call to 0x01F7 at 0x01F6 // Incoming jump from 0x0258 // Inputs[4] // { // @01FF memory[0x40:0x60] // @0200 stack[-1] // @0209 memory[0x40:0x60] // @020E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01FC 5B JUMPDEST 01FD 60 PUSH1 0x40 01FF 51 MLOAD 0200 90 SWAP1 0201 81 DUP2 0202 52 MSTORE 0203 60 PUSH1 0x20 0205 01 ADD 0206 5B JUMPDEST 0207 60 PUSH1 0x40 0209 51 MLOAD 020A 80 DUP1 020B 91 SWAP2 020C 03 SUB 020D 90 SWAP1 020E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0202 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @020E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_020F: // Incoming jump from 0x01D8, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0216 msg.data.length } 020F 5B JUMPDEST 0210 61 PUSH2 0x0222 0213 61 PUSH2 0x021d 0216 36 CALLDATASIZE 0217 60 PUSH1 0x04 0219 61 PUSH2 0x2387 021C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0210 stack[0] = 0x0222 // @0213 stack[1] = 0x021d // @0216 stack[2] = msg.data.length // @0217 stack[3] = 0x04 // } // Block ends with call to 0x2387, returns to 0x021D label_021D: // Incoming return from call to 0x2387 at 0x021C 021D 5B JUMPDEST 021E 61 PUSH2 0x05e6 0221 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05e6 label_0222: // Incoming return from call to 0x0402 at 0x0401 // Incoming return from call to 0x035E at 0x035D // Inputs[2] // { // @0225 memory[0x40:0x60] // @0226 stack[-1] // } 0222 5B JUMPDEST 0223 60 PUSH1 0x40 0225 51 MLOAD 0226 90 SWAP1 0227 15 ISZERO 0228 15 ISZERO 0229 81 DUP2 022A 52 MSTORE 022B 60 PUSH1 0x20 022D 01 ADD 022E 61 PUSH2 0x0206 0231 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @022A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @022D stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0206 label_0232: // Incoming jump from 0x01E3, if 0x0ab5f32a == stack[-1] 0232 5B JUMPDEST 0233 61 PUSH2 0x01fc 0236 7F PUSH32 0x4a78764b0e84f45a602e24e86f19a3e2af7956f2a9112d825c8b5ca7991c711f 0257 81 DUP2 0258 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0233 stack[0] = 0x01fc // @0236 stack[1] = 0x4a78764b0e84f45a602e24e86f19a3e2af7956f2a9112d825c8b5ca7991c711f // } // Block ends with unconditional jump to 0x01fc label_0259: // Incoming jump from 0x019D, if 0x0e89341c == stack[-1] // Inputs[1] { @0260 msg.data.length } 0259 5B JUMPDEST 025A 61 PUSH2 0x026c 025D 61 PUSH2 0x0267 0260 36 CALLDATASIZE 0261 60 PUSH1 0x04 0263 61 PUSH2 0x23a4 0266 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @025A stack[0] = 0x026c // @025D stack[1] = 0x0267 // @0260 stack[2] = msg.data.length // @0261 stack[3] = 0x04 // } // Block ends with call to 0x23a4, returns to 0x0267 label_0267: // Incoming return from call to 0x23A4 at 0x0266 0267 5B JUMPDEST 0268 61 PUSH2 0x05f7 026B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05f7 label_026C: // Incoming return from call to 0x0267 at 0x0266 // Inputs[2] // { // @026F memory[0x40:0x60] // @0273 stack[-1] // } 026C 5B JUMPDEST 026D 60 PUSH1 0x40 026F 51 MLOAD 0270 61 PUSH2 0x0206 0273 91 SWAP2 0274 90 SWAP1 0275 61 PUSH2 0x2415 0278 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0273 stack[-1] = 0x0206 // @0274 stack[1] = memory[0x40:0x60] // @0274 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2415 label_0279: // Incoming jump from 0x01A8, if 0x248a9ca3 == stack[-1] // Inputs[1] { @0280 msg.data.length } 0279 5B JUMPDEST 027A 61 PUSH2 0x01fc 027D 61 PUSH2 0x0287 0280 36 CALLDATASIZE 0281 60 PUSH1 0x04 0283 61 PUSH2 0x23a4 0286 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @027A stack[0] = 0x01fc // @027D stack[1] = 0x0287 // @0280 stack[2] = msg.data.length // @0281 stack[3] = 0x04 // } // Block ends with call to 0x23a4, returns to 0x0287 label_0287: // Incoming return from call to 0x23A4 at 0x0286 // Inputs[4] // { // @028A stack[-1] // @0295 memory[0x00:0x40] // @0299 storage[0x01 + keccak256(memory[0x00:0x40])] // @029A stack[-2] // } 0287 5B JUMPDEST 0288 60 PUSH1 0x00 028A 90 SWAP1 028B 81 DUP2 028C 52 MSTORE 028D 60 PUSH1 0x04 028F 60 PUSH1 0x20 0291 52 MSTORE 0292 60 PUSH1 0x40 0294 90 SWAP1 0295 20 SHA3 0296 60 PUSH1 0x01 0298 01 ADD 0299 54 SLOAD 029A 90 SWAP1 029B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @028C memory[0x00:0x20] = stack[-1] // @0291 memory[0x20:0x40] = 0x04 // @029A stack[-2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_029C: // Incoming jump from 0x01B3, if 0x282c51f3 == stack[-1] 029C 5B JUMPDEST 029D 61 PUSH2 0x01fc 02A0 7F PUSH32 0x9667e80708b6eeeb0053fa0cca44e028ff548e2a9f029edfeac87c118b08b7c8 02C1 81 DUP2 02C2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @029D stack[0] = 0x01fc // @02A0 stack[1] = 0x9667e80708b6eeeb0053fa0cca44e028ff548e2a9f029edfeac87c118b08b7c8 // } // Block ends with unconditional jump to 0x01fc label_02C3: // Incoming jump from 0x01BE, if 0x2a55205a == stack[-1] // Inputs[1] { @02CA msg.data.length } 02C3 5B JUMPDEST 02C4 61 PUSH2 0x02d6 02C7 61 PUSH2 0x02d1 02CA 36 CALLDATASIZE 02CB 60 PUSH1 0x04 02CD 61 PUSH2 0x2428 02D0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02C4 stack[0] = 0x02d6 // @02C7 stack[1] = 0x02d1 // @02CA stack[2] = msg.data.length // @02CB stack[3] = 0x04 // } // Block ends with call to 0x2428, returns to 0x02D1 label_02D1: // Incoming return from call to 0x2428 at 0x02D0 02D1 5B JUMPDEST 02D2 61 PUSH2 0x06c4 02D5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06c4 02D6 5B JUMPDEST 02D7 60 PUSH1 0x40 02D9 80 DUP1 02DA 51 MLOAD 02DB 60 PUSH1 0x01 02DD 60 PUSH1 0x01 02DF 60 PUSH1 0xa0 02E1 1B SHL 02E2 03 SUB 02E3 90 SWAP1 02E4 93 SWAP4 02E5 16 AND 02E6 83 DUP4 02E7 52 MSTORE 02E8 60 PUSH1 0x20 02EA 83 DUP4 02EB 01 ADD 02EC 91 SWAP2 02ED 90 SWAP1 02EE 91 SWAP2 02EF 52 MSTORE 02F0 01 ADD 02F1 61 PUSH2 0x0206 02F4 56 *JUMP label_02F5: // Incoming jump from 0x0161, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @02FC msg.data.length } 02F5 5B JUMPDEST 02F6 61 PUSH2 0x0308 02F9 61 PUSH2 0x0303 02FC 36 CALLDATASIZE 02FD 60 PUSH1 0x04 02FF 61 PUSH2 0x2596 0302 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F6 stack[0] = 0x0308 // @02F9 stack[1] = 0x0303 // @02FC stack[2] = msg.data.length // @02FD stack[3] = 0x04 // } // Block ends with call to 0x2596, returns to 0x0303 label_0303: // Incoming return from call to 0x2596 at 0x0302 0303 5B JUMPDEST 0304 61 PUSH2 0x06fa 0307 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06fa label_0308: // Incoming return from call to 0x0443 at 0x0442 // Incoming return from call to 0x0476 at 0x0475 // Incoming return from call to 0x032B at 0x032A // Incoming return from call to 0x0393 at 0x0392 // Incoming return from call to 0x0A50 at 0x039F // Incoming return from call to 0x0489 at 0x0488 // Incoming return from call to 0x0318 at 0x0317 // Incoming return from call to 0x0380 at 0x037F // Incoming return from call to 0x0525 at 0x0524 0308 5B JUMPDEST 0309 00 *STOP // Stack delta = +0 // Outputs[1] { @0309 stop(); } // Block terminates label_030A: // Incoming jump from 0x016C, if 0x2f2ff15d == stack[-1] // Inputs[1] { @0311 msg.data.length } 030A 5B JUMPDEST 030B 61 PUSH2 0x0308 030E 61 PUSH2 0x0318 0311 36 CALLDATASIZE 0312 60 PUSH1 0x04 0314 61 PUSH2 0x2640 0317 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @030B stack[0] = 0x0308 // @030E stack[1] = 0x0318 // @0311 stack[2] = msg.data.length // @0312 stack[3] = 0x04 // } // Block ends with call to 0x2640, returns to 0x0318 label_0318: // Incoming return from call to 0x2640 at 0x0317 0318 5B JUMPDEST 0319 61 PUSH2 0x079c 031C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x079c label_031D: // Incoming jump from 0x0177, if 0x36568abe == stack[-1] // Inputs[1] { @0324 msg.data.length } 031D 5B JUMPDEST 031E 61 PUSH2 0x0308 0321 61 PUSH2 0x032b 0324 36 CALLDATASIZE 0325 60 PUSH1 0x04 0327 61 PUSH2 0x2640 032A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @031E stack[0] = 0x0308 // @0321 stack[1] = 0x032b // @0324 stack[2] = msg.data.length // @0325 stack[3] = 0x04 // } // Block ends with call to 0x2640, returns to 0x032B label_032B: // Incoming return from call to 0x2640 at 0x032A 032B 5B JUMPDEST 032C 61 PUSH2 0x07c7 032F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07c7 label_0330: // Incoming jump from 0x0182, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0337 msg.data.length } 0330 5B JUMPDEST 0331 61 PUSH2 0x0343 0334 61 PUSH2 0x033e 0337 36 CALLDATASIZE 0338 60 PUSH1 0x04 033A 61 PUSH2 0x26d0 033D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0331 stack[0] = 0x0343 // @0334 stack[1] = 0x033e // @0337 stack[2] = msg.data.length // @0338 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x26d0 033E 5B JUMPDEST 033F 61 PUSH2 0x0853 0342 56 *JUMP 0343 5B JUMPDEST 0344 60 PUSH1 0x40 0346 51 MLOAD 0347 61 PUSH2 0x0206 034A 91 SWAP2 034B 90 SWAP1 034C 61 PUSH2 0x276f 034F 56 *JUMP label_0350: // Incoming jump from 0x0130, if 0x4f558e79 == stack[-1] // Inputs[1] { @0357 msg.data.length } 0350 5B JUMPDEST 0351 61 PUSH2 0x0222 0354 61 PUSH2 0x035e 0357 36 CALLDATASIZE 0358 60 PUSH1 0x04 035A 61 PUSH2 0x23a4 035D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0351 stack[0] = 0x0222 // @0354 stack[1] = 0x035e // @0357 stack[2] = msg.data.length // @0358 stack[3] = 0x04 // } // Block ends with call to 0x23a4, returns to 0x035E label_035E: // Incoming return from call to 0x23A4 at 0x035D // Inputs[4] // { // @0361 stack[-1] // @036C memory[0x00:0x40] // @036D storage[keccak256(memory[0x00:0x40])] // @0370 stack[-2] // } 035E 5B JUMPDEST 035F 60 PUSH1 0x00 0361 90 SWAP1 0362 81 DUP2 0363 52 MSTORE 0364 60 PUSH1 0x03 0366 60 PUSH1 0x20 0368 52 MSTORE 0369 60 PUSH1 0x40 036B 90 SWAP1 036C 20 SHA3 036D 54 SLOAD 036E 15 ISZERO 036F 15 ISZERO 0370 90 SWAP1 0371 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0363 memory[0x00:0x20] = stack[-1] // @0368 memory[0x20:0x40] = 0x03 // @0370 stack[-2] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0372: // Incoming jump from 0x013B, if 0x55732e9b == stack[-1] // Inputs[1] { @0379 msg.data.length } 0372 5B JUMPDEST 0373 61 PUSH2 0x0308 0376 61 PUSH2 0x0380 0379 36 CALLDATASIZE 037A 60 PUSH1 0x04 037C 61 PUSH2 0x2782 037F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0373 stack[0] = 0x0308 // @0376 stack[1] = 0x0380 // @0379 stack[2] = msg.data.length // @037A stack[3] = 0x04 // } // Block ends with call to 0x2782, returns to 0x0380 label_0380: // Incoming return from call to 0x2782 at 0x037F 0380 5B JUMPDEST 0381 61 PUSH2 0x0991 0384 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0991 label_0385: // Incoming jump from 0x0146, if 0x6b20c454 == stack[-1] // Inputs[1] { @038C msg.data.length } 0385 5B JUMPDEST 0386 61 PUSH2 0x0308 0389 61 PUSH2 0x0393 038C 36 CALLDATASIZE 038D 60 PUSH1 0x04 038F 61 PUSH2 0x2813 0392 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0386 stack[0] = 0x0308 // @0389 stack[1] = 0x0393 // @038C stack[2] = msg.data.length // @038D stack[3] = 0x04 // } // Block ends with call to 0x2813, returns to 0x0393 label_0393: // Incoming return from call to 0x2813 at 0x0392 0393 5B JUMPDEST 0394 61 PUSH2 0x0a14 0397 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a14 label_0398: // Incoming jump from 0x0151, if 0x715018a6 == stack[-1] 0398 5B JUMPDEST 0399 61 PUSH2 0x0308 039C 61 PUSH2 0x0a50 039F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0399 stack[0] = 0x0308 } // Block ends with call to 0x0a50, returns to 0x0308 label_03A0: // Incoming jump from 0x00E9, if 0x731133e9 == stack[-1] // Inputs[1] { @03A7 msg.data.length } 03A0 5B JUMPDEST 03A1 61 PUSH2 0x0308 03A4 61 PUSH2 0x03ae 03A7 36 CALLDATASIZE 03A8 60 PUSH1 0x04 03AA 61 PUSH2 0x2887 03AD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03A1 stack[0] = 0x0308 // @03A4 stack[1] = 0x03ae // @03A7 stack[2] = msg.data.length // @03A8 stack[3] = 0x04 // } // Block ends with call to 0x2887, returns to 0x03AE label_03AE: // Incoming return from call to 0x2887 at 0x03AD 03AE 5B JUMPDEST 03AF 61 PUSH2 0x0ab6 03B2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ab6 label_03B3: // Incoming jump from 0x00F4, if 0x862440e2 == stack[-1] // Inputs[1] { @03BA msg.data.length } 03B3 5B JUMPDEST 03B4 61 PUSH2 0x0308 03B7 61 PUSH2 0x03c1 03BA 36 CALLDATASIZE 03BB 60 PUSH1 0x04 03BD 61 PUSH2 0x28e8 03C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B4 stack[0] = 0x0308 // @03B7 stack[1] = 0x03c1 // @03BA stack[2] = msg.data.length // @03BB stack[3] = 0x04 // } // Block ends with call to 0x28e8, returns to 0x03C1 label_03C1: // Incoming return from call to 0x28E8 at 0x03C0 03C1 5B JUMPDEST 03C2 61 PUSH2 0x0aed 03C5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0aed label_03C6: // Incoming jump from 0x00FF, if 0x88e3c8d6 == stack[-1] // Inputs[1] { @03CD msg.data.length } 03C6 5B JUMPDEST 03C7 61 PUSH2 0x0308 03CA 61 PUSH2 0x03d4 03CD 36 CALLDATASIZE 03CE 60 PUSH1 0x04 03D0 61 PUSH2 0x2925 03D3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C7 stack[0] = 0x0308 // @03CA stack[1] = 0x03d4 // @03CD stack[2] = msg.data.length // @03CE stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2925 03D4 5B JUMPDEST 03D5 61 PUSH2 0x0b37 03D8 56 *JUMP label_03D9: // Incoming jump from 0x010A, if 0x8da5cb5b == stack[-1] // Inputs[2] // { // @03DC storage[0x06] // @03DF memory[0x40:0x60] // } 03D9 5B JUMPDEST 03DA 60 PUSH1 0x06 03DC 54 SLOAD 03DD 60 PUSH1 0x40 03DF 51 MLOAD 03E0 60 PUSH1 0x01 03E2 60 PUSH1 0x01 03E4 60 PUSH1 0xa0 03E6 1B SHL 03E7 03 SUB 03E8 90 SWAP1 03E9 91 SWAP2 03EA 16 AND 03EB 81 DUP2 03EC 52 MSTORE 03ED 60 PUSH1 0x20 03EF 01 ADD 03F0 61 PUSH2 0x0206 03F3 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x06] & (0x01 << 0xa0) - 0x01 // @03EF stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0206 label_03F4: // Incoming jump from 0x00B8, if 0x91d14854 == stack[-1] // Inputs[1] { @03FB msg.data.length } 03F4 5B JUMPDEST 03F5 61 PUSH2 0x0222 03F8 61 PUSH2 0x0402 03FB 36 CALLDATASIZE 03FC 60 PUSH1 0x04 03FE 61 PUSH2 0x2640 0401 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03F5 stack[0] = 0x0222 // @03F8 stack[1] = 0x0402 // @03FB stack[2] = msg.data.length // @03FC stack[3] = 0x04 // } // Block ends with call to 0x2640, returns to 0x0402 label_0402: // Incoming return from call to 0x2640 at 0x0401 // Inputs[6] // { // @0405 stack[-2] // @0413 memory[0x00:0x40] // @041C stack[-1] // @0426 memory[0x00:0x40] // @0427 storage[keccak256(memory[0x00:0x40])] // @042B stack[-3] // } 0402 5B JUMPDEST 0403 60 PUSH1 0x00 0405 91 SWAP2 0406 82 DUP3 0407 52 MSTORE 0408 60 PUSH1 0x04 040A 60 PUSH1 0x20 040C 90 SWAP1 040D 81 DUP2 040E 52 MSTORE 040F 60 PUSH1 0x40 0411 80 DUP1 0412 84 DUP5 0413 20 SHA3 0414 60 PUSH1 0x01 0416 60 PUSH1 0x01 0418 60 PUSH1 0xa0 041A 1B SHL 041B 03 SUB 041C 93 SWAP4 041D 90 SWAP1 041E 93 SWAP4 041F 16 AND 0420 84 DUP5 0421 52 MSTORE 0422 91 SWAP2 0423 90 SWAP1 0424 52 MSTORE 0425 90 SWAP1 0426 20 SHA3 0427 54 SLOAD 0428 60 PUSH1 0xff 042A 16 AND 042B 90 SWAP1 042C 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0407 memory[0x00:0x20] = stack[-2] // @040E memory[0x20:0x40] = 0x04 // @0421 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0424 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @042B stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_042D: // Incoming jump from 0x00C3, if 0xa217fddf == stack[-1] 042D 5B JUMPDEST 042E 61 PUSH2 0x01fc 0431 60 PUSH1 0x00 0433 81 DUP2 0434 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @042E stack[0] = 0x01fc // @0431 stack[1] = 0x00 // } // Block ends with unconditional jump to 0x01fc label_0435: // Incoming jump from 0x00CE, if 0xa22cb465 == stack[-1] // Inputs[1] { @043C msg.data.length } 0435 5B JUMPDEST 0436 61 PUSH2 0x0308 0439 61 PUSH2 0x0443 043C 36 CALLDATASIZE 043D 60 PUSH1 0x04 043F 61 PUSH2 0x29ab 0442 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0436 stack[0] = 0x0308 // @0439 stack[1] = 0x0443 // @043C stack[2] = msg.data.length // @043D stack[3] = 0x04 // } // Block ends with call to 0x29ab, returns to 0x0443 label_0443: // Incoming return from call to 0x29AB at 0x0442 0443 5B JUMPDEST 0444 61 PUSH2 0x0c3d 0447 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c3d label_0448: // Incoming jump from 0x00D9, if 0xbd85b039 == stack[-1] // Inputs[1] { @044F msg.data.length } 0448 5B JUMPDEST 0449 61 PUSH2 0x01fc 044C 61 PUSH2 0x0456 044F 36 CALLDATASIZE 0450 60 PUSH1 0x04 0452 61 PUSH2 0x23a4 0455 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0449 stack[0] = 0x01fc // @044C stack[1] = 0x0456 // @044F stack[2] = msg.data.length // @0450 stack[3] = 0x04 // } // Block ends with call to 0x23a4, returns to 0x0456 label_0456: // Incoming return from call to 0x23A4 at 0x0455 // Inputs[4] // { // @0459 stack[-1] // @0464 memory[0x00:0x40] // @0465 storage[keccak256(memory[0x00:0x40])] // @0466 stack[-2] // } 0456 5B JUMPDEST 0457 60 PUSH1 0x00 0459 90 SWAP1 045A 81 DUP2 045B 52 MSTORE 045C 60 PUSH1 0x03 045E 60 PUSH1 0x20 0460 52 MSTORE 0461 60 PUSH1 0x40 0463 90 SWAP1 0464 20 SHA3 0465 54 SLOAD 0466 90 SWAP1 0467 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @045B memory[0x00:0x20] = stack[-1] // @0460 memory[0x20:0x40] = 0x03 // @0466 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0468: // Incoming jump from 0x007C, if 0xd547741f == stack[-1] // Inputs[1] { @046F msg.data.length } 0468 5B JUMPDEST 0469 61 PUSH2 0x0308 046C 61 PUSH2 0x0476 046F 36 CALLDATASIZE 0470 60 PUSH1 0x04 0472 61 PUSH2 0x2640 0475 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0469 stack[0] = 0x0308 // @046C stack[1] = 0x0476 // @046F stack[2] = msg.data.length // @0470 stack[3] = 0x04 // } // Block ends with call to 0x2640, returns to 0x0476 label_0476: // Incoming return from call to 0x2640 at 0x0475 0476 5B JUMPDEST 0477 61 PUSH2 0x0d28 047A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d28 label_047B: // Incoming jump from 0x0087, if 0xe2e784d5 == stack[-1] // Inputs[1] { @0482 msg.data.length } 047B 5B JUMPDEST 047C 61 PUSH2 0x0308 047F 61 PUSH2 0x0489 0482 36 CALLDATASIZE 0483 60 PUSH1 0x04 0485 61 PUSH2 0x2347 0488 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @047C stack[0] = 0x0308 // @047F stack[1] = 0x0489 // @0482 stack[2] = msg.data.length // @0483 stack[3] = 0x04 // } // Block ends with call to 0x2347, returns to 0x0489 label_0489: // Incoming return from call to 0x2347 at 0x0488 0489 5B JUMPDEST 048A 61 PUSH2 0x0d4e 048D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d4e label_048E: // Incoming jump from 0x0092, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0495 msg.data.length } 048E 5B JUMPDEST 048F 61 PUSH2 0x0222 0492 61 PUSH2 0x049c 0495 36 CALLDATASIZE 0496 60 PUSH1 0x04 0498 61 PUSH2 0x29e7 049B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @048F stack[0] = 0x0222 // @0492 stack[1] = 0x049c // @0495 stack[2] = msg.data.length // @0496 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x29e7 label_049C: // Incoming call from 0x0715, returns to 0x0716 // Inputs[6] // { // @04A5 stack[-2] // @04B8 memory[0x00:0x40] // @04B9 stack[-1] // @04C3 memory[0x00:0x40] // @04C4 storage[keccak256(memory[0x00:0x40])] // @04C8 stack[-3] // } 049C 5B JUMPDEST 049D 60 PUSH1 0x01 049F 60 PUSH1 0x01 04A1 60 PUSH1 0xa0 04A3 1B SHL 04A4 03 SUB 04A5 91 SWAP2 04A6 82 DUP3 04A7 16 AND 04A8 60 PUSH1 0x00 04AA 90 SWAP1 04AB 81 DUP2 04AC 52 MSTORE 04AD 60 PUSH1 0x01 04AF 60 PUSH1 0x20 04B1 90 SWAP1 04B2 81 DUP2 04B3 52 MSTORE 04B4 60 PUSH1 0x40 04B6 80 DUP1 04B7 83 DUP4 04B8 20 SHA3 04B9 93 SWAP4 04BA 90 SWAP1 04BB 94 SWAP5 04BC 16 AND 04BD 82 DUP3 04BE 52 MSTORE 04BF 91 SWAP2 04C0 90 SWAP1 04C1 91 SWAP2 04C2 52 MSTORE 04C3 20 SHA3 04C4 54 SLOAD 04C5 60 PUSH1 0xff 04C7 16 AND 04C8 90 SWAP1 04C9 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @04AC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @04B3 memory[0x20:0x40] = 0x01 // @04BE memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @04C2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @04C8 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_04CA: // Incoming jump from 0x009D, if 0xe9a9c850 == stack[-1] 04CA 5B JUMPDEST 04CB 61 PUSH2 0x01fc 04CE 7F PUSH32 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba 04EF 81 DUP2 04F0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @04CB stack[0] = 0x01fc // @04CE stack[1] = 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba // } // Block ends with unconditional jump to 0x01fc label_04F1: // Incoming jump from 0x004B, if 0xf242432a == stack[-1] // Inputs[1] { @04F8 msg.data.length } 04F1 5B JUMPDEST 04F2 61 PUSH2 0x0308 04F5 61 PUSH2 0x04ff 04F8 36 CALLDATASIZE 04F9 60 PUSH1 0x04 04FB 61 PUSH2 0x2a11 04FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04F2 stack[0] = 0x0308 // @04F5 stack[1] = 0x04ff // @04F8 stack[2] = msg.data.length // @04F9 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2a11 04FF 5B JUMPDEST 0500 61 PUSH2 0x0e11 0503 56 *JUMP label_0504: // Incoming jump from 0x0056, if 0xf2fde38b == stack[-1] // Inputs[1] { @050B msg.data.length } 0504 5B JUMPDEST 0505 61 PUSH2 0x0308 0508 61 PUSH2 0x0512 050B 36 CALLDATASIZE 050C 60 PUSH1 0x04 050E 61 PUSH2 0x2a76 0511 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0505 stack[0] = 0x0308 // @0508 stack[1] = 0x0512 // @050B stack[2] = msg.data.length // @050C stack[3] = 0x04 // } // Block ends with call to 0x2a76, returns to 0x0512 label_0512: // Incoming return from call to 0x2A76 at 0x0511 0512 5B JUMPDEST 0513 61 PUSH2 0x0eac 0516 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eac label_0517: // Incoming jump from 0x0061, if 0xf5298aca == stack[-1] // Inputs[1] { @051E msg.data.length } 0517 5B JUMPDEST 0518 61 PUSH2 0x0308 051B 61 PUSH2 0x0525 051E 36 CALLDATASIZE 051F 60 PUSH1 0x04 0521 61 PUSH2 0x2a91 0524 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0518 stack[0] = 0x0308 // @051B stack[1] = 0x0525 // @051E stack[2] = msg.data.length // @051F stack[3] = 0x04 // } // Block ends with call to 0x2a91, returns to 0x0525 label_0525: // Incoming return from call to 0x2A91 at 0x0524 0525 5B JUMPDEST 0526 61 PUSH2 0x0f8e 0529 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f8e label_052A: // Incoming jump from 0x006C, if 0xfaf21c7f == stack[-1] // Inputs[1] { @0531 msg.data.length } 052A 5B JUMPDEST 052B 61 PUSH2 0x0308 052E 61 PUSH2 0x0538 0531 36 CALLDATASIZE 0532 60 PUSH1 0x04 0534 61 PUSH2 0x2ac4 0537 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @052B stack[0] = 0x0308 // @052E stack[1] = 0x0538 // @0531 stack[2] = msg.data.length // @0532 stack[3] = 0x04 // } // Block ends with call to 0x2ac4, returns to 0x0538 label_0538: // Incoming return from call to 0x2AC4 at 0x0537 0538 5B JUMPDEST 0539 61 PUSH2 0x0fc4 053C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fc4 label_053D: // Incoming jump from 0x01FB // Inputs[1] { @0548 stack[-2] } 053D 5B JUMPDEST 053E 60 PUSH1 0x00 0540 60 PUSH1 0x01 0542 60 PUSH1 0x01 0544 60 PUSH1 0xa0 0546 1B SHL 0547 03 SUB 0548 83 DUP4 0549 16 AND 054A 61 PUSH2 0x05c0 054D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053E stack[0] = 0x00 } // Block ends with conditional jump to 0x05c0, if stack[-2] & (0x01 << 0xa0) - 0x01 label_054E: // Incoming jump from 0x054D, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0550 memory[0x40:0x60] } 054E 60 PUSH1 0x40 0550 51 MLOAD 0551 62 PUSH3 0x461bcd 0555 60 PUSH1 0xe5 0557 1B SHL 0558 81 DUP2 0559 52 MSTORE 055A 60 PUSH1 0x20 055C 60 PUSH1 0x04 055E 82 DUP3 055F 01 ADD 0560 52 MSTORE 0561 60 PUSH1 0x2b 0563 60 PUSH1 0x24 0565 82 DUP3 0566 01 ADD 0567 52 MSTORE 0568 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 0589 60 PUSH1 0x44 058B 82 DUP3 058C 01 ADD 058D 52 MSTORE 058E 7F PUSH32 0x65726f2061646472657373000000000000000000000000000000000000000000 05AF 60 PUSH1 0x64 05B1 82 DUP3 05B2 01 ADD 05B3 52 MSTORE 05B4 60 PUSH1 0x84 05B6 01 ADD // Stack delta = +1 // Outputs[6] // { // @0559 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0560 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0567 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @058D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @05B3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373000000000000000000000000000000000000000000 // @05B6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_05B7: // Incoming jump from 0x1BA3 // Incoming jump from 0x05B6 // Incoming jump from 0x0787 // Incoming jump from 0x0F05 // Incoming jump from 0x1112 // Incoming jump from 0x0844 // Incoming jump from 0x0F81 // Incoming jump from 0x207C // Incoming jump from 0x10AE // Incoming jump from 0x1DA0 // Incoming jump from 0x0CBB // Incoming jump from 0x1E7B // Incoming jump from 0x1D29 // Incoming jump from 0x218B // Incoming jump from 0x197A // Incoming jump from 0x18F4 // Incoming jump from 0x18F4 // Incoming jump from 0x20DE // Incoming jump from 0x11F7 // Incoming jump from 0x1C26 // Incoming jump from 0x0AA9 // Incoming jump from 0x0DD1 // Inputs[3] // { // @05BA memory[0x40:0x60] // @05BC stack[-1] // @05BF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 05B7 5B JUMPDEST 05B8 60 PUSH1 0x40 05BA 51 MLOAD 05BB 80 DUP1 05BC 91 SWAP2 05BD 03 SUB 05BE 90 SWAP1 05BF FD *REVERT // Stack delta = -1 // Outputs[1] { @05BF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_05C0: // Incoming jump from 0x054D, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @05C4 stack[-2] // @05D0 memory[0x00:0x40] // @05D9 stack[-3] // @05E2 memory[0x00:0x40] // @05E3 storage[keccak256(memory[0x00:0x40])] // @05E4 stack[-4] // } 05C0 5B JUMPDEST 05C1 50 POP 05C2 60 PUSH1 0x00 05C4 90 SWAP1 05C5 81 DUP2 05C6 52 MSTORE 05C7 60 PUSH1 0x20 05C9 81 DUP2 05CA 81 DUP2 05CB 52 MSTORE 05CC 60 PUSH1 0x40 05CE 80 DUP1 05CF 83 DUP4 05D0 20 SHA3 05D1 60 PUSH1 0x01 05D3 60 PUSH1 0x01 05D5 60 PUSH1 0xa0 05D7 1B SHL 05D8 03 SUB 05D9 94 SWAP5 05DA 90 SWAP1 05DB 94 SWAP5 05DC 16 AND 05DD 83 DUP4 05DE 52 MSTORE 05DF 92 SWAP3 05E0 90 SWAP1 05E1 52 MSTORE 05E2 20 SHA3 05E3 54 SLOAD 05E4 90 SWAP1 05E5 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @05C6 memory[0x00:0x20] = stack[-2] // @05CB memory[0x20:0x40] = 0x00 // @05DE memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @05E1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @05E4 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_05E6: // Incoming jump from 0x0221 // Inputs[1] { @05EC stack[-1] } 05E6 5B JUMPDEST 05E7 60 PUSH1 0x00 05E9 61 PUSH2 0x05f1 05EC 82 DUP3 05ED 61 PUSH2 0x0ff8 05F0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05E7 stack[0] = 0x00 // @05E9 stack[1] = 0x05f1 // @05EC stack[2] = stack[-1] // } // Block ends with call to 0x0ff8, returns to 0x05F1 label_05F1: // Incoming jump from 0x17A7, if 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x225F, if stack[-1] // Incoming jump from 0x225F, if 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1029 at 0x06C3 // Incoming jump from 0x1008, if stack[-1] // Incoming return from call to 0x21F7 at 0x17B0 // Incoming jump from 0x2291 // Incoming return from call to 0x0FF8 at 0x05F0 // Inputs[3] // { // @05F2 stack[-1] // @05F2 stack[-4] // @05F3 stack[-3] // } 05F1 5B JUMPDEST 05F2 92 SWAP3 05F3 91 SWAP2 05F4 50 POP 05F5 50 POP 05F6 56 *JUMP // Stack delta = -3 // Outputs[1] { @05F2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_05F7: // Incoming jump from 0x026B // Inputs[3] // { // @05FA stack[-1] // @0605 memory[0x00:0x40] // @0607 storage[keccak256(memory[0x00:0x40])] // } 05F7 5B JUMPDEST 05F8 60 PUSH1 0x00 05FA 81 DUP2 05FB 81 DUP2 05FC 52 MSTORE 05FD 60 PUSH1 0x07 05FF 60 PUSH1 0x20 0601 52 MSTORE 0602 60 PUSH1 0x40 0604 81 DUP2 0605 20 SHA3 0606 80 DUP1 0607 54 SLOAD 0608 60 PUSH1 0x60 060A 92 SWAP3 060B 91 SWAP2 060C 90 SWAP1 060D 61 PUSH2 0x0615 0610 90 SWAP1 0611 61 PUSH2 0x2b01 0614 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @05FC memory[0x00:0x20] = stack[-1] // @0601 memory[0x20:0x40] = 0x07 // @060A stack[0] = 0x60 // @060B stack[1] = 0x00 // @060C stack[2] = keccak256(memory[0x00:0x40]) // @0610 stack[3] = 0x0615 // @0610 stack[4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2b01, returns to 0x0615 label_0615: // Incoming return from call to 0x2B01 at 0x0614 // Inputs[3] // { // @0616 stack[-1] // @0616 stack[-2] // @0618 stack[-3] // } 0615 5B JUMPDEST 0616 90 SWAP1 0617 50 POP 0618 11 GT 0619 15 ISZERO 061A 61 PUSH2 0x06bb 061D 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x06bb, if !(stack[-1] > stack[-3]) label_061E: // Incoming jump from 0x061D, if not !(stack[-1] > stack[-3]) // Inputs[3] // { // @0620 stack[-2] // @062B memory[0x00:0x40] // @062D storage[keccak256(memory[0x00:0x40])] // } 061E 60 PUSH1 0x00 0620 82 DUP3 0621 81 DUP2 0622 52 MSTORE 0623 60 PUSH1 0x07 0625 60 PUSH1 0x20 0627 52 MSTORE 0628 60 PUSH1 0x40 062A 90 SWAP1 062B 20 SHA3 062C 80 DUP1 062D 54 SLOAD 062E 61 PUSH2 0x0636 0631 90 SWAP1 0632 61 PUSH2 0x2b01 0635 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0622 memory[0x00:0x20] = stack[-2] // @0627 memory[0x20:0x40] = 0x07 // @062B stack[0] = keccak256(memory[0x00:0x40]) // @0631 stack[1] = 0x0636 // @0631 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2b01, returns to 0x0636 label_0636: // Incoming return from call to 0x2B01 at 0x1037 // Incoming return from call to 0x2B01 at 0x0635 // Inputs[4] // { // @0637 stack[-1] // @0646 memory[0x40:0x60] // @064E stack[-2] // @0659 storage[stack[-2]] // } 0636 5B JUMPDEST 0637 80 DUP1 0638 60 PUSH1 0x1f 063A 01 ADD 063B 60 PUSH1 0x20 063D 80 DUP1 063E 91 SWAP2 063F 04 DIV 0640 02 MUL 0641 60 PUSH1 0x20 0643 01 ADD 0644 60 PUSH1 0x40 0646 51 MLOAD 0647 90 SWAP1 0648 81 DUP2 0649 01 ADD 064A 60 PUSH1 0x40 064C 52 MSTORE 064D 80 DUP1 064E 92 SWAP3 064F 91 SWAP2 0650 90 SWAP1 0651 81 DUP2 0652 81 DUP2 0653 52 MSTORE 0654 60 PUSH1 0x20 0656 01 ADD 0657 82 DUP3 0658 80 DUP1 0659 54 SLOAD 065A 61 PUSH2 0x0662 065D 90 SWAP1 065E 61 PUSH2 0x2b01 0661 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @064C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @064E stack[-2] = memory[0x40:0x60] // @064F stack[-1] = stack[-2] // @0650 stack[0] = stack[-1] // @0653 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0656 stack[1] = 0x20 + memory[0x40:0x60] // @0657 stack[2] = stack[-2] // @065D stack[4] = storage[stack[-2]] // @065D stack[3] = 0x0662 // } // Block ends with call to 0x2b01, returns to 0x0662 label_0662: // Incoming return from call to 0x2B01 at 0x0661 // Inputs[1] { @0663 stack[-1] } 0662 5B JUMPDEST 0663 80 DUP1 0664 15 ISZERO 0665 61 PUSH2 0x06af 0668 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06af, if !stack[-1] label_0669: // Incoming jump from 0x0668, if not !stack[-1] // Inputs[1] { @0669 stack[-1] } 0669 80 DUP1 066A 60 PUSH1 0x1f 066C 10 LT 066D 61 PUSH2 0x0684 0670 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0684, if 0x1f < stack[-1] label_0671: // Incoming jump from 0x0670, if not 0x1f < stack[-1] // Inputs[4] // { // @0675 stack[-2] // @0676 storage[stack[-2]] // @0679 stack[-3] // @067B stack[-1] // } 0671 61 PUSH2 0x0100 0674 80 DUP1 0675 83 DUP4 0676 54 SLOAD 0677 04 DIV 0678 02 MUL 0679 83 DUP4 067A 52 MSTORE 067B 91 SWAP2 067C 60 PUSH1 0x20 067E 01 ADD 067F 91 SWAP2 0680 61 PUSH2 0x06af 0683 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @067A memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @067F stack[-1] = stack[-1] // @067F stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06af label_0684: // Incoming jump from 0x0670, if 0x1f < stack[-1] // Inputs[5] // { // @0685 stack[-3] // @0686 stack[-1] // @0688 stack[-2] // @0690 memory[0x00:0x20] // @0694 storage[keccak256(memory[0x00:0x20])] // } 0684 5B JUMPDEST 0685 82 DUP3 0686 01 ADD 0687 91 SWAP2 0688 90 SWAP1 0689 60 PUSH1 0x00 068B 52 MSTORE 068C 60 PUSH1 0x20 068E 60 PUSH1 0x00 0690 20 SHA3 0691 90 SWAP1 0692 5B JUMPDEST 0693 81 DUP2 0694 54 SLOAD 0695 81 DUP2 0696 52 MSTORE 0697 90 SWAP1 0698 60 PUSH1 0x01 069A 01 ADD 069B 90 SWAP1 069C 60 PUSH1 0x20 069E 01 ADD 069F 80 DUP1 06A0 83 DUP4 06A1 11 GT 06A2 61 PUSH2 0x0692 06A5 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0687 stack[-3] = stack[-3] + stack[-1] // @068B memory[0x00:0x20] = stack[-2] // @0696 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @069B stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @069E stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0692, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06A6: // Incoming jump from 0x06A5, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x06A5, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @06A6 stack[-3] // @06A7 stack[-1] // } 06A6 82 DUP3 06A7 90 SWAP1 06A8 03 SUB 06A9 60 PUSH1 0x1f 06AB 16 AND 06AC 82 DUP3 06AD 01 ADD 06AE 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @06AE stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @06AE stack[-1] = stack[-3] // } // Block continues label_06AF: // Incoming jump from 0x06AE // Incoming jump from 0x0683 // Incoming jump from 0x0668, if !stack[-1] // Inputs[4] // { // @06B5 stack[-6] // @06B5 stack[-7] // @06B7 stack[-9] // @06B8 stack[-8] // } 06AF 5B JUMPDEST 06B0 50 POP 06B1 50 POP 06B2 50 POP 06B3 50 POP 06B4 50 POP 06B5 90 SWAP1 06B6 50 POP 06B7 91 SWAP2 06B8 90 SWAP1 06B9 50 POP 06BA 56 *JUMP // Stack delta = -8 // Outputs[1] { @06B7 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_06BB: // Incoming jump from 0x061D, if !(stack[-1] > stack[-3]) // Inputs[1] { @06BF stack[-2] } 06BB 5B JUMPDEST 06BC 61 PUSH2 0x05f1 06BF 82 DUP3 06C0 61 PUSH2 0x1029 06C3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06BC stack[0] = 0x05f1 // @06BF stack[1] = stack[-2] // } // Block ends with call to 0x1029, returns to 0x05F1 label_06C4: // Incoming jump from 0x02D5 // Inputs[3] // { // @06C7 storage[0x08] // @06CA storage[0x09] // @06E2 stack[-1] // } 06C4 5B JUMPDEST 06C5 60 PUSH1 0x08 06C7 54 SLOAD 06C8 60 PUSH1 0x09 06CA 54 SLOAD 06CB 60 PUSH1 0x01 06CD 60 PUSH1 0x01 06CF 60 PUSH1 0xa0 06D1 1B SHL 06D2 03 SUB 06D3 90 SWAP1 06D4 91 SWAP2 06D5 16 AND 06D6 90 SWAP1 06D7 60 PUSH1 0x00 06D9 90 SWAP1 06DA 61 PUSH2 0x2710 06DD 90 SWAP1 06DE 61 PUSH2 0x06e7 06E1 90 SWAP1 06E2 85 DUP6 06E3 61 PUSH2 0x2b52 06E6 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @06D6 stack[0] = storage[0x08] & (0x01 << 0xa0) - 0x01 // @06D9 stack[1] = 0x00 // @06DD stack[2] = 0x2710 // @06E1 stack[3] = 0x06e7 // @06E1 stack[4] = storage[0x09] // @06E2 stack[5] = stack[-1] // } // Block ends with call to 0x2b52, returns to 0x06E7 label_06E7: // Incoming return from call to 0x2B52 at 0x06E6 // Inputs[2] // { // @06EB stack[-2] // @06EC stack[-1] // } 06E7 5B JUMPDEST 06E8 61 PUSH2 0x06f1 06EB 91 SWAP2 06EC 90 SWAP1 06ED 61 PUSH2 0x2b71 06F0 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @06EB stack[-2] = 0x06f1 // @06EC stack[-1] = stack[-2] // @06EC stack[0] = stack[-1] // } // Block ends with call to 0x2b71, returns to 0x06F1 label_06F1: // Incoming return from call to 0x232B at 0x2A10 // Incoming return from call to 0x232B at 0x2662 // Incoming return from call to 0x2B71 at 0x06F0 // Inputs[6] // { // @06F2 stack[-2] // @06F2 stack[-1] // @06F4 stack[-5] // @06F6 stack[-3] // @06F6 stack[-6] // @06F7 stack[-4] // } 06F1 5B JUMPDEST 06F2 90 SWAP1 06F3 50 POP 06F4 92 SWAP3 06F5 50 POP 06F6 92 SWAP3 06F7 90 SWAP1 06F8 50 POP 06F9 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @06F4 stack[-5] = stack[-1] // @06F6 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_06FA: // Incoming jump from 0x0307 // Inputs[2] // { // @0703 stack[-5] // @0705 msg.sender // } 06FA 5B JUMPDEST 06FB 60 PUSH1 0x01 06FD 60 PUSH1 0x01 06FF 60 PUSH1 0xa0 0701 1B SHL 0702 03 SUB 0703 85 DUP6 0704 16 AND 0705 33 CALLER 0706 14 EQ 0707 80 DUP1 0708 61 PUSH2 0x0716 070B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0706 stack[0] = msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x0716, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 label_070C: // Incoming jump from 0x070B, if not msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0710 stack[-6] // @0711 msg.sender // } 070C 50 POP 070D 61 PUSH2 0x0716 0710 85 DUP6 0711 33 CALLER 0712 61 PUSH2 0x049c 0715 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @070D stack[-1] = 0x0716 // @0710 stack[0] = stack[-6] // @0711 stack[1] = msg.sender // } // Block ends with call to 0x049c, returns to 0x0716 label_0716: // Incoming return from call to 0x049C at 0x0715 // Incoming jump from 0x070B, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @071A stack[-1] } 0716 5B JUMPDEST 0717 61 PUSH2 0x0788 071A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0788, if stack[-1] label_071B: // Incoming jump from 0x071A, if not stack[-1] // Inputs[1] { @071D memory[0x40:0x60] } 071B 60 PUSH1 0x40 071D 51 MLOAD 071E 62 PUSH3 0x461bcd 0722 60 PUSH1 0xe5 0724 1B SHL 0725 81 DUP2 0726 52 MSTORE 0727 60 PUSH1 0x20 0729 60 PUSH1 0x04 072B 82 DUP3 072C 01 ADD 072D 52 MSTORE 072E 60 PUSH1 0x32 0730 60 PUSH1 0x24 0732 82 DUP3 0733 01 ADD 0734 52 MSTORE 0735 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 0756 60 PUSH1 0x44 0758 82 DUP3 0759 01 ADD 075A 52 MSTORE 075B 7F PUSH32 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 077C 60 PUSH1 0x64 077E 82 DUP3 077F 01 ADD 0780 52 MSTORE 0781 60 PUSH1 0x84 0783 01 ADD 0784 61 PUSH2 0x05b7 0787 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0726 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @072D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0734 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x32 // @075A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 // @0780 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 // @0783 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_0788: // Incoming jump from 0x071A, if stack[-1] // Inputs[5] // { // @078C stack[-5] // @078D stack[-4] // @078E stack[-3] // @078F stack[-2] // @0790 stack[-1] // } 0788 5B JUMPDEST 0789 61 PUSH2 0x0795 078C 85 DUP6 078D 85 DUP6 078E 85 DUP6 078F 85 DUP6 0790 85 DUP6 0791 61 PUSH2 0x1038 0794 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0789 stack[0] = 0x0795 // @078C stack[1] = stack[-5] // @078D stack[2] = stack[-4] // @078E stack[3] = stack[-3] // @078F stack[4] = stack[-2] // @0790 stack[5] = stack[-1] // } // Block ends with unconditional jump to 0x1038 label_0795: // Incoming return from call to 0x1F5D at 0x1CC7 // Incoming return from call to 0x1F12 at 0x15F8 // Inputs[1] { @079B stack[-6] } 0795 5B JUMPDEST 0796 50 POP 0797 50 POP 0798 50 POP 0799 50 POP 079A 50 POP 079B 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_079C: // Incoming jump from 0x031C // Inputs[4] // { // @079F stack[-2] // @07AA memory[0x00:0x40] // @07AE storage[0x01 + keccak256(memory[0x00:0x40])] // @07B3 msg.sender // } 079C 5B JUMPDEST 079D 60 PUSH1 0x00 079F 82 DUP3 07A0 81 DUP2 07A1 52 MSTORE 07A2 60 PUSH1 0x04 07A4 60 PUSH1 0x20 07A6 52 MSTORE 07A7 60 PUSH1 0x40 07A9 90 SWAP1 07AA 20 SHA3 07AB 60 PUSH1 0x01 07AD 01 ADD 07AE 54 SLOAD 07AF 61 PUSH2 0x07b8 07B2 81 DUP2 07B3 33 CALLER 07B4 61 PUSH2 0x12b6 07B7 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @07A1 memory[0x00:0x20] = stack[-2] // @07A6 memory[0x20:0x40] = 0x04 // @07AE stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @07AF stack[1] = 0x07b8 // @07B2 stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // @07B3 stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x07B8 label_07B8: // Incoming return from call to 0x12B6 at 0x07B7 // Inputs[2] // { // @07BC stack[-3] // @07BD stack[-2] // } 07B8 5B JUMPDEST 07B9 61 PUSH2 0x07c2 07BC 83 DUP4 07BD 83 DUP4 07BE 61 PUSH2 0x1336 07C1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07B9 stack[0] = 0x07c2 // @07BC stack[1] = stack[-3] // @07BD stack[2] = stack[-2] // } // Block ends with call to 0x1336, returns to 0x07C2 label_07C2: // Incoming return from call to 0x13D8 at 0x0D4D // Incoming return from call to 0x1336 at 0x07C1 // Inputs[1] { @07C6 stack[-4] } 07C2 5B JUMPDEST 07C3 50 POP 07C4 50 POP 07C5 50 POP 07C6 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_07C7: // Incoming jump from 0x032F // Inputs[2] // { // @07D0 stack[-1] // @07D2 msg.sender // } 07C7 5B JUMPDEST 07C8 60 PUSH1 0x01 07CA 60 PUSH1 0x01 07CC 60 PUSH1 0xa0 07CE 1B SHL 07CF 03 SUB 07D0 81 DUP2 07D1 16 AND 07D2 33 CALLER 07D3 14 EQ 07D4 61 PUSH2 0x0845 07D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0845, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 label_07D8: // Incoming jump from 0x07D7, if not msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @07DA memory[0x40:0x60] } 07D8 60 PUSH1 0x40 07DA 51 MLOAD 07DB 62 PUSH3 0x461bcd 07DF 60 PUSH1 0xe5 07E1 1B SHL 07E2 81 DUP2 07E3 52 MSTORE 07E4 60 PUSH1 0x20 07E6 60 PUSH1 0x04 07E8 82 DUP3 07E9 01 ADD 07EA 52 MSTORE 07EB 60 PUSH1 0x2f 07ED 60 PUSH1 0x24 07EF 82 DUP3 07F0 01 ADD 07F1 52 MSTORE 07F2 7F PUSH32 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 0813 60 PUSH1 0x44 0815 82 DUP3 0816 01 ADD 0817 52 MSTORE 0818 7F PUSH32 0x20726f6c657320666f722073656c660000000000000000000000000000000000 0839 60 PUSH1 0x64 083B 82 DUP3 083C 01 ADD 083D 52 MSTORE 083E 60 PUSH1 0x84 0840 01 ADD 0841 61 PUSH2 0x05b7 0844 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @07E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07EA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07F1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @0817 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 // @083D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x20726f6c657320666f722073656c660000000000000000000000000000000000 // @0840 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_0845: // Incoming jump from 0x07D7, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0849 stack[-2] // @084A stack[-1] // } 0845 5B JUMPDEST 0846 61 PUSH2 0x084f 0849 82 DUP3 084A 82 DUP3 084B 61 PUSH2 0x13d8 084E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0846 stack[0] = 0x084f // @0849 stack[1] = stack[-2] // @084A stack[2] = stack[-1] // } // Block ends with call to 0x13d8, returns to 0x084F label_084F: // Incoming jump from 0x12E0, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1360, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1403, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming return from call to 0x13D8 at 0x084E // Inputs[1] { @0852 stack[-3] } 084F 5B JUMPDEST 0850 50 POP 0851 50 POP 0852 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] 0853 5B JUMPDEST 0854 60 PUSH1 0x60 0856 81 DUP2 0857 51 MLOAD 0858 83 DUP4 0859 51 MLOAD 085A 14 EQ 085B 61 PUSH2 0x08cc 085E 57 *JUMPI 085F 60 PUSH1 0x40 0861 51 MLOAD 0862 62 PUSH3 0x461bcd 0866 60 PUSH1 0xe5 0868 1B SHL 0869 81 DUP2 086A 52 MSTORE 086B 60 PUSH1 0x20 086D 60 PUSH1 0x04 086F 82 DUP3 0870 01 ADD 0871 52 MSTORE 0872 60 PUSH1 0x29 0874 60 PUSH1 0x24 0876 82 DUP3 0877 01 ADD 0878 52 MSTORE 0879 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 089A 60 PUSH1 0x44 089C 82 DUP3 089D 01 ADD 089E 52 MSTORE 089F 7F PUSH32 0x206d69736d617463680000000000000000000000000000000000000000000000 08C0 60 PUSH1 0x64 08C2 82 DUP3 08C3 01 ADD 08C4 52 MSTORE 08C5 60 PUSH1 0x84 08C7 01 ADD 08C8 61 PUSH2 0x05b7 08CB 56 *JUMP 08CC 5B JUMPDEST 08CD 60 PUSH1 0x00 08CF 83 DUP4 08D0 51 MLOAD 08D1 67 PUSH8 0xffffffffffffffff 08DA 81 DUP2 08DB 11 GT 08DC 15 ISZERO 08DD 61 PUSH2 0x08e8 08E0 57 *JUMPI 08E1 61 PUSH2 0x08e8 08E4 61 PUSH2 0x244a 08E7 56 *JUMP 08E8 5B JUMPDEST 08E9 60 PUSH1 0x40 08EB 51 MLOAD 08EC 90 SWAP1 08ED 80 DUP1 08EE 82 DUP3 08EF 52 MSTORE 08F0 80 DUP1 08F1 60 PUSH1 0x20 08F3 02 MUL 08F4 60 PUSH1 0x20 08F6 01 ADD 08F7 82 DUP3 08F8 01 ADD 08F9 60 PUSH1 0x40 08FB 52 MSTORE 08FC 80 DUP1 08FD 15 ISZERO 08FE 61 PUSH2 0x0911 0901 57 *JUMPI 0902 81 DUP2 0903 60 PUSH1 0x20 0905 01 ADD 0906 60 PUSH1 0x20 0908 82 DUP3 0909 02 MUL 090A 80 DUP1 090B 36 CALLDATASIZE 090C 83 DUP4 090D 37 CALLDATACOPY 090E 01 ADD 090F 90 SWAP1 0910 50 POP 0911 5B JUMPDEST 0912 50 POP 0913 90 SWAP1 0914 50 POP 0915 60 PUSH1 0x00 0917 5B JUMPDEST 0918 84 DUP5 0919 51 MLOAD 091A 81 DUP2 091B 10 LT 091C 15 ISZERO 091D 61 PUSH2 0x0989 0920 57 *JUMPI 0921 61 PUSH2 0x095c 0924 85 DUP6 0925 82 DUP3 0926 81 DUP2 0927 51 MLOAD 0928 81 DUP2 0929 10 LT 092A 61 PUSH2 0x0935 092D 57 *JUMPI 092E 61 PUSH2 0x0935 0931 61 PUSH2 0x2b93 0934 56 *JUMP 0935 5B JUMPDEST 0936 60 PUSH1 0x20 0938 02 MUL 0939 60 PUSH1 0x20 093B 01 ADD 093C 01 ADD 093D 51 MLOAD 093E 85 DUP6 093F 83 DUP4 0940 81 DUP2 0941 51 MLOAD 0942 81 DUP2 0943 10 LT 0944 61 PUSH2 0x094f 0947 57 *JUMPI 0948 61 PUSH2 0x094f 094B 61 PUSH2 0x2b93 094E 56 *JUMP 094F 5B JUMPDEST 0950 60 PUSH1 0x20 0952 02 MUL 0953 60 PUSH1 0x20 0955 01 ADD 0956 01 ADD 0957 51 MLOAD 0958 61 PUSH2 0x053d 095B 56 *JUMP 095C 5B JUMPDEST 095D 82 DUP3 095E 82 DUP3 095F 81 DUP2 0960 51 MLOAD 0961 81 DUP2 0962 10 LT 0963 61 PUSH2 0x096e 0966 57 *JUMPI 0967 61 PUSH2 0x096e 096A 61 PUSH2 0x2b93 096D 56 *JUMP 096E 5B JUMPDEST 096F 60 PUSH1 0x20 0971 90 SWAP1 0972 81 DUP2 0973 02 MUL 0974 91 SWAP2 0975 90 SWAP1 0976 91 SWAP2 0977 01 ADD 0978 01 ADD 0979 52 MSTORE 097A 61 PUSH2 0x0982 097D 81 DUP2 097E 61 PUSH2 0x2ba9 0981 56 *JUMP 0982 5B JUMPDEST 0983 90 SWAP1 0984 50 POP 0985 61 PUSH2 0x0917 0988 56 *JUMP 0989 5B JUMPDEST 098A 50 POP 098B 93 SWAP4 098C 92 SWAP3 098D 50 POP 098E 50 POP 098F 50 POP 0990 56 *JUMP label_0991: // Incoming jump from 0x0384 // Inputs[1] { @09B7 msg.sender } 0991 5B JUMPDEST 0992 7F PUSH32 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba 09B3 61 PUSH2 0x09bc 09B6 81 DUP2 09B7 33 CALLER 09B8 61 PUSH2 0x12b6 09BB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0992 stack[0] = 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba // @09B3 stack[1] = 0x09bc // @09B6 stack[2] = 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba // @09B7 stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x09BC label_09BC: // Incoming return from call to 0x12B6 at 0x09BB // Inputs[1] { @09C0 stack[-5] } 09BC 5B JUMPDEST 09BD 60 PUSH1 0x00 09BF 5B JUMPDEST 09C0 85 DUP6 09C1 81 DUP2 09C2 10 LT 09C3 15 ISZERO 09C4 61 PUSH2 0x0a0b 09C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09BD stack[0] = 0x00 } // Block ends with conditional jump to 0x0a0b, if !(0x00 < stack[-5]) label_09C8: // Incoming jump from 0x09C7, if not !(0x00 < stack[-5]) // Inputs[3] // { // @09CB stack[-7] // @09CC stack[-6] // @09CD stack[-1] // } 09C8 61 PUSH2 0x09f9 09CB 87 DUP8 09CC 87 DUP8 09CD 83 DUP4 09CE 81 DUP2 09CF 81 DUP2 09D0 10 LT 09D1 61 PUSH2 0x09dc 09D4 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @09C8 stack[0] = 0x09f9 // @09CB stack[1] = stack[-7] // @09CC stack[2] = stack[-6] // @09CD stack[3] = stack[-1] // } // Block ends with conditional jump to 0x09dc, if stack[-1] < stack[-6] label_09D5: // Incoming jump from 0x09D4, if not stack[-1] < stack[-6] 09D5 61 PUSH2 0x09dc 09D8 61 PUSH2 0x2b93 09DB 56 *JUMP // Stack delta = +1 // Outputs[1] { @09D5 stack[0] = 0x09dc } // Block ends with unconditional jump to 0x2b93 label_09DC: // Incoming jump from 0x09D4, if stack[-1] < stack[-6] // Inputs[3] // { // @09DD stack[-1] // @09DD stack[-2] // @09E2 stack[-3] // } 09DC 5B JUMPDEST 09DD 90 SWAP1 09DE 50 POP 09DF 60 PUSH1 0x20 09E1 02 MUL 09E2 01 ADD 09E3 60 PUSH1 0x20 09E5 81 DUP2 09E6 01 ADD 09E7 90 SWAP1 09E8 61 PUSH2 0x09f1 09EB 91 SWAP2 09EC 90 SWAP1 09ED 61 PUSH2 0x2a76 09F0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09EB stack[-3] = 0x09f1 // @09EC stack[-1] = 0x20 * stack[-1] + stack[-3] // @09EC stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x2a76, returns to 0x09F1 label_09F1: // Incoming return from call to 0x2A76 at 0x09F0 // Inputs[3] // { // @09F2 stack[-7] // @09F3 stack[-6] // @09F4 stack[-5] // } 09F1 5B JUMPDEST 09F2 86 DUP7 09F3 86 DUP7 09F4 86 DUP7 09F5 61 PUSH2 0x145b 09F8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09F2 stack[0] = stack[-7] // @09F3 stack[1] = stack[-6] // @09F4 stack[2] = stack[-5] // } // Block ends with unconditional jump to 0x145b 09F9 5B JUMPDEST 09FA 80 DUP1 09FB 61 PUSH2 0x0a03 09FE 81 DUP2 09FF 61 PUSH2 0x2ba9 0A02 56 *JUMP 0A03 5B JUMPDEST 0A04 91 SWAP2 0A05 50 POP 0A06 50 POP 0A07 61 PUSH2 0x09bf 0A0A 56 *JUMP label_0A0B: // Incoming jump from 0x190D, if 0xbc197c81 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x200F, if 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x09C7, if !(0x00 < stack[-5]) // Inputs[1] { @0A13 stack[-8] } 0A0B 5B JUMPDEST 0A0C 50 POP 0A0D 50 POP 0A0E 50 POP 0A0F 50 POP 0A10 50 POP 0A11 50 POP 0A12 50 POP 0A13 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_0A14: // Incoming jump from 0x0397 // Inputs[1] { @0A3A msg.sender } 0A14 5B JUMPDEST 0A15 7F PUSH32 0x9667e80708b6eeeb0053fa0cca44e028ff548e2a9f029edfeac87c118b08b7c8 0A36 61 PUSH2 0x0a3f 0A39 81 DUP2 0A3A 33 CALLER 0A3B 61 PUSH2 0x12b6 0A3E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A15 stack[0] = 0x9667e80708b6eeeb0053fa0cca44e028ff548e2a9f029edfeac87c118b08b7c8 // @0A36 stack[1] = 0x0a3f // @0A39 stack[2] = 0x9667e80708b6eeeb0053fa0cca44e028ff548e2a9f029edfeac87c118b08b7c8 // @0A3A stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x0A3F label_0A3F: // Incoming return from call to 0x12B6 at 0x0A3E // Inputs[3] // { // @0A43 stack[-4] // @0A44 stack[-3] // @0A45 stack[-2] // } 0A3F 5B JUMPDEST 0A40 61 PUSH2 0x0a4a 0A43 84 DUP5 0A44 84 DUP5 0A45 84 DUP5 0A46 61 PUSH2 0x1490 0A49 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A40 stack[0] = 0x0a4a // @0A43 stack[1] = stack[-4] // @0A44 stack[2] = stack[-3] // @0A45 stack[3] = stack[-2] // } // Block ends with call to 0x1490, returns to 0x0A4A label_0A4A: // Incoming return from call to 0x172D at 0x0FC3 // Incoming jump from 0x14A7, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x23E0, if !(stack[-1] > stack[-4]) // Incoming jump from 0x14A7, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming return from call to 0x1490 at 0x0A49 // Inputs[1] { @0A4F stack[-5] } 0A4A 5B JUMPDEST 0A4B 50 POP 0A4C 50 POP 0A4D 50 POP 0A4E 50 POP 0A4F 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0A50: // Incoming call from 0x039F, returns to 0x0308 // Inputs[2] // { // @0A53 storage[0x06] // @0A5D msg.sender // } 0A50 5B JUMPDEST 0A51 60 PUSH1 0x06 0A53 54 SLOAD 0A54 60 PUSH1 0x01 0A56 60 PUSH1 0x01 0A58 60 PUSH1 0xa0 0A5A 1B SHL 0A5B 03 SUB 0A5C 16 AND 0A5D 33 CALLER 0A5E 14 EQ 0A5F 61 PUSH2 0x0aaa 0A62 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aaa, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0A63: // Incoming jump from 0x0A62, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0A65 memory[0x40:0x60] } 0A63 60 PUSH1 0x40 0A65 51 MLOAD 0A66 62 PUSH3 0x461bcd 0A6A 60 PUSH1 0xe5 0A6C 1B SHL 0A6D 81 DUP2 0A6E 52 MSTORE 0A6F 60 PUSH1 0x20 0A71 60 PUSH1 0x04 0A73 82 DUP3 0A74 01 ADD 0A75 81 DUP2 0A76 90 SWAP1 0A77 52 MSTORE 0A78 60 PUSH1 0x24 0A7A 82 DUP3 0A7B 01 ADD 0A7C 52 MSTORE 0A7D 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0A9E 60 PUSH1 0x44 0AA0 82 DUP3 0AA1 01 ADD 0AA2 52 MSTORE 0AA3 60 PUSH1 0x64 0AA5 01 ADD 0AA6 61 PUSH2 0x05b7 0AA9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A6E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A77 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A7C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0AA2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0AA5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_0AAA: // Incoming jump from 0x0A62, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] 0AAA 5B JUMPDEST 0AAB 61 PUSH2 0x0ab4 0AAE 60 PUSH1 0x00 0AB0 61 PUSH2 0x1512 0AB3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AAB stack[0] = 0x0ab4 // @0AAE stack[1] = 0x00 // } // Block ends with call to 0x1512, returns to 0x0AB4 label_0AB4: // Incoming return from call to 0x1512 at 0x0AB3 // Inputs[1] { @0AB5 stack[-1] } 0AB4 5B JUMPDEST 0AB5 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0AB6: // Incoming jump from 0x03B2 // Inputs[1] { @0ADC msg.sender } 0AB6 5B JUMPDEST 0AB7 7F PUSH32 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba 0AD8 61 PUSH2 0x0ae1 0ADB 81 DUP2 0ADC 33 CALLER 0ADD 61 PUSH2 0x12b6 0AE0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AB7 stack[0] = 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba // @0AD8 stack[1] = 0x0ae1 // @0ADB stack[2] = 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba // @0ADC stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x0AE1 label_0AE1: // Incoming return from call to 0x12B6 at 0x0AE0 // Inputs[4] // { // @0AE5 stack[-5] // @0AE6 stack[-4] // @0AE7 stack[-3] // @0AE8 stack[-2] // } 0AE1 5B JUMPDEST 0AE2 61 PUSH2 0x0795 0AE5 85 DUP6 0AE6 85 DUP6 0AE7 85 DUP6 0AE8 85 DUP6 0AE9 61 PUSH2 0x145b 0AEC 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0AE2 stack[0] = 0x0795 // @0AE5 stack[1] = stack[-5] // @0AE6 stack[2] = stack[-4] // @0AE7 stack[3] = stack[-3] // @0AE8 stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x145b label_0AED: // Incoming jump from 0x03C5 // Inputs[1] { @0B13 msg.sender } 0AED 5B JUMPDEST 0AEE 7F PUSH32 0x4a78764b0e84f45a602e24e86f19a3e2af7956f2a9112d825c8b5ca7991c711f 0B0F 61 PUSH2 0x0b18 0B12 81 DUP2 0B13 33 CALLER 0B14 61 PUSH2 0x12b6 0B17 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AEE stack[0] = 0x4a78764b0e84f45a602e24e86f19a3e2af7956f2a9112d825c8b5ca7991c711f // @0B0F stack[1] = 0x0b18 // @0B12 stack[2] = 0x4a78764b0e84f45a602e24e86f19a3e2af7956f2a9112d825c8b5ca7991c711f // @0B13 stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x0B18 label_0B18: // Incoming return from call to 0x12B6 at 0x0B17 // Inputs[4] // { // @0B1B stack[-3] // @0B29 memory[0x00:0x40] // @0B2A stack[-2] // @0B2B memory[stack[-2]:stack[-2] + 0x20] // } 0B18 5B JUMPDEST 0B19 60 PUSH1 0x00 0B1B 83 DUP4 0B1C 81 DUP2 0B1D 52 MSTORE 0B1E 60 PUSH1 0x07 0B20 60 PUSH1 0x20 0B22 90 SWAP1 0B23 81 DUP2 0B24 52 MSTORE 0B25 60 PUSH1 0x40 0B27 90 SWAP1 0B28 91 SWAP2 0B29 20 SHA3 0B2A 83 DUP4 0B2B 51 MLOAD 0B2C 61 PUSH2 0x0a4a 0B2F 92 SWAP3 0B30 85 DUP6 0B31 01 ADD 0B32 90 SWAP1 0B33 61 PUSH2 0x2292 0B36 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0B1D memory[0x00:0x20] = stack[-3] // @0B24 memory[0x20:0x40] = 0x07 // @0B29 stack[1] = keccak256(memory[0x00:0x40]) // @0B2F stack[0] = 0x0a4a // @0B32 stack[2] = stack[-2] + 0x20 // @0B32 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2292 0B37 5B JUMPDEST 0B38 7F PUSH32 0xfdf81848136595c31bb5f76217767372bc4bf906663038eb38381131ea27ecba 0B59 61 PUSH2 0x0b62 0B5C 81 DUP2 0B5D 33 CALLER 0B5E 61 PUSH2 0x12b6 0B61 56 *JUMP 0B62 5B JUMPDEST 0B63 83 DUP4 0B64 51 MLOAD 0B65 85 DUP6 0B66 51 MLOAD 0B67 14 EQ 0B68 61 PUSH2 0x0bd9 0B6B 57 *JUMPI 0B6C 60 PUSH1 0x40 0B6E 51 MLOAD 0B6F 62 PUSH3 0x461bcd 0B73 60 PUSH1 0xe5 0B75 1B SHL 0B76 81 DUP2 0B77 52 MSTORE 0B78 60 PUSH1 0x20 0B7A 60 PUSH1 0x04 0B7C 82 DUP3 0B7D 01 ADD 0B7E 52 MSTORE 0B7F 60 PUSH1 0x26 0B81 60 PUSH1 0x24 0B83 82 DUP3 0B84 01 ADD 0B85 52 MSTORE 0B86 7F PUSH32 0x61646472657373206c69737420616e64206964206c697374206d757374206265 0BA7 60 PUSH1 0x44 0BA9 82 DUP3 0BAA 01 ADD 0BAB 52 MSTORE 0BAC 7F PUSH32 0x20657175616c0000000000000000000000000000000000000000000000000000 0BCD 60 PUSH1 0x64 0BCF 82 DUP3 0BD0 01 ADD 0BD1 52 MSTORE 0BD2 60 PUSH1 0x84 0BD4 01 ADD 0BD5 61 PUSH2 0x05b7 0BD8 56 *JUMP 0BD9 5B JUMPDEST 0BDA 60 PUSH1 0x00 0BDC 5B JUMPDEST 0BDD 85 DUP6 0BDE 51 MLOAD 0BDF 81 DUP2 0BE0 11 GT 0BE1 15 ISZERO 0BE2 61 PUSH2 0x0c35 0BE5 57 *JUMPI 0BE6 61 PUSH2 0x0c23 0BE9 86 DUP7 0BEA 82 DUP3 0BEB 81 DUP2 0BEC 51 MLOAD 0BED 81 DUP2 0BEE 10 LT 0BEF 61 PUSH2 0x0bfa 0BF2 57 *JUMPI 0BF3 61 PUSH2 0x0bfa 0BF6 61 PUSH2 0x2b93 0BF9 56 *JUMP 0BFA 5B JUMPDEST 0BFB 60 PUSH1 0x20 0BFD 02 MUL 0BFE 60 PUSH1 0x20 0C00 01 ADD 0C01 01 ADD 0C02 51 MLOAD 0C03 86 DUP7 0C04 83 DUP4 0C05 81 DUP2 0C06 51 MLOAD 0C07 81 DUP2 0C08 10 LT 0C09 61 PUSH2 0x0c14 0C0C 57 *JUMPI 0C0D 61 PUSH2 0x0c14 0C10 61 PUSH2 0x2b93 0C13 56 *JUMP 0C14 5B JUMPDEST 0C15 60 PUSH1 0x20 0C17 02 MUL 0C18 60 PUSH1 0x20 0C1A 01 ADD 0C1B 01 ADD 0C1C 51 MLOAD 0C1D 86 DUP7 0C1E 86 DUP7 0C1F 61 PUSH2 0x145b 0C22 56 *JUMP 0C23 5B JUMPDEST 0C24 80 DUP1 0C25 61 PUSH2 0x0c2d 0C28 81 DUP2 0C29 61 PUSH2 0x2ba9 0C2C 56 *JUMP 0C2D 5B JUMPDEST 0C2E 91 SWAP2 0C2F 50 POP 0C30 50 POP 0C31 61 PUSH2 0x0bdc 0C34 56 *JUMP label_0C35: // Incoming jump from 0x1F6D, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Incoming return from call to 0x17B1 at 0x12B5 // Incoming jump from 0x17C1, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0C3C stack[-7] } 0C35 5B JUMPDEST 0C36 50 POP 0C37 50 POP 0C38 50 POP 0C39 50 POP 0C3A 50 POP 0C3B 50 POP 0C3C 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0C3D: // Incoming jump from 0x0447 // Inputs[2] // { // @0C3E msg.sender // @0C47 stack[-2] // } 0C3D 5B JUMPDEST 0C3E 33 CALLER 0C3F 60 PUSH1 0x01 0C41 60 PUSH1 0x01 0C43 60 PUSH1 0xa0 0C45 1B SHL 0C46 03 SUB 0C47 83 DUP4 0C48 16 AND 0C49 14 EQ 0C4A 15 ISZERO 0C4B 61 PUSH2 0x0cbc 0C4E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cbc, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) label_0C4F: // Incoming jump from 0x0C4E, if not !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[1] { @0C51 memory[0x40:0x60] } 0C4F 60 PUSH1 0x40 0C51 51 MLOAD 0C52 62 PUSH3 0x461bcd 0C56 60 PUSH1 0xe5 0C58 1B SHL 0C59 81 DUP2 0C5A 52 MSTORE 0C5B 60 PUSH1 0x20 0C5D 60 PUSH1 0x04 0C5F 82 DUP3 0C60 01 ADD 0C61 52 MSTORE 0C62 60 PUSH1 0x29 0C64 60 PUSH1 0x24 0C66 82 DUP3 0C67 01 ADD 0C68 52 MSTORE 0C69 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 0C8A 60 PUSH1 0x44 0C8C 82 DUP3 0C8D 01 ADD 0C8E 52 MSTORE 0C8F 7F PUSH32 0x20666f722073656c660000000000000000000000000000000000000000000000 0CB0 60 PUSH1 0x64 0CB2 82 DUP3 0CB3 01 ADD 0CB4 52 MSTORE 0CB5 60 PUSH1 0x84 0CB7 01 ADD 0CB8 61 PUSH2 0x05b7 0CBB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C5A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C61 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C68 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0C8E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @0CB4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x20666f722073656c660000000000000000000000000000000000000000000000 // @0CB7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_0CBC: // Incoming jump from 0x0C4E, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[10] // { // @0CBD msg.sender // @0CCE memory[0x00:0x40] // @0CD7 stack[-2] // @0CE2 memory[0x00:0x40] // @0CE4 storage[keccak256(memory[0x00:0x40])] // @0CE9 stack[-1] // @0CF3 memory[0x40:0x60] // @0D1F memory[0x40:0x60] // @0D24 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0D27 stack[-3] // } 0CBC 5B JUMPDEST 0CBD 33 CALLER 0CBE 60 PUSH1 0x00 0CC0 81 DUP2 0CC1 81 DUP2 0CC2 52 MSTORE 0CC3 60 PUSH1 0x01 0CC5 60 PUSH1 0x20 0CC7 90 SWAP1 0CC8 81 DUP2 0CC9 52 MSTORE 0CCA 60 PUSH1 0x40 0CCC 80 DUP1 0CCD 83 DUP4 0CCE 20 SHA3 0CCF 60 PUSH1 0x01 0CD1 60 PUSH1 0x01 0CD3 60 PUSH1 0xa0 0CD5 1B SHL 0CD6 03 SUB 0CD7 87 DUP8 0CD8 16 AND 0CD9 80 DUP1 0CDA 85 DUP6 0CDB 52 MSTORE 0CDC 90 SWAP1 0CDD 83 DUP4 0CDE 52 MSTORE 0CDF 92 SWAP3 0CE0 81 DUP2 0CE1 90 SWAP1 0CE2 20 SHA3 0CE3 80 DUP1 0CE4 54 SLOAD 0CE5 60 PUSH1 0xff 0CE7 19 NOT 0CE8 16 AND 0CE9 86 DUP7 0CEA 15 ISZERO 0CEB 15 ISZERO 0CEC 90 SWAP1 0CED 81 DUP2 0CEE 17 OR 0CEF 90 SWAP1 0CF0 91 SWAP2 0CF1 55 SSTORE 0CF2 90 SWAP1 0CF3 51 MLOAD 0CF4 90 SWAP1 0CF5 81 DUP2 0CF6 52 MSTORE 0CF7 91 SWAP2 0CF8 92 SWAP3 0CF9 91 SWAP2 0CFA 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0D1B 91 SWAP2 0D1C 01 ADD 0D1D 60 PUSH1 0x40 0D1F 51 MLOAD 0D20 80 DUP1 0D21 91 SWAP2 0D22 03 SUB 0D23 90 SWAP1 0D24 A3 LOG3 0D25 50 POP 0D26 50 POP 0D27 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0CC2 memory[0x00:0x20] = msg.sender // @0CC9 memory[0x20:0x40] = 0x01 // @0CDB memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0CDE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0CF1 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0CF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0D24 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_0D28: // Incoming jump from 0x047A // Inputs[4] // { // @0D2B stack[-2] // @0D36 memory[0x00:0x40] // @0D3A storage[0x01 + keccak256(memory[0x00:0x40])] // @0D3F msg.sender // } 0D28 5B JUMPDEST 0D29 60 PUSH1 0x00 0D2B 82 DUP3 0D2C 81 DUP2 0D2D 52 MSTORE 0D2E 60 PUSH1 0x04 0D30 60 PUSH1 0x20 0D32 52 MSTORE 0D33 60 PUSH1 0x40 0D35 90 SWAP1 0D36 20 SHA3 0D37 60 PUSH1 0x01 0D39 01 ADD 0D3A 54 SLOAD 0D3B 61 PUSH2 0x0d44 0D3E 81 DUP2 0D3F 33 CALLER 0D40 61 PUSH2 0x12b6 0D43 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0D2D memory[0x00:0x20] = stack[-2] // @0D32 memory[0x20:0x40] = 0x04 // @0D3A stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @0D3B stack[1] = 0x0d44 // @0D3E stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // @0D3F stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x0D44 label_0D44: // Incoming return from call to 0x12B6 at 0x0D43 // Inputs[2] // { // @0D48 stack[-3] // @0D49 stack[-2] // } 0D44 5B JUMPDEST 0D45 61 PUSH2 0x07c2 0D48 83 DUP4 0D49 83 DUP4 0D4A 61 PUSH2 0x13d8 0D4D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D45 stack[0] = 0x07c2 // @0D48 stack[1] = stack[-3] // @0D49 stack[2] = stack[-2] // } // Block ends with call to 0x13d8, returns to 0x07C2 label_0D4E: // Incoming jump from 0x048D // Inputs[1] { @0D55 msg.sender } 0D4E 5B JUMPDEST 0D4F 60 PUSH1 0x00 0D51 61 PUSH2 0x0d5a 0D54 81 DUP2 0D55 33 CALLER 0D56 61 PUSH2 0x12b6 0D59 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D4F stack[0] = 0x00 // @0D51 stack[1] = 0x0d5a // @0D54 stack[2] = 0x00 // @0D55 stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x0D5A label_0D5A: // Incoming return from call to 0x12B6 at 0x0D59 // Inputs[1] { @0D5E stack[-2] } 0D5A 5B JUMPDEST 0D5B 61 PUSH2 0x2710 0D5E 82 DUP3 0D5F 11 GT 0D60 15 ISZERO 0D61 61 PUSH2 0x0dd2 0D64 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dd2, if !(stack[-2] > 0x2710) label_0D65: // Incoming jump from 0x0D64, if not !(stack[-2] > 0x2710) // Inputs[1] { @0D67 memory[0x40:0x60] } 0D65 60 PUSH1 0x40 0D67 51 MLOAD 0D68 62 PUSH3 0x461bcd 0D6C 60 PUSH1 0xe5 0D6E 1B SHL 0D6F 81 DUP2 0D70 52 MSTORE 0D71 60 PUSH1 0x20 0D73 60 PUSH1 0x04 0D75 82 DUP3 0D76 01 ADD 0D77 52 MSTORE 0D78 60 PUSH1 0x22 0D7A 60 PUSH1 0x24 0D7C 82 DUP3 0D7D 01 ADD 0D7E 52 MSTORE 0D7F 7F PUSH32 0x726f79616c747950657263656e74616765206d757374206265206c7420313030 0DA0 60 PUSH1 0x44 0DA2 82 DUP3 0DA3 01 ADD 0DA4 52 MSTORE 0DA5 7F PUSH32 0x3030000000000000000000000000000000000000000000000000000000000000 0DC6 60 PUSH1 0x64 0DC8 82 DUP3 0DC9 01 ADD 0DCA 52 MSTORE 0DCB 60 PUSH1 0x84 0DCD 01 ADD 0DCE 61 PUSH2 0x05b7 0DD1 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0D70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D77 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D7E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @0DA4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x726f79616c747950657263656e74616765206d757374206265206c7420313030 // @0DCA memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3030000000000000000000000000000000000000000000000000000000000000 // @0DCD stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_0DD2: // Incoming jump from 0x0D64, if !(stack[-2] > 0x2710) // Inputs[4] // { // @0DD7 storage[0x08] // @0E02 stack[-3] // @0E0A stack[-2] // @0E10 stack[-4] // } 0DD2 5B JUMPDEST 0DD3 50 POP 0DD4 60 PUSH1 0x08 0DD6 80 DUP1 0DD7 54 SLOAD 0DD8 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 0DF9 16 AND 0DFA 60 PUSH1 0x01 0DFC 60 PUSH1 0x01 0DFE 60 PUSH1 0xa0 0E00 1B SHL 0E01 03 SUB 0E02 93 SWAP4 0E03 90 SWAP1 0E04 93 SWAP4 0E05 16 AND 0E06 92 SWAP3 0E07 90 SWAP1 0E08 92 SWAP3 0E09 17 OR 0E0A 90 SWAP1 0E0B 91 SWAP2 0E0C 55 SSTORE 0E0D 60 PUSH1 0x09 0E0F 55 SSTORE 0E10 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0E0C storage[0x08] = ((0x01 << 0xa0) - 0x01 & stack[-3]) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & storage[0x08]) // @0E0F storage[0x09] = stack[-2] // } // Block ends with unconditional jump to stack[-4] 0E11 5B JUMPDEST 0E12 60 PUSH1 0x01 0E14 60 PUSH1 0x01 0E16 60 PUSH1 0xa0 0E18 1B SHL 0E19 03 SUB 0E1A 85 DUP6 0E1B 16 AND 0E1C 33 CALLER 0E1D 14 EQ 0E1E 80 DUP1 0E1F 61 PUSH2 0x0e2d 0E22 57 *JUMPI 0E23 50 POP 0E24 61 PUSH2 0x0e2d 0E27 85 DUP6 0E28 33 CALLER 0E29 61 PUSH2 0x049c 0E2C 56 *JUMP 0E2D 5B JUMPDEST 0E2E 61 PUSH2 0x0e9f 0E31 57 *JUMPI 0E32 60 PUSH1 0x40 0E34 51 MLOAD 0E35 62 PUSH3 0x461bcd 0E39 60 PUSH1 0xe5 0E3B 1B SHL 0E3C 81 DUP2 0E3D 52 MSTORE 0E3E 60 PUSH1 0x20 0E40 60 PUSH1 0x04 0E42 82 DUP3 0E43 01 ADD 0E44 52 MSTORE 0E45 60 PUSH1 0x29 0E47 60 PUSH1 0x24 0E49 82 DUP3 0E4A 01 ADD 0E4B 52 MSTORE 0E4C 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 0E6D 60 PUSH1 0x44 0E6F 82 DUP3 0E70 01 ADD 0E71 52 MSTORE 0E72 7F PUSH32 0x20617070726f7665640000000000000000000000000000000000000000000000 0E93 60 PUSH1 0x64 0E95 82 DUP3 0E96 01 ADD 0E97 52 MSTORE 0E98 60 PUSH1 0x84 0E9A 01 ADD 0E9B 61 PUSH2 0x05b7 0E9E 56 *JUMP 0E9F 5B JUMPDEST 0EA0 61 PUSH2 0x0795 0EA3 85 DUP6 0EA4 85 DUP6 0EA5 85 DUP6 0EA6 85 DUP6 0EA7 85 DUP6 0EA8 61 PUSH2 0x157c 0EAB 56 *JUMP label_0EAC: // Incoming jump from 0x0516 // Inputs[2] // { // @0EAF storage[0x06] // @0EB9 msg.sender // } 0EAC 5B JUMPDEST 0EAD 60 PUSH1 0x06 0EAF 54 SLOAD 0EB0 60 PUSH1 0x01 0EB2 60 PUSH1 0x01 0EB4 60 PUSH1 0xa0 0EB6 1B SHL 0EB7 03 SUB 0EB8 16 AND 0EB9 33 CALLER 0EBA 14 EQ 0EBB 61 PUSH2 0x0f06 0EBE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f06, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0EBF: // Incoming jump from 0x0EBE, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0EC1 memory[0x40:0x60] } 0EBF 60 PUSH1 0x40 0EC1 51 MLOAD 0EC2 62 PUSH3 0x461bcd 0EC6 60 PUSH1 0xe5 0EC8 1B SHL 0EC9 81 DUP2 0ECA 52 MSTORE 0ECB 60 PUSH1 0x20 0ECD 60 PUSH1 0x04 0ECF 82 DUP3 0ED0 01 ADD 0ED1 81 DUP2 0ED2 90 SWAP1 0ED3 52 MSTORE 0ED4 60 PUSH1 0x24 0ED6 82 DUP3 0ED7 01 ADD 0ED8 52 MSTORE 0ED9 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0EFA 60 PUSH1 0x44 0EFC 82 DUP3 0EFD 01 ADD 0EFE 52 MSTORE 0EFF 60 PUSH1 0x64 0F01 01 ADD 0F02 61 PUSH2 0x05b7 0F05 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0ECA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0ED3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0ED8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0EFE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0F01 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_0F06: // Incoming jump from 0x0EBE, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0F0F stack[-1] } 0F06 5B JUMPDEST 0F07 60 PUSH1 0x01 0F09 60 PUSH1 0x01 0F0B 60 PUSH1 0xa0 0F0D 1B SHL 0F0E 03 SUB 0F0F 81 DUP2 0F10 16 AND 0F11 61 PUSH2 0x0f82 0F14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f82, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0F15: // Incoming jump from 0x0F14, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0F17 memory[0x40:0x60] } 0F15 60 PUSH1 0x40 0F17 51 MLOAD 0F18 62 PUSH3 0x461bcd 0F1C 60 PUSH1 0xe5 0F1E 1B SHL 0F1F 81 DUP2 0F20 52 MSTORE 0F21 60 PUSH1 0x20 0F23 60 PUSH1 0x04 0F25 82 DUP3 0F26 01 ADD 0F27 52 MSTORE 0F28 60 PUSH1 0x26 0F2A 60 PUSH1 0x24 0F2C 82 DUP3 0F2D 01 ADD 0F2E 52 MSTORE 0F2F 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0F50 60 PUSH1 0x44 0F52 82 DUP3 0F53 01 ADD 0F54 52 MSTORE 0F55 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 0F76 60 PUSH1 0x64 0F78 82 DUP3 0F79 01 ADD 0F7A 52 MSTORE 0F7B 60 PUSH1 0x84 0F7D 01 ADD 0F7E 61 PUSH2 0x05b7 0F81 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0F20 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F27 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F2E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0F54 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0F7A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @0F7D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_0F82: // Incoming jump from 0x0F14, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0F86 stack[-1] } 0F82 5B JUMPDEST 0F83 61 PUSH2 0x0f8b 0F86 81 DUP2 0F87 61 PUSH2 0x1512 0F8A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F83 stack[0] = 0x0f8b // @0F86 stack[1] = stack[-1] // } // Block ends with call to 0x1512, returns to 0x0F8B label_0F8B: // Incoming jump from 0x2382, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1512 at 0x0F8A // Inputs[1] { @0F8D stack[-2] } 0F8B 5B JUMPDEST 0F8C 50 POP 0F8D 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0F8E: // Incoming jump from 0x0529 // Inputs[1] { @0FB4 msg.sender } 0F8E 5B JUMPDEST 0F8F 7F PUSH32 0x9667e80708b6eeeb0053fa0cca44e028ff548e2a9f029edfeac87c118b08b7c8 0FB0 61 PUSH2 0x0fb9 0FB3 81 DUP2 0FB4 33 CALLER 0FB5 61 PUSH2 0x12b6 0FB8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F8F stack[0] = 0x9667e80708b6eeeb0053fa0cca44e028ff548e2a9f029edfeac87c118b08b7c8 // @0FB0 stack[1] = 0x0fb9 // @0FB3 stack[2] = 0x9667e80708b6eeeb0053fa0cca44e028ff548e2a9f029edfeac87c118b08b7c8 // @0FB4 stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x0FB9 label_0FB9: // Incoming return from call to 0x12B6 at 0x0FB8 // Inputs[3] // { // @0FBD stack[-4] // @0FBE stack[-3] // @0FBF stack[-2] // } 0FB9 5B JUMPDEST 0FBA 61 PUSH2 0x0a4a 0FBD 84 DUP5 0FBE 84 DUP5 0FBF 84 DUP5 0FC0 61 PUSH2 0x172d 0FC3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FBA stack[0] = 0x0a4a // @0FBD stack[1] = stack[-4] // @0FBE stack[2] = stack[-3] // @0FBF stack[3] = stack[-2] // } // Block ends with call to 0x172d, returns to 0x0A4A label_0FC4: // Incoming jump from 0x053C // Inputs[1] { @0FEA msg.sender } 0FC4 5B JUMPDEST 0FC5 7F PUSH32 0x4a78764b0e84f45a602e24e86f19a3e2af7956f2a9112d825c8b5ca7991c711f 0FE6 61 PUSH2 0x0fef 0FE9 81 DUP2 0FEA 33 CALLER 0FEB 61 PUSH2 0x12b6 0FEE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FC5 stack[0] = 0x4a78764b0e84f45a602e24e86f19a3e2af7956f2a9112d825c8b5ca7991c711f // @0FE6 stack[1] = 0x0fef // @0FE9 stack[2] = 0x4a78764b0e84f45a602e24e86f19a3e2af7956f2a9112d825c8b5ca7991c711f // @0FEA stack[3] = msg.sender // } // Block ends with call to 0x12b6, returns to 0x0FEF label_0FEF: // Incoming return from call to 0x12B6 at 0x0FEE // Inputs[1] { @0FF3 stack[-2] } 0FEF 5B JUMPDEST 0FF0 61 PUSH2 0x084f 0FF3 82 DUP3 0FF4 61 PUSH2 0x1760 0FF7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FF0 stack[0] = 0x084f // @0FF3 stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x1760 label_0FF8: // Incoming call from 0x05F0, returns to 0x05F1 // Inputs[1] { @0FFE stack[-1] } 0FF8 5B JUMPDEST 0FF9 60 PUSH1 0x00 0FFB 61 PUSH2 0x1003 0FFE 82 DUP3 0FFF 61 PUSH2 0x1773 1002 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FF9 stack[0] = 0x00 // @0FFB stack[1] = 0x1003 // @0FFE stack[2] = stack[-1] // } // Block ends with call to 0x1773, returns to 0x1003 label_1003: // Incoming return from call to 0x1773 at 0x1002 // Inputs[1] { @1004 stack[-1] } 1003 5B JUMPDEST 1004 80 DUP1 1005 61 PUSH2 0x05f1 1008 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f1, if stack[-1] label_1009: // Incoming jump from 0x1008, if not stack[-1] // Inputs[4] // { // @1014 stack[-3] // @1022 memory[0x00:0x40] // @1023 storage[keccak256(memory[0x00:0x40])] // @1027 stack[-4] // } 1009 50 POP 100A 50 POP 100B 60 PUSH1 0x01 100D 60 PUSH1 0x01 100F 60 PUSH1 0xe0 1011 1B SHL 1012 03 SUB 1013 19 NOT 1014 16 AND 1015 60 PUSH1 0x00 1017 90 SWAP1 1018 81 DUP2 1019 52 MSTORE 101A 60 PUSH1 0x05 101C 60 PUSH1 0x20 101E 52 MSTORE 101F 60 PUSH1 0x40 1021 90 SWAP1 1022 20 SHA3 1023 54 SLOAD 1024 60 PUSH1 0xff 1026 16 AND 1027 90 SWAP1 1028 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1019 memory[0x00:0x20] = ~((0x01 << 0xe0) - 0x01) & stack[-3] // @101E memory[0x20:0x40] = 0x05 // @1027 stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_1029: // Incoming call from 0x06C3, returns to 0x05F1 // Inputs[1] { @102F storage[0x02] } 1029 5B JUMPDEST 102A 60 PUSH1 0x60 102C 60 PUSH1 0x02 102E 80 DUP1 102F 54 SLOAD 1030 61 PUSH2 0x0636 1033 90 SWAP1 1034 61 PUSH2 0x2b01 1037 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @102A stack[0] = 0x60 // @102C stack[1] = 0x02 // @1033 stack[2] = 0x0636 // @1033 stack[3] = storage[0x02] // } // Block ends with call to 0x2b01, returns to 0x0636 label_1038: // Incoming jump from 0x0794 // Inputs[4] // { // @1039 stack[-2] // @103A memory[stack[-2]:stack[-2] + 0x20] // @103B stack[-3] // @103C memory[stack[-3]:stack[-3] + 0x20] // } 1038 5B JUMPDEST 1039 81 DUP2 103A 51 MLOAD 103B 83 DUP4 103C 51 MLOAD 103D 14 EQ 103E 61 PUSH2 0x10af 1041 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10af, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] label_1042: // Incoming jump from 0x1041, if not memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @1044 memory[0x40:0x60] } 1042 60 PUSH1 0x40 1044 51 MLOAD 1045 62 PUSH3 0x461bcd 1049 60 PUSH1 0xe5 104B 1B SHL 104C 81 DUP2 104D 52 MSTORE 104E 60 PUSH1 0x20 1050 60 PUSH1 0x04 1052 82 DUP3 1053 01 ADD 1054 52 MSTORE 1055 60 PUSH1 0x28 1057 60 PUSH1 0x24 1059 82 DUP3 105A 01 ADD 105B 52 MSTORE 105C 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 107D 60 PUSH1 0x44 107F 82 DUP3 1080 01 ADD 1081 52 MSTORE 1082 7F PUSH32 0x6d69736d61746368000000000000000000000000000000000000000000000000 10A3 60 PUSH1 0x64 10A5 82 DUP3 10A6 01 ADD 10A7 52 MSTORE 10A8 60 PUSH1 0x84 10AA 01 ADD 10AB 61 PUSH2 0x05b7 10AE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @104D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1054 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @105B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @1081 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 // @10A7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6d69736d61746368000000000000000000000000000000000000000000000000 // @10AA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_10AF: // Incoming jump from 0x1041, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @10B8 stack[-4] } 10AF 5B JUMPDEST 10B0 60 PUSH1 0x01 10B2 60 PUSH1 0x01 10B4 60 PUSH1 0xa0 10B6 1B SHL 10B7 03 SUB 10B8 84 DUP5 10B9 16 AND 10BA 61 PUSH2 0x1113 10BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1113, if stack[-4] & (0x01 << 0xa0) - 0x01 label_10BE: // Incoming jump from 0x10BD, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @10C0 memory[0x40:0x60] } 10BE 60 PUSH1 0x40 10C0 51 MLOAD 10C1 62 PUSH3 0x461bcd 10C5 60 PUSH1 0xe5 10C7 1B SHL 10C8 81 DUP2 10C9 52 MSTORE 10CA 60 PUSH1 0x20 10CC 60 PUSH1 0x04 10CE 82 DUP3 10CF 01 ADD 10D0 52 MSTORE 10D1 60 PUSH1 0x25 10D3 60 PUSH1 0x24 10D5 82 DUP3 10D6 01 ADD 10D7 52 MSTORE 10D8 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 10F9 60 PUSH1 0x44 10FB 82 DUP3 10FC 01 ADD 10FD 52 MSTORE 10FE 64 PUSH5 0x6472657373 1104 60 PUSH1 0xd8 1106 1B SHL 1107 60 PUSH1 0x64 1109 82 DUP3 110A 01 ADD 110B 52 MSTORE 110C 60 PUSH1 0x84 110E 01 ADD 110F 61 PUSH2 0x05b7 1112 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @10C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10D0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10D7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @10FD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 // @110B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6472657373 << 0xd8 // @110E stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_1113: // Incoming jump from 0x10BD, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1114 msg.sender // @1118 stack[-3] // @1119 memory[stack[-3]:stack[-3] + 0x20] // } 1113 5B JUMPDEST 1114 33 CALLER 1115 60 PUSH1 0x00 1117 5B JUMPDEST 1118 84 DUP5 1119 51 MLOAD 111A 81 DUP2 111B 10 LT 111C 15 ISZERO 111D 61 PUSH2 0x1250 1120 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1114 stack[0] = msg.sender // @1115 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1250, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_1121: // Incoming jump from 0x1120, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x1120, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @1123 stack[-5] // @1124 stack[-1] // @1126 memory[stack[-5]:stack[-5] + 0x20] // } 1121 60 PUSH1 0x00 1123 85 DUP6 1124 82 DUP3 1125 81 DUP2 1126 51 MLOAD 1127 81 DUP2 1128 10 LT 1129 61 PUSH2 0x1134 112C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1121 stack[0] = 0x00 // @1123 stack[1] = stack[-5] // @1124 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1134, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_112D: // Incoming jump from 0x112C, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 112D 61 PUSH2 0x1134 1130 61 PUSH2 0x2b93 1133 56 *JUMP // Stack delta = +1 // Outputs[1] { @112D stack[0] = 0x1134 } // Block ends with unconditional jump to 0x2b93 label_1134: // Incoming jump from 0x112C, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[7] // { // @1137 stack[-1] // @113B stack[-2] // @113C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @113D stack[-3] // @1141 stack[-7] // @1142 stack[-4] // @1144 memory[stack[-7]:stack[-7] + 0x20] // } 1134 5B JUMPDEST 1135 60 PUSH1 0x20 1137 02 MUL 1138 60 PUSH1 0x20 113A 01 ADD 113B 01 ADD 113C 51 MLOAD 113D 90 SWAP1 113E 50 POP 113F 60 PUSH1 0x00 1141 85 DUP6 1142 83 DUP4 1143 81 DUP2 1144 51 MLOAD 1145 81 DUP2 1146 10 LT 1147 61 PUSH2 0x1152 114A 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @113D stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @113F stack[-2] = 0x00 // @1141 stack[-1] = stack[-7] // @1142 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x1152, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_114B: // Incoming jump from 0x114A, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] 114B 61 PUSH2 0x1152 114E 61 PUSH2 0x2b93 1151 56 *JUMP // Stack delta = +1 // Outputs[1] { @114B stack[0] = 0x1152 } // Block ends with unconditional jump to 0x2b93 label_1152: // Incoming jump from 0x114A, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[9] // { // @1155 stack[-1] // @1158 stack[-2] // @115E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1161 stack[-4] // @116B memory[0x00:0x40] // @1174 stack[-11] // @117E memory[0x00:0x40] // @117F storage[keccak256(memory[0x00:0x40])] // @1181 stack[-3] // } 1152 5B JUMPDEST 1153 60 PUSH1 0x20 1155 90 SWAP1 1156 81 DUP2 1157 02 MUL 1158 91 SWAP2 1159 90 SWAP1 115A 91 SWAP2 115B 01 ADD 115C 81 DUP2 115D 01 ADD 115E 51 MLOAD 115F 60 PUSH1 0x00 1161 84 DUP5 1162 81 DUP2 1163 52 MSTORE 1164 80 DUP1 1165 83 DUP4 1166 52 MSTORE 1167 60 PUSH1 0x40 1169 80 DUP1 116A 82 DUP3 116B 20 SHA3 116C 60 PUSH1 0x01 116E 60 PUSH1 0x01 1170 60 PUSH1 0xa0 1172 1B SHL 1173 03 SUB 1174 8E DUP15 1175 16 AND 1176 83 DUP4 1177 52 MSTORE 1178 90 SWAP1 1179 93 SWAP4 117A 52 MSTORE 117B 91 SWAP2 117C 90 SWAP1 117D 91 SWAP2 117E 20 SHA3 117F 54 SLOAD 1180 90 SWAP1 1181 91 SWAP2 1182 50 POP 1183 81 DUP2 1184 81 DUP2 1185 10 LT 1186 15 ISZERO 1187 61 PUSH2 0x11f8 118A 57 *JUMPI // Stack delta = -1 // Outputs[6] // { // @1163 memory[0x00:0x20] = stack[-4] // @1166 memory[0x20:0x40] = 0x00 // @1177 memory[0x00:0x20] = stack[-11] & (0x01 << 0xa0) - 0x01 // @117A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1180 stack[-2] = storage[keccak256(memory[0x00:0x40])] // @1181 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x11f8, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) label_118B: // Incoming jump from 0x118A, if not !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[1] { @118D memory[0x40:0x60] } 118B 60 PUSH1 0x40 118D 51 MLOAD 118E 62 PUSH3 0x461bcd 1192 60 PUSH1 0xe5 1194 1B SHL 1195 81 DUP2 1196 52 MSTORE 1197 60 PUSH1 0x20 1199 60 PUSH1 0x04 119B 82 DUP3 119C 01 ADD 119D 52 MSTORE 119E 60 PUSH1 0x2a 11A0 60 PUSH1 0x24 11A2 82 DUP3 11A3 01 ADD 11A4 52 MSTORE 11A5 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 11C6 60 PUSH1 0x44 11C8 82 DUP3 11C9 01 ADD 11CA 52 MSTORE 11CB 7F PUSH32 0x72207472616e7366657200000000000000000000000000000000000000000000 11EC 60 PUSH1 0x64 11EE 82 DUP3 11EF 01 ADD 11F0 52 MSTORE 11F1 60 PUSH1 0x84 11F3 01 ADD 11F4 61 PUSH2 0x05b7 11F7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1196 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @119D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11A4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @11CA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a20696e73756666696369656e742062616c616e636520666f // @11F0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72207472616e7366657200000000000000000000000000000000000000000000 // @11F3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_11F8: // Incoming jump from 0x118A, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[9] // { // @11FB stack[-3] // @1207 memory[0x00:0x40] // @1210 stack[-10] // @1219 memory[0x00:0x40] // @121A stack[-2] // @121B stack[-1] // @1220 stack[-9] // @1225 memory[0x00:0x40] // @1227 storage[keccak256(memory[0x00:0x40])] // } 11F8 5B JUMPDEST 11F9 60 PUSH1 0x00 11FB 83 DUP4 11FC 81 DUP2 11FD 52 MSTORE 11FE 60 PUSH1 0x20 1200 81 DUP2 1201 81 DUP2 1202 52 MSTORE 1203 60 PUSH1 0x40 1205 80 DUP1 1206 83 DUP4 1207 20 SHA3 1208 60 PUSH1 0x01 120A 60 PUSH1 0x01 120C 60 PUSH1 0xa0 120E 1B SHL 120F 03 SUB 1210 8E DUP15 1211 81 DUP2 1212 16 AND 1213 85 DUP6 1214 52 MSTORE 1215 92 SWAP3 1216 52 MSTORE 1217 80 DUP1 1218 83 DUP4 1219 20 SHA3 121A 85 DUP6 121B 85 DUP6 121C 03 SUB 121D 90 SWAP1 121E 55 SSTORE 121F 90 SWAP1 1220 8B DUP12 1221 16 AND 1222 82 DUP3 1223 52 MSTORE 1224 81 DUP2 1225 20 SHA3 1226 80 DUP1 1227 54 SLOAD 1228 84 DUP5 1229 92 SWAP3 122A 90 SWAP1 122B 61 PUSH2 0x1235 122E 90 SWAP1 122F 84 DUP5 1230 90 SWAP1 1231 61 PUSH2 0x2bc4 1234 56 *JUMP // Stack delta = +6 // Outputs[12] // { // @11FD memory[0x00:0x20] = stack[-3] // @1202 memory[0x20:0x40] = 0x00 // @1214 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-10] // @1216 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @121E storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-2] // @1223 memory[0x00:0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @1225 stack[1] = keccak256(memory[0x00:0x40]) // @1229 stack[0] = stack[-2] // @122A stack[2] = 0x00 // @122E stack[3] = 0x1235 // @1230 stack[4] = stack[-2] // @1230 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2bc4, returns to 0x1235 label_1235: // Incoming return from call to 0x2BC4 at 0x1234 // Inputs[4] // { // @1236 stack[-4] // @1236 stack[-1] // @123A stack[-3] // @1240 stack[-8] // } 1235 5B JUMPDEST 1236 92 SWAP3 1237 50 POP 1238 50 POP 1239 81 DUP2 123A 90 SWAP1 123B 55 SSTORE 123C 50 POP 123D 50 POP 123E 50 POP 123F 50 POP 1240 80 DUP1 1241 61 PUSH2 0x1249 1244 90 SWAP1 1245 61 PUSH2 0x2ba9 1248 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @123B storage[stack[-3]] = stack[-1] // @1244 stack[-7] = 0x1249 // @1244 stack[-6] = stack[-8] // } // Block ends with call to 0x2ba9, returns to 0x1249 label_1249: // Incoming return from call to 0x2BA9 at 0x1248 // Inputs[2] // { // @124A stack[-1] // @124A stack[-2] // } 1249 5B JUMPDEST 124A 90 SWAP1 124B 50 POP 124C 61 PUSH2 0x1117 124F 56 *JUMP // Stack delta = -1 // Outputs[1] { @124A stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x1117 label_1250: // Incoming jump from 0x1120, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x1120, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[6] // { // @1252 stack[-6] // @125C stack[-7] // @1266 stack[-2] // @1291 stack[-5] // @1292 stack[-4] // @1295 memory[0x40:0x60] // } 1250 5B JUMPDEST 1251 50 POP 1252 84 DUP5 1253 60 PUSH1 0x01 1255 60 PUSH1 0x01 1257 60 PUSH1 0xa0 1259 1B SHL 125A 03 SUB 125B 16 AND 125C 86 DUP7 125D 60 PUSH1 0x01 125F 60 PUSH1 0x01 1261 60 PUSH1 0xa0 1263 1B SHL 1264 03 SUB 1265 16 AND 1266 82 DUP3 1267 60 PUSH1 0x01 1269 60 PUSH1 0x01 126B 60 PUSH1 0xa0 126D 1B SHL 126E 03 SUB 126F 16 AND 1270 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1291 87 DUP8 1292 87 DUP8 1293 60 PUSH1 0x40 1295 51 MLOAD 1296 61 PUSH2 0x12a0 1299 92 SWAP3 129A 91 SWAP2 129B 90 SWAP1 129C 61 PUSH2 0x2bdc 129F 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @125B stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1265 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-7] // @126F stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1270 stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @1299 stack[3] = 0x12a0 // @129A stack[4] = stack[-5] // @129B stack[6] = memory[0x40:0x60] // @129B stack[5] = stack[-4] // } // Block ends with call to 0x2bdc, returns to 0x12A0 label_12A0: // Incoming return from call to 0x2BDC at 0x129F // Inputs[13] // { // @12A3 memory[0x40:0x60] // @12A5 stack[-1] // @12A8 stack[-2] // @12A8 stack[-4] // @12A8 stack[-3] // @12A8 stack[-5] // @12A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @12AC stack[-6] // @12AD stack[-11] // @12AE stack[-10] // @12AF stack[-9] // @12B0 stack[-8] // @12B1 stack[-7] // } 12A0 5B JUMPDEST 12A1 60 PUSH1 0x40 12A3 51 MLOAD 12A4 80 DUP1 12A5 91 SWAP2 12A6 03 SUB 12A7 90 SWAP1 12A8 A4 LOG4 12A9 61 PUSH2 0x0c35 12AC 81 DUP2 12AD 87 DUP8 12AE 87 DUP8 12AF 87 DUP8 12B0 87 DUP8 12B1 87 DUP8 12B2 61 PUSH2 0x17b1 12B5 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @12A8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); // @12A9 stack[-5] = 0x0c35 // @12AC stack[-4] = stack[-6] // @12AD stack[-3] = stack[-11] // @12AE stack[-2] = stack[-10] // @12AF stack[-1] = stack[-9] // @12B0 stack[0] = stack[-8] // @12B1 stack[1] = stack[-7] // } // Block ends with call to 0x17b1, returns to 0x0C35 label_12B6: // Incoming call from 0x0D43, returns to 0x0D44 // Incoming call from 0x0FEE, returns to 0x0FEF // Incoming call from 0x0AE0, returns to 0x0AE1 // Incoming call from 0x09BB, returns to 0x09BC // Incoming call from 0x0B17, returns to 0x0B18 // Incoming call from 0x0A3E, returns to 0x0A3F // Incoming call from 0x0D59, returns to 0x0D5A // Incoming call from 0x0FB8, returns to 0x0FB9 // Incoming call from 0x07B7, returns to 0x07B8 // Inputs[5] // { // @12B9 stack[-2] // @12C7 memory[0x00:0x40] // @12D0 stack[-1] // @12D8 memory[0x00:0x40] // @12D9 storage[keccak256(memory[0x00:0x40])] // } 12B6 5B JUMPDEST 12B7 60 PUSH1 0x00 12B9 82 DUP3 12BA 81 DUP2 12BB 52 MSTORE 12BC 60 PUSH1 0x04 12BE 60 PUSH1 0x20 12C0 90 SWAP1 12C1 81 DUP2 12C2 52 MSTORE 12C3 60 PUSH1 0x40 12C5 80 DUP1 12C6 83 DUP4 12C7 20 SHA3 12C8 60 PUSH1 0x01 12CA 60 PUSH1 0x01 12CC 60 PUSH1 0xa0 12CE 1B SHL 12CF 03 SUB 12D0 85 DUP6 12D1 16 AND 12D2 84 DUP5 12D3 52 MSTORE 12D4 90 SWAP1 12D5 91 SWAP2 12D6 52 MSTORE 12D7 90 SWAP1 12D8 20 SHA3 12D9 54 SLOAD 12DA 60 PUSH1 0xff 12DC 16 AND 12DD 61 PUSH2 0x084f 12E0 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @12BB memory[0x00:0x20] = stack[-2] // @12C2 memory[0x20:0x40] = 0x04 // @12D3 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @12D6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x084f, if 0xff & storage[keccak256(memory[0x00:0x40])] label_12E1: // Incoming jump from 0x12E0, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @12E4 stack[-1] } 12E1 61 PUSH2 0x12f4 12E4 81 DUP2 12E5 60 PUSH1 0x01 12E7 60 PUSH1 0x01 12E9 60 PUSH1 0xa0 12EB 1B SHL 12EC 03 SUB 12ED 16 AND 12EE 60 PUSH1 0x14 12F0 61 PUSH2 0x197b 12F3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12E1 stack[0] = 0x12f4 // @12ED stack[1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @12EE stack[2] = 0x14 // } // Block ends with call to 0x197b, returns to 0x12F4 label_12F4: // Incoming return from call to 0x197B at 0x12F3 // Inputs[1] { @12F8 stack[-3] } 12F4 5B JUMPDEST 12F5 61 PUSH2 0x12ff 12F8 83 DUP4 12F9 60 PUSH1 0x20 12FB 61 PUSH2 0x197b 12FE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12F5 stack[0] = 0x12ff // @12F8 stack[1] = stack[-3] // @12F9 stack[2] = 0x20 // } // Block ends with call to 0x197b, returns to 0x12FF label_12FF: // Incoming return from call to 0x197B at 0x12FE // Inputs[3] // { // @1302 memory[0x40:0x60] // @1309 stack[-2] // @130A stack[-1] // } 12FF 5B JUMPDEST 1300 60 PUSH1 0x40 1302 51 MLOAD 1303 60 PUSH1 0x20 1305 01 ADD 1306 61 PUSH2 0x1310 1309 92 SWAP3 130A 91 SWAP2 130B 90 SWAP1 130C 61 PUSH2 0x2c0a 130F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1309 stack[-2] = 0x1310 // @130A stack[-1] = stack[-2] // @130B stack[1] = 0x20 + memory[0x40:0x60] // @130B stack[0] = stack[-1] // } // Block ends with call to 0x2c0a, returns to 0x1310 label_1310: // Incoming return from call to 0x2C0A at 0x130F // Inputs[2] // { // @1314 memory[0x40:0x60] // @1319 stack[-1] // } 1310 5B JUMPDEST 1311 60 PUSH1 0x40 1313 80 DUP1 1314 51 MLOAD 1315 60 PUSH1 0x1f 1317 19 NOT 1318 81 DUP2 1319 84 DUP5 131A 03 SUB 131B 01 ADD 131C 81 DUP2 131D 52 MSTORE 131E 90 SWAP1 131F 82 DUP3 1320 90 SWAP1 1321 52 MSTORE 1322 62 PUSH3 0x461bcd 1326 60 PUSH1 0xe5 1328 1B SHL 1329 82 DUP3 132A 52 MSTORE 132B 61 PUSH2 0x05b7 132E 91 SWAP2 132F 60 PUSH1 0x04 1331 01 ADD 1332 61 PUSH2 0x2415 1335 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @131D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + ~0x1f // @131E stack[0] = memory[0x40:0x60] // @1321 memory[0x40:0x60] = stack[-1] // @132A memory[stack[-1]:stack[-1] + 0x20] = 0x461bcd << 0xe5 // @132E stack[-1] = 0x05b7 // @1331 stack[1] = 0x04 + stack[-1] // } // Block ends with unconditional jump to 0x2415 label_1336: // Incoming call from 0x07C1, returns to 0x07C2 // Inputs[5] // { // @1339 stack[-2] // @1347 memory[0x00:0x40] // @1350 stack[-1] // @1358 memory[0x00:0x40] // @1359 storage[keccak256(memory[0x00:0x40])] // } 1336 5B JUMPDEST 1337 60 PUSH1 0x00 1339 82 DUP3 133A 81 DUP2 133B 52 MSTORE 133C 60 PUSH1 0x04 133E 60 PUSH1 0x20 1340 90 SWAP1 1341 81 DUP2 1342 52 MSTORE 1343 60 PUSH1 0x40 1345 80 DUP1 1346 83 DUP4 1347 20 SHA3 1348 60 PUSH1 0x01 134A 60 PUSH1 0x01 134C 60 PUSH1 0xa0 134E 1B SHL 134F 03 SUB 1350 85 DUP6 1351 16 AND 1352 84 DUP5 1353 52 MSTORE 1354 90 SWAP1 1355 91 SWAP2 1356 52 MSTORE 1357 90 SWAP1 1358 20 SHA3 1359 54 SLOAD 135A 60 PUSH1 0xff 135C 16 AND 135D 61 PUSH2 0x084f 1360 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @133B memory[0x00:0x20] = stack[-2] // @1342 memory[0x20:0x40] = 0x04 // @1353 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1356 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x084f, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1361: // Incoming jump from 0x1360, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @1363 stack[-2] // @1371 memory[0x00:0x40] // @137A stack[-1] // @1382 memory[0x00:0x40] // @1384 storage[keccak256(memory[0x00:0x40])] // @1391 msg.sender // } 1361 60 PUSH1 0x00 1363 82 DUP3 1364 81 DUP2 1365 52 MSTORE 1366 60 PUSH1 0x04 1368 60 PUSH1 0x20 136A 90 SWAP1 136B 81 DUP2 136C 52 MSTORE 136D 60 PUSH1 0x40 136F 80 DUP1 1370 83 DUP4 1371 20 SHA3 1372 60 PUSH1 0x01 1374 60 PUSH1 0x01 1376 60 PUSH1 0xa0 1378 1B SHL 1379 03 SUB 137A 85 DUP6 137B 16 AND 137C 84 DUP5 137D 52 MSTORE 137E 90 SWAP1 137F 91 SWAP2 1380 52 MSTORE 1381 90 SWAP1 1382 20 SHA3 1383 80 DUP1 1384 54 SLOAD 1385 60 PUSH1 0xff 1387 19 NOT 1388 16 AND 1389 60 PUSH1 0x01 138B 17 OR 138C 90 SWAP1 138D 55 SSTORE 138E 61 PUSH2 0x1394 1391 33 CALLER 1392 90 SWAP1 1393 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1365 memory[0x00:0x20] = stack[-2] // @136C memory[0x20:0x40] = 0x04 // @137D memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1380 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @138D storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1392 stack[0] = msg.sender // } // Block ends with unconditional jump to 0x1394 label_1394: // Incoming jump from 0x1393 // Inputs[7] // { // @139D stack[-1] // @139E stack[-2] // @13A8 stack[-3] // @13CC memory[0x40:0x60] // @13CF memory[0x40:0x60] // @13D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @13D7 stack[-4] // } 1394 5B JUMPDEST 1395 60 PUSH1 0x01 1397 60 PUSH1 0x01 1399 60 PUSH1 0xa0 139B 1B SHL 139C 03 SUB 139D 16 AND 139E 81 DUP2 139F 60 PUSH1 0x01 13A1 60 PUSH1 0x01 13A3 60 PUSH1 0xa0 13A5 1B SHL 13A6 03 SUB 13A7 16 AND 13A8 83 DUP4 13A9 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 13CA 60 PUSH1 0x40 13CC 51 MLOAD 13CD 60 PUSH1 0x40 13CF 51 MLOAD 13D0 80 DUP1 13D1 91 SWAP2 13D2 03 SUB 13D3 90 SWAP1 13D4 A4 LOG4 13D5 50 POP 13D6 50 POP 13D7 56 *JUMP // Stack delta = -4 // Outputs[1] { @13D4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d, stack[-3], stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-4] label_13D8: // Incoming call from 0x0D4D, returns to 0x07C2 // Incoming call from 0x084E, returns to 0x084F // Inputs[5] // { // @13DB stack[-2] // @13E9 memory[0x00:0x40] // @13F2 stack[-1] // @13FA memory[0x00:0x40] // @13FB storage[keccak256(memory[0x00:0x40])] // } 13D8 5B JUMPDEST 13D9 60 PUSH1 0x00 13DB 82 DUP3 13DC 81 DUP2 13DD 52 MSTORE 13DE 60 PUSH1 0x04 13E0 60 PUSH1 0x20 13E2 90 SWAP1 13E3 81 DUP2 13E4 52 MSTORE 13E5 60 PUSH1 0x40 13E7 80 DUP1 13E8 83 DUP4 13E9 20 SHA3 13EA 60 PUSH1 0x01 13EC 60 PUSH1 0x01 13EE 60 PUSH1 0xa0 13F0 1B SHL 13F1 03 SUB 13F2 85 DUP6 13F3 16 AND 13F4 84 DUP5 13F5 52 MSTORE 13F6 90 SWAP1 13F7 91 SWAP2 13F8 52 MSTORE 13F9 90 SWAP1 13FA 20 SHA3 13FB 54 SLOAD 13FC 60 PUSH1 0xff 13FE 16 AND 13FF 15 ISZERO 1400 61 PUSH2 0x084f 1403 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @13DD memory[0x00:0x20] = stack[-2] // @13E4 memory[0x20:0x40] = 0x04 // @13F5 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @13F8 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x084f, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1404: // Incoming jump from 0x1403, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[9] // { // @1406 stack[-2] // @1414 memory[0x00:0x40] // @141D stack[-1] // @1426 memory[0x00:0x40] // @1428 storage[keccak256(memory[0x00:0x40])] // @142F memory[0x40:0x60] // @1430 msg.sender // @1457 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @145A stack[-3] // } 1404 60 PUSH1 0x00 1406 82 DUP3 1407 81 DUP2 1408 52 MSTORE 1409 60 PUSH1 0x04 140B 60 PUSH1 0x20 140D 90 SWAP1 140E 81 DUP2 140F 52 MSTORE 1410 60 PUSH1 0x40 1412 80 DUP1 1413 83 DUP4 1414 20 SHA3 1415 60 PUSH1 0x01 1417 60 PUSH1 0x01 1419 60 PUSH1 0xa0 141B 1B SHL 141C 03 SUB 141D 85 DUP6 141E 16 AND 141F 80 DUP1 1420 85 DUP6 1421 52 MSTORE 1422 92 SWAP3 1423 52 MSTORE 1424 80 DUP1 1425 83 DUP4 1426 20 SHA3 1427 80 DUP1 1428 54 SLOAD 1429 60 PUSH1 0xff 142B 19 NOT 142C 16 AND 142D 90 SWAP1 142E 55 SSTORE 142F 51 MLOAD 1430 33 CALLER 1431 92 SWAP3 1432 85 DUP6 1433 91 SWAP2 1434 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 1455 91 SWAP2 1456 90 SWAP1 1457 A4 LOG4 1458 50 POP 1459 50 POP 145A 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @1408 memory[0x00:0x20] = stack[-2] // @140F memory[0x20:0x40] = 0x04 // @1421 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1423 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @142E storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @1457 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b, stack[-2], stack[-1] & (0x01 << 0xa0) - 0x01, msg.sender]); // } // Block ends with unconditional jump to stack[-3] label_145B: // Incoming jump from 0x0AEC // Incoming jump from 0x09F8 // Inputs[4] // { // @145F stack[-4] // @1460 stack[-3] // @1461 stack[-2] // @1462 stack[-1] // } 145B 5B JUMPDEST 145C 61 PUSH2 0x1467 145F 84 DUP5 1460 84 DUP5 1461 84 DUP5 1462 84 DUP5 1463 61 PUSH2 0x1bab 1466 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @145C stack[0] = 0x1467 // @145F stack[1] = stack[-4] // @1460 stack[2] = stack[-3] // @1461 stack[3] = stack[-2] // @1462 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1bab 1467 5B JUMPDEST 1468 60 PUSH1 0x00 146A 83 DUP4 146B 81 DUP2 146C 52 MSTORE 146D 60 PUSH1 0x03 146F 60 PUSH1 0x20 1471 52 MSTORE 1472 60 PUSH1 0x40 1474 81 DUP2 1475 20 SHA3 1476 80 DUP1 1477 54 SLOAD 1478 84 DUP5 1479 92 SWAP3 147A 90 SWAP1 147B 61 PUSH2 0x1485 147E 90 SWAP1 147F 84 DUP5 1480 90 SWAP1 1481 61 PUSH2 0x2bc4 1484 56 *JUMP 1485 5B JUMPDEST 1486 90 SWAP1 1487 91 SWAP2 1488 55 SSTORE 1489 50 POP 148A 50 POP 148B 50 POP 148C 50 POP 148D 50 POP 148E 50 POP 148F 56 *JUMP label_1490: // Incoming call from 0x0A49, returns to 0x0A4A // Inputs[3] // { // @1494 stack[-3] // @1495 stack[-2] // @1496 stack[-1] // } 1490 5B JUMPDEST 1491 61 PUSH2 0x149b 1494 83 DUP4 1495 83 DUP4 1496 83 DUP4 1497 61 PUSH2 0x1cc8 149A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1491 stack[0] = 0x149b // @1494 stack[1] = stack[-3] // @1495 stack[2] = stack[-2] // @1496 stack[3] = stack[-1] // } // Block ends with call to 0x1cc8, returns to 0x149B label_149B: // Incoming return from call to 0x1CC8 at 0x149A // Inputs[2] // { // @149F stack[-2] // @14A0 memory[stack[-2]:stack[-2] + 0x20] // } 149B 5B JUMPDEST 149C 60 PUSH1 0x00 149E 5B JUMPDEST 149F 82 DUP3 14A0 51 MLOAD 14A1 81 DUP2 14A2 10 LT 14A3 15 ISZERO 14A4 61 PUSH2 0x0a4a 14A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @149C stack[0] = 0x00 } // Block ends with conditional jump to 0x0a4a, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_14A8: // Incoming jump from 0x14A7, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x14A7, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @14A8 stack[-2] // @14A9 stack[-1] // @14AB memory[stack[-2]:stack[-2] + 0x20] // } 14A8 81 DUP2 14A9 81 DUP2 14AA 81 DUP2 14AB 51 MLOAD 14AC 81 DUP2 14AD 10 LT 14AE 61 PUSH2 0x14b9 14B1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14A8 stack[0] = stack[-2] // @14A9 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x14b9, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_14B2: // Incoming jump from 0x14B1, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 14B2 61 PUSH2 0x14b9 14B5 61 PUSH2 0x2b93 14B8 56 *JUMP // Stack delta = +1 // Outputs[1] { @14B2 stack[0] = 0x14b9 } // Block ends with unconditional jump to 0x2b93 label_14B9: // Incoming jump from 0x14B1, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[6] // { // @14BC stack[-1] // @14C0 stack[-2] // @14C1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @14C6 stack[-5] // @14C7 stack[-3] // @14C9 memory[stack[-5]:stack[-5] + 0x20] // } 14B9 5B JUMPDEST 14BA 60 PUSH1 0x20 14BC 02 MUL 14BD 60 PUSH1 0x20 14BF 01 ADD 14C0 01 ADD 14C1 51 MLOAD 14C2 60 PUSH1 0x03 14C4 60 PUSH1 0x00 14C6 85 DUP6 14C7 84 DUP5 14C8 81 DUP2 14C9 51 MLOAD 14CA 81 DUP2 14CB 10 LT 14CC 61 PUSH2 0x14d7 14CF 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @14C1 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @14C2 stack[-1] = 0x03 // @14C4 stack[0] = 0x00 // @14C6 stack[1] = stack[-5] // @14C7 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x14d7, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] label_14D0: // Incoming jump from 0x14CF, if not stack[-3] < memory[stack[-5]:stack[-5] + 0x20] 14D0 61 PUSH2 0x14d7 14D3 61 PUSH2 0x2b93 14D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @14D0 stack[0] = 0x14d7 } // Block ends with unconditional jump to 0x2b93 label_14D7: // Incoming jump from 0x14CF, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[8] // { // @14DA stack[-1] // @14DE stack[-2] // @14DF memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @14E0 stack[-3] // @14E5 stack[-4] // @14ED memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @14F0 stack[-5] // @14F2 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // } 14D7 5B JUMPDEST 14D8 60 PUSH1 0x20 14DA 02 MUL 14DB 60 PUSH1 0x20 14DD 01 ADD 14DE 01 ADD 14DF 51 MLOAD 14E0 81 DUP2 14E1 52 MSTORE 14E2 60 PUSH1 0x20 14E4 01 ADD 14E5 90 SWAP1 14E6 81 DUP2 14E7 52 MSTORE 14E8 60 PUSH1 0x20 14EA 01 ADD 14EB 60 PUSH1 0x00 14ED 20 SHA3 14EE 60 PUSH1 0x00 14F0 82 DUP3 14F1 82 DUP3 14F2 54 SLOAD 14F3 61 PUSH2 0x14fc 14F6 91 SWAP2 14F7 90 SWAP1 14F8 61 PUSH2 0x2c8b 14FB 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @14E1 memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @14E7 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @14ED stack[-4] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) // @14EE stack[-3] = 0x00 // @14F6 stack[-2] = 0x14fc // @14F7 stack[0] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @14F7 stack[-1] = stack[-5] // } // Block ends with call to 0x2c8b, returns to 0x14FC label_14FC: // Incoming return from call to 0x2C8B at 0x14FB // Inputs[5] // { // @14FD stack[-1] // @14FD stack[-2] // @14FE stack[-3] // @1504 stack[-4] // @1506 stack[-5] // } 14FC 5B JUMPDEST 14FD 90 SWAP1 14FE 91 SWAP2 14FF 55 SSTORE 1500 50 POP 1501 61 PUSH2 0x150b 1504 90 SWAP1 1505 50 POP 1506 81 DUP2 1507 61 PUSH2 0x2ba9 150A 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @14FF storage[stack[-3]] = stack[-1] // @1504 stack[-4] = 0x150b // @1506 stack[-3] = stack[-5] // } // Block ends with call to 0x2ba9, returns to 0x150B label_150B: // Incoming return from call to 0x2BA9 at 0x150A // Inputs[2] // { // @150C stack[-1] // @150C stack[-2] // } 150B 5B JUMPDEST 150C 90 SWAP1 150D 50 POP 150E 61 PUSH2 0x149e 1511 56 *JUMP // Stack delta = -1 // Outputs[1] { @150C stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x149e label_1512: // Incoming call from 0x0F8A, returns to 0x0F8B // Incoming call from 0x0AB3, returns to 0x0AB4 // Inputs[5] // { // @1516 storage[0x06] // @151F stack[-1] // @154C memory[0x40:0x60] // @1578 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @157B stack[-2] // } 1512 5B JUMPDEST 1513 60 PUSH1 0x06 1515 80 DUP1 1516 54 SLOAD 1517 60 PUSH1 0x01 1519 60 PUSH1 0x01 151B 60 PUSH1 0xa0 151D 1B SHL 151E 03 SUB 151F 83 DUP4 1520 81 DUP2 1521 16 AND 1522 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 1543 83 DUP4 1544 16 AND 1545 81 DUP2 1546 17 OR 1547 90 SWAP1 1548 93 SWAP4 1549 55 SSTORE 154A 60 PUSH1 0x40 154C 51 MLOAD 154D 91 SWAP2 154E 16 AND 154F 91 SWAP2 1550 90 SWAP1 1551 82 DUP3 1552 90 SWAP1 1553 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1574 90 SWAP1 1575 60 PUSH1 0x00 1577 90 SWAP1 1578 A3 LOG3 1579 50 POP 157A 50 POP 157B 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1549 storage[0x06] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x06] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) // @1578 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x06] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 157C 5B JUMPDEST 157D 60 PUSH1 0x01 157F 60 PUSH1 0x01 1581 60 PUSH1 0xa0 1583 1B SHL 1584 03 SUB 1585 84 DUP5 1586 16 AND 1587 61 PUSH2 0x15e0 158A 57 *JUMPI 158B 60 PUSH1 0x40 158D 51 MLOAD 158E 62 PUSH3 0x461bcd 1592 60 PUSH1 0xe5 1594 1B SHL 1595 81 DUP2 1596 52 MSTORE 1597 60 PUSH1 0x20 1599 60 PUSH1 0x04 159B 82 DUP3 159C 01 ADD 159D 52 MSTORE 159E 60 PUSH1 0x25 15A0 60 PUSH1 0x24 15A2 82 DUP3 15A3 01 ADD 15A4 52 MSTORE 15A5 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 15C6 60 PUSH1 0x44 15C8 82 DUP3 15C9 01 ADD 15CA 52 MSTORE 15CB 64 PUSH5 0x6472657373 15D1 60 PUSH1 0xd8 15D3 1B SHL 15D4 60 PUSH1 0x64 15D6 82 DUP3 15D7 01 ADD 15D8 52 MSTORE 15D9 60 PUSH1 0x84 15DB 01 ADD 15DC 61 PUSH2 0x05b7 15DF 56 *JUMP 15E0 5B JUMPDEST 15E1 33 CALLER 15E2 61 PUSH2 0x15f9 15E5 81 DUP2 15E6 87 DUP8 15E7 87 DUP8 15E8 61 PUSH2 0x15f0 15EB 88 DUP9 15EC 61 PUSH2 0x1f12 15EF 56 *JUMP label_15F0: // Incoming return from call to 0x1F12 at 0x1C37 // Inputs[1] { @15F4 stack[-8] } 15F0 5B JUMPDEST 15F1 61 PUSH2 0x0795 15F4 88 DUP9 15F5 61 PUSH2 0x1f12 15F8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15F1 stack[0] = 0x0795 // @15F4 stack[1] = stack[-8] // } // Block ends with call to 0x1f12, returns to 0x0795 15F9 5B JUMPDEST 15FA 60 PUSH1 0x00 15FC 84 DUP5 15FD 81 DUP2 15FE 52 MSTORE 15FF 60 PUSH1 0x20 1601 81 DUP2 1602 81 DUP2 1603 52 MSTORE 1604 60 PUSH1 0x40 1606 80 DUP1 1607 83 DUP4 1608 20 SHA3 1609 60 PUSH1 0x01 160B 60 PUSH1 0x01 160D 60 PUSH1 0xa0 160F 1B SHL 1610 03 SUB 1611 8A DUP11 1612 16 AND 1613 84 DUP5 1614 52 MSTORE 1615 90 SWAP1 1616 91 SWAP2 1617 52 MSTORE 1618 90 SWAP1 1619 20 SHA3 161A 54 SLOAD 161B 83 DUP4 161C 81 DUP2 161D 10 LT 161E 15 ISZERO 161F 61 PUSH2 0x1690 1622 57 *JUMPI 1623 60 PUSH1 0x40 1625 51 MLOAD 1626 62 PUSH3 0x461bcd 162A 60 PUSH1 0xe5 162C 1B SHL 162D 81 DUP2 162E 52 MSTORE 162F 60 PUSH1 0x20 1631 60 PUSH1 0x04 1633 82 DUP3 1634 01 ADD 1635 52 MSTORE 1636 60 PUSH1 0x2a 1638 60 PUSH1 0x24 163A 82 DUP3 163B 01 ADD 163C 52 MSTORE 163D 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 165E 60 PUSH1 0x44 1660 82 DUP3 1661 01 ADD 1662 52 MSTORE 1663 7F PUSH32 0x72207472616e7366657200000000000000000000000000000000000000000000 1684 60 PUSH1 0x64 1686 82 DUP3 1687 01 ADD 1688 52 MSTORE 1689 60 PUSH1 0x84 168B 01 ADD 168C 61 PUSH2 0x05b7 168F 56 *JUMP 1690 5B JUMPDEST 1691 60 PUSH1 0x00 1693 85 DUP6 1694 81 DUP2 1695 52 MSTORE 1696 60 PUSH1 0x20 1698 81 DUP2 1699 81 DUP2 169A 52 MSTORE 169B 60 PUSH1 0x40 169D 80 DUP1 169E 83 DUP4 169F 20 SHA3 16A0 60 PUSH1 0x01 16A2 60 PUSH1 0x01 16A4 60 PUSH1 0xa0 16A6 1B SHL 16A7 03 SUB 16A8 8B DUP12 16A9 81 DUP2 16AA 16 AND 16AB 85 DUP6 16AC 52 MSTORE 16AD 92 SWAP3 16AE 52 MSTORE 16AF 80 DUP1 16B0 83 DUP4 16B1 20 SHA3 16B2 87 DUP8 16B3 85 DUP6 16B4 03 SUB 16B5 90 SWAP1 16B6 55 SSTORE 16B7 90 SWAP1 16B8 88 DUP9 16B9 16 AND 16BA 82 DUP3 16BB 52 MSTORE 16BC 81 DUP2 16BD 20 SHA3 16BE 80 DUP1 16BF 54 SLOAD 16C0 86 DUP7 16C1 92 SWAP3 16C2 90 SWAP1 16C3 61 PUSH2 0x16cd 16C6 90 SWAP1 16C7 84 DUP5 16C8 90 SWAP1 16C9 61 PUSH2 0x2bc4 16CC 56 *JUMP 16CD 5B JUMPDEST 16CE 90 SWAP1 16CF 91 SWAP2 16D0 55 SSTORE 16D1 50 POP 16D2 50 POP 16D3 60 PUSH1 0x40 16D5 80 DUP1 16D6 51 MLOAD 16D7 86 DUP7 16D8 81 DUP2 16D9 52 MSTORE 16DA 60 PUSH1 0x20 16DC 81 DUP2 16DD 01 ADD 16DE 86 DUP7 16DF 90 SWAP1 16E0 52 MSTORE 16E1 60 PUSH1 0x01 16E3 60 PUSH1 0x01 16E5 60 PUSH1 0xa0 16E7 1B SHL 16E8 03 SUB 16E9 80 DUP1 16EA 89 DUP10 16EB 16 AND 16EC 92 SWAP3 16ED 8A DUP11 16EE 82 DUP3 16EF 16 AND 16F0 92 SWAP3 16F1 91 SWAP2 16F2 86 DUP7 16F3 16 AND 16F4 91 SWAP2 16F5 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1716 91 SWAP2 1717 01 ADD 1718 60 PUSH1 0x40 171A 51 MLOAD 171B 80 DUP1 171C 91 SWAP2 171D 03 SUB 171E 90 SWAP1 171F A4 LOG4 1720 61 PUSH2 0x0a0b 1723 82 DUP3 1724 88 DUP9 1725 88 DUP9 1726 88 DUP9 1727 88 DUP9 1728 88 DUP9 1729 61 PUSH2 0x1f5d 172C 56 *JUMP label_172D: // Incoming call from 0x0FC3, returns to 0x0A4A // Inputs[3] // { // @1731 stack[-3] // @1732 stack[-2] // @1733 stack[-1] // } 172D 5B JUMPDEST 172E 61 PUSH2 0x1738 1731 83 DUP4 1732 83 DUP4 1733 83 DUP4 1734 61 PUSH2 0x207d 1737 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @172E stack[0] = 0x1738 // @1731 stack[1] = stack[-3] // @1732 stack[2] = stack[-2] // @1733 stack[3] = stack[-1] // } // Block ends with call to 0x207d, returns to 0x1738 label_1738: // Incoming return from call to 0x207D at 0x1737 // Inputs[4] // { // @173B stack[-2] // @1746 memory[0x00:0x40] // @1748 storage[keccak256(memory[0x00:0x40])] // @1749 stack[-1] // } 1738 5B JUMPDEST 1739 60 PUSH1 0x00 173B 82 DUP3 173C 81 DUP2 173D 52 MSTORE 173E 60 PUSH1 0x03 1740 60 PUSH1 0x20 1742 52 MSTORE 1743 60 PUSH1 0x40 1745 81 DUP2 1746 20 SHA3 1747 80 DUP1 1748 54 SLOAD 1749 83 DUP4 174A 92 SWAP3 174B 90 SWAP1 174C 61 PUSH2 0x1756 174F 90 SWAP1 1750 84 DUP5 1751 90 SWAP1 1752 61 PUSH2 0x2c8b 1755 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @173D memory[0x00:0x20] = stack[-2] // @1742 memory[0x20:0x40] = 0x03 // @1746 stack[1] = keccak256(memory[0x00:0x40]) // @174A stack[0] = stack[-1] // @174B stack[2] = 0x00 // @174F stack[3] = 0x1756 // @1751 stack[4] = stack[-1] // @1751 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2c8b, returns to 0x1756 label_1756: // Incoming return from call to 0x2C8B at 0x1755 // Inputs[4] // { // @1757 stack[-2] // @1757 stack[-1] // @1758 stack[-3] // @175F stack[-8] // } 1756 5B JUMPDEST 1757 90 SWAP1 1758 91 SWAP2 1759 55 SSTORE 175A 50 POP 175B 50 POP 175C 50 POP 175D 50 POP 175E 50 POP 175F 56 *JUMP // Stack delta = -8 // Outputs[1] { @1759 storage[stack[-3]] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1760: // Incoming jump from 0x0FF7 // Inputs[2] // { // @1761 stack[-1] // @1762 memory[stack[-1]:stack[-1] + 0x20] // } 1760 5B JUMPDEST 1761 80 DUP1 1762 51 MLOAD 1763 61 PUSH2 0x084f 1766 90 SWAP1 1767 60 PUSH1 0x02 1769 90 SWAP1 176A 60 PUSH1 0x20 176C 84 DUP5 176D 01 ADD 176E 90 SWAP1 176F 61 PUSH2 0x2292 1772 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1766 stack[0] = 0x084f // @1769 stack[1] = 0x02 // @176E stack[2] = stack[-1] + 0x20 // @176E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2292 label_1773: // Incoming call from 0x1002, returns to 0x1003 // Inputs[1] { @177F stack[-1] } 1773 5B JUMPDEST 1774 60 PUSH1 0x00 1776 60 PUSH1 0x01 1778 60 PUSH1 0x01 177A 60 PUSH1 0xe0 177C 1B SHL 177D 03 SUB 177E 19 NOT 177F 82 DUP3 1780 16 AND 1781 7F PUSH32 0x7965db0b00000000000000000000000000000000000000000000000000000000 17A2 14 EQ 17A3 80 DUP1 17A4 61 PUSH2 0x05f1 17A7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1774 stack[0] = 0x00 // @17A2 stack[1] = 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x05f1, if 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_17A8: // Incoming jump from 0x17A7, if not 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @17AC stack[-3] } 17A8 50 POP 17A9 61 PUSH2 0x05f1 17AC 82 DUP3 17AD 61 PUSH2 0x21f7 17B0 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @17A9 stack[-1] = 0x05f1 // @17AC stack[0] = stack[-3] // } // Block ends with call to 0x21f7, returns to 0x05F1 label_17B1: // Incoming call from 0x12B5, returns to 0x0C35 // Inputs[2] // { // @17BA stack[-4] // @17BC address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 17B1 5B JUMPDEST 17B2 60 PUSH1 0x01 17B4 60 PUSH1 0x01 17B6 60 PUSH1 0xa0 17B8 1B SHL 17B9 03 SUB 17BA 84 DUP5 17BB 16 AND 17BC 3B EXTCODESIZE 17BD 15 ISZERO 17BE 61 PUSH2 0x0c35 17C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c35, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_17C2: // Incoming jump from 0x17C1, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[7] // { // @17C4 memory[0x40:0x60] // @17D7 stack[-4] // @17E4 stack[-6] // @17E6 stack[-5] // @17E8 stack[-3] // @17EA stack[-2] // @17EC stack[-1] // } 17C2 60 PUSH1 0x40 17C4 51 MLOAD 17C5 63 PUSH4 0xbc197c81 17CA 60 PUSH1 0xe0 17CC 1B SHL 17CD 81 DUP2 17CE 52 MSTORE 17CF 60 PUSH1 0x01 17D1 60 PUSH1 0x01 17D3 60 PUSH1 0xa0 17D5 1B SHL 17D6 03 SUB 17D7 85 DUP6 17D8 16 AND 17D9 90 SWAP1 17DA 63 PUSH4 0xbc197c81 17DF 90 SWAP1 17E0 61 PUSH2 0x17f5 17E3 90 SWAP1 17E4 89 DUP10 17E5 90 SWAP1 17E6 89 DUP10 17E7 90 SWAP1 17E8 88 DUP9 17E9 90 SWAP1 17EA 88 DUP9 17EB 90 SWAP1 17EC 88 DUP9 17ED 90 SWAP1 17EE 60 PUSH1 0x04 17F0 01 ADD 17F1 61 PUSH2 0x2ca2 17F4 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @17CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xbc197c81 << 0xe0 // @17D9 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @17DF stack[1] = 0xbc197c81 // @17E3 stack[2] = 0x17f5 // @17E5 stack[3] = stack[-6] // @17E7 stack[4] = stack[-5] // @17E9 stack[5] = stack[-3] // @17EB stack[6] = stack[-2] // @17ED stack[7] = stack[-1] // @17F0 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2ca2, returns to 0x17F5 label_17F5: // Incoming return from call to 0x2CA2 at 0x17F4 // Inputs[4] // { // @17FA memory[0x40:0x60] // @17FC stack[-1] // @1801 stack[-3] // @1803 address(stack[-3]).code.length // } 17F5 5B JUMPDEST 17F6 60 PUSH1 0x20 17F8 60 PUSH1 0x40 17FA 51 MLOAD 17FB 80 DUP1 17FC 83 DUP4 17FD 03 SUB 17FE 81 DUP2 17FF 60 PUSH1 0x00 1801 87 DUP8 1802 80 DUP1 1803 3B EXTCODESIZE 1804 15 ISZERO 1805 80 DUP1 1806 15 ISZERO 1807 61 PUSH2 0x180f 180A 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @17F6 stack[0] = 0x20 // @17FA stack[1] = memory[0x40:0x60] // @17FD stack[2] = stack[-1] - memory[0x40:0x60] // @17FE stack[3] = memory[0x40:0x60] // @17FF stack[4] = 0x00 // @1801 stack[5] = stack[-3] // @1804 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x180f, if !!address(stack[-3]).code.length label_180B: // Incoming jump from 0x180A, if not !!address(stack[-3]).code.length // Inputs[1] { @180E memory[0x00:0x00] } 180B 60 PUSH1 0x00 180D 80 DUP1 180E FD *REVERT // Stack delta = +0 // Outputs[1] { @180E revert(memory[0x00:0x00]); } // Block terminates label_180F: // Incoming jump from 0x180A, if !!address(stack[-3]).code.length // Inputs[10] // { // @1811 msg.gas // @1812 stack[-3] // @1812 stack[-6] // @1812 stack[-7] // @1812 memory[stack[-4]:stack[-4] + stack[-5]] // @1812 stack[-4] // @1812 stack[-2] // @1812 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1812 stack[-5] // @1813 stack[-10] // } 180F 5B JUMPDEST 1810 50 POP 1811 5A GAS 1812 F1 CALL 1813 92 SWAP3 1814 50 POP 1815 50 POP 1816 50 POP 1817 80 DUP1 1818 15 ISZERO 1819 61 PUSH2 0x183f 181C 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1812 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1813 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 0x183f, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_181D: // Incoming jump from 0x181C, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1821 memory[0x40:0x60] // @1824 returndata.length // } 181D 50 POP 181E 60 PUSH1 0x40 1820 80 DUP1 1821 51 MLOAD 1822 60 PUSH1 0x1f 1824 3D RETURNDATASIZE 1825 90 SWAP1 1826 81 DUP2 1827 01 ADD 1828 60 PUSH1 0x1f 182A 19 NOT 182B 16 AND 182C 82 DUP3 182D 01 ADD 182E 90 SWAP1 182F 92 SWAP3 1830 52 MSTORE 1831 61 PUSH2 0x183c 1834 91 SWAP2 1835 81 DUP2 1836 01 ADD 1837 90 SWAP1 1838 61 PUSH2 0x2d00 183B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1830 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1834 stack[-1] = 0x183c // @1837 stack[1] = memory[0x40:0x60] // @1837 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2d00 183C 5B JUMPDEST 183D 60 PUSH1 0x01 label_183F: // Incoming jump from 0x181C, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1843 stack[-1] } 183F 5B JUMPDEST 1840 61 PUSH2 0x18f5 1843 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18f5, if stack[-1] label_1844: // Incoming jump from 0x1843, if not stack[-1] 1844 61 PUSH2 0x184b 1847 61 PUSH2 0x2d1d 184A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1844 stack[0] = 0x184b } // Block ends with call to 0x2d1d, returns to 0x184B label_184B: // Incoming return from call to 0x2D1D at 0x1FF6 // Incoming return from call to 0x2D1D at 0x184A // Inputs[1] { @184C stack[-1] } 184B 5B JUMPDEST 184C 80 DUP1 184D 63 PUSH4 0x08c379a0 1852 14 EQ 1853 15 ISZERO 1854 61 PUSH2 0x1885 1857 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1885, if !(0x08c379a0 == stack[-1]) label_1858: // Incoming jump from 0x1857, if not !(0x08c379a0 == stack[-1]) 1858 50 POP 1859 61 PUSH2 0x1860 185C 61 PUSH2 0x2d39 185F 56 *JUMP // Stack delta = +0 // Outputs[1] { @1859 stack[-1] = 0x1860 } // Block ends with call to 0x2d39, returns to 0x1860 label_1860: // Incoming return from call to 0x2D39 at 0x185F // Incoming return from call to 0x2D39 at 0x185F // Inputs[1] { @1861 stack[-1] } 1860 5B JUMPDEST 1861 80 DUP1 1862 61 PUSH2 0x186b 1865 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x186b, if stack[-1] label_1866: // Incoming jump from 0x1865, if not stack[-1] 1866 50 POP 1867 61 PUSH2 0x1887 186A 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1887 label_186B: // Incoming jump from 0x1865, if stack[-1] // Inputs[2] // { // @186C stack[-1] // @186F memory[0x40:0x60] // } 186B 5B JUMPDEST 186C 80 DUP1 186D 60 PUSH1 0x40 186F 51 MLOAD 1870 62 PUSH3 0x461bcd 1874 60 PUSH1 0xe5 1876 1B SHL 1877 81 DUP2 1878 52 MSTORE 1879 60 PUSH1 0x04 187B 01 ADD 187C 61 PUSH2 0x05b7 187F 91 SWAP2 1880 90 SWAP1 1881 61 PUSH2 0x2415 1884 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1878 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @187F stack[0] = 0x05b7 // @1880 stack[1] = stack[-1] // @1880 stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2415 label_1885: // Incoming jump from 0x1857, if !(0x08c379a0 == stack[-1]) // Inputs[1] { @188A memory[0x40:0x60] } 1885 5B JUMPDEST 1886 50 POP 1887 5B JUMPDEST 1888 60 PUSH1 0x40 188A 51 MLOAD 188B 62 PUSH3 0x461bcd 188F 60 PUSH1 0xe5 1891 1B SHL 1892 81 DUP2 1893 52 MSTORE 1894 60 PUSH1 0x20 1896 60 PUSH1 0x04 1898 82 DUP3 1899 01 ADD 189A 52 MSTORE 189B 60 PUSH1 0x34 189D 60 PUSH1 0x24 189F 82 DUP3 18A0 01 ADD 18A1 52 MSTORE 18A2 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 18C3 60 PUSH1 0x44 18C5 82 DUP3 18C6 01 ADD 18C7 52 MSTORE 18C8 7F PUSH32 0x526563656976657220696d706c656d656e746572000000000000000000000000 18E9 60 PUSH1 0x64 18EB 82 DUP3 18EC 01 ADD 18ED 52 MSTORE 18EE 60 PUSH1 0x84 18F0 01 ADD 18F1 61 PUSH2 0x05b7 18F4 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @1893 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @189A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18A1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x34 // @18C7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 // @18ED memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x526563656976657220696d706c656d656e746572000000000000000000000000 // @18F0 stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_18F5: // Incoming jump from 0x1843, if stack[-1] // Inputs[1] { @18FF stack[-1] } 18F5 5B JUMPDEST 18F6 60 PUSH1 0x01 18F8 60 PUSH1 0x01 18FA 60 PUSH1 0xe0 18FC 1B SHL 18FD 03 SUB 18FE 19 NOT 18FF 81 DUP2 1900 16 AND 1901 63 PUSH4 0xbc197c81 1906 60 PUSH1 0xe0 1908 1B SHL 1909 14 EQ 190A 61 PUSH2 0x0a0b 190D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a0b, if 0xbc197c81 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_190E: // Incoming jump from 0x190D, if not 0xbc197c81 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1910 memory[0x40:0x60] } 190E 60 PUSH1 0x40 1910 51 MLOAD 1911 62 PUSH3 0x461bcd 1915 60 PUSH1 0xe5 1917 1B SHL 1918 81 DUP2 1919 52 MSTORE 191A 60 PUSH1 0x20 191C 60 PUSH1 0x04 191E 82 DUP3 191F 01 ADD 1920 52 MSTORE 1921 60 PUSH1 0x28 1923 60 PUSH1 0x24 1925 82 DUP3 1926 01 ADD 1927 52 MSTORE 1928 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 1949 60 PUSH1 0x44 194B 82 DUP3 194C 01 ADD 194D 52 MSTORE 194E 7F PUSH32 0x6420746f6b656e73000000000000000000000000000000000000000000000000 196F 60 PUSH1 0x64 1971 82 DUP3 1972 01 ADD 1973 52 MSTORE 1974 60 PUSH1 0x84 1976 01 ADD 1977 61 PUSH2 0x05b7 197A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1919 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1920 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1927 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @194D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @1973 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6420746f6b656e73000000000000000000000000000000000000000000000000 // @1976 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_197B: // Incoming call from 0x12F3, returns to 0x12F4 // Incoming call from 0x12FE, returns to 0x12FF // Inputs[1] { @1983 stack[-1] } 197B 5B JUMPDEST 197C 60 PUSH1 0x60 197E 60 PUSH1 0x00 1980 61 PUSH2 0x198a 1983 83 DUP4 1984 60 PUSH1 0x02 1986 61 PUSH2 0x2b52 1989 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @197C stack[0] = 0x60 // @197E stack[1] = 0x00 // @1980 stack[2] = 0x198a // @1983 stack[3] = stack[-1] // @1984 stack[4] = 0x02 // } // Block ends with call to 0x2b52, returns to 0x198A label_198A: // Incoming return from call to 0x2B52 at 0x1989 // Inputs[1] { @198E stack[-1] } 198A 5B JUMPDEST 198B 61 PUSH2 0x1995 198E 90 SWAP1 198F 60 PUSH1 0x02 1991 61 PUSH2 0x2bc4 1994 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @198E stack[0] = stack[-1] // @198E stack[-1] = 0x1995 // @198F stack[1] = 0x02 // } // Block ends with call to 0x2bc4, returns to 0x1995 label_1995: // Incoming return from call to 0x2BC4 at 0x1994 // Inputs[1] { @199F stack[-1] } 1995 5B JUMPDEST 1996 67 PUSH8 0xffffffffffffffff 199F 81 DUP2 19A0 11 GT 19A1 15 ISZERO 19A2 61 PUSH2 0x19ad 19A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19ad, if !(stack[-1] > 0xffffffffffffffff) label_19A6: // Incoming jump from 0x19A5, if not !(stack[-1] > 0xffffffffffffffff) 19A6 61 PUSH2 0x19ad 19A9 61 PUSH2 0x244a 19AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @19A6 stack[0] = 0x19ad } // Block ends with unconditional jump to 0x244a label_19AD: // Incoming jump from 0x19A5, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @19B0 memory[0x40:0x60] // @19B1 stack[-1] // } 19AD 5B JUMPDEST 19AE 60 PUSH1 0x40 19B0 51 MLOAD 19B1 90 SWAP1 19B2 80 DUP1 19B3 82 DUP3 19B4 52 MSTORE 19B5 80 DUP1 19B6 60 PUSH1 0x1f 19B8 01 ADD 19B9 60 PUSH1 0x1f 19BB 19 NOT 19BC 16 AND 19BD 60 PUSH1 0x20 19BF 01 ADD 19C0 82 DUP3 19C1 01 ADD 19C2 60 PUSH1 0x40 19C4 52 MSTORE 19C5 80 DUP1 19C6 15 ISZERO 19C7 61 PUSH2 0x19d7 19CA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @19B1 stack[-1] = memory[0x40:0x60] // @19B1 stack[0] = stack[-1] // @19B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @19C4 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x19d7, if !stack[-1] label_19CB: // Incoming jump from 0x19CA, if not !stack[-1] // Inputs[6] // { // @19CD stack[-2] // @19CF stack[-1] // @19D1 msg.data.length // @19D3 msg.data[msg.data.length:msg.data.length + stack[-1]] // @19D9 stack[-3] // @1A00 memory[stack[-2]:stack[-2] + 0x20] // } 19CB 60 PUSH1 0x20 19CD 82 DUP3 19CE 01 ADD 19CF 81 DUP2 19D0 80 DUP1 19D1 36 CALLDATASIZE 19D2 83 DUP4 19D3 37 CALLDATACOPY 19D4 01 ADD 19D5 90 SWAP1 19D6 50 POP 19D7 5B JUMPDEST 19D8 50 POP 19D9 90 SWAP1 19DA 50 POP 19DB 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 19FC 81 DUP2 19FD 60 PUSH1 0x00 19FF 81 DUP2 1A00 51 MLOAD 1A01 81 DUP2 1A02 10 LT 1A03 61 PUSH2 0x1a0e 1A06 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @19D3 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @19D9 stack[-3] = stack[-2] // @19DB stack[-2] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @19FC stack[-1] = stack[-2] // @19FD stack[0] = 0x00 // } // Block ends with conditional jump to 0x1a0e, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_1A07: // Incoming jump from 0x1A06, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1A06, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 1A07 61 PUSH2 0x1a0e 1A0A 61 PUSH2 0x2b93 1A0D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A07 stack[0] = 0x1a0e } // Block ends with unconditional jump to 0x2b93 label_1A0E: // Incoming jump from 0x1A06, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1A06, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @1A11 stack[-1] // @1A12 stack[-2] // @1A13 stack[-3] // @1A5F stack[-4] // @1A63 memory[stack[-4]:stack[-4] + 0x20] // } 1A0E 5B JUMPDEST 1A0F 60 PUSH1 0x20 1A11 01 ADD 1A12 01 ADD 1A13 90 SWAP1 1A14 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1A34 19 NOT 1A35 16 AND 1A36 90 SWAP1 1A37 81 DUP2 1A38 60 PUSH1 0x00 1A3A 1A BYTE 1A3B 90 SWAP1 1A3C 53 MSTORE8 1A3D 50 POP 1A3E 7F PUSH32 0x7800000000000000000000000000000000000000000000000000000000000000 1A5F 81 DUP2 1A60 60 PUSH1 0x01 1A62 81 DUP2 1A63 51 MLOAD 1A64 81 DUP2 1A65 10 LT 1A66 61 PUSH2 0x1a71 1A69 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1A3C memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @1A3E stack[-3] = 0x7800000000000000000000000000000000000000000000000000000000000000 // @1A5F stack[-2] = stack[-4] // @1A60 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x1a71, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_1A6A: // Incoming jump from 0x1A69, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 1A6A 61 PUSH2 0x1a71 1A6D 61 PUSH2 0x2b93 1A70 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A6A stack[0] = 0x1a71 } // Block ends with unconditional jump to 0x2b93 label_1A71: // Incoming jump from 0x1A69, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @1A74 stack[-1] // @1A75 stack[-2] // @1A76 stack[-3] // @1AA6 stack[-6] // } 1A71 5B JUMPDEST 1A72 60 PUSH1 0x20 1A74 01 ADD 1A75 01 ADD 1A76 90 SWAP1 1A77 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1A97 19 NOT 1A98 16 AND 1A99 90 SWAP1 1A9A 81 DUP2 1A9B 60 PUSH1 0x00 1A9D 1A BYTE 1A9E 90 SWAP1 1A9F 53 MSTORE8 1AA0 50 POP 1AA1 60 PUSH1 0x00 1AA3 61 PUSH2 0x1aad 1AA6 84 DUP5 1AA7 60 PUSH1 0x02 1AA9 61 PUSH2 0x2b52 1AAC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1A9F memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @1AA1 stack[-3] = 0x00 // @1AA3 stack[-2] = 0x1aad // @1AA6 stack[-1] = stack[-6] // @1AA7 stack[0] = 0x02 // } // Block ends with call to 0x2b52, returns to 0x1AAD label_1AAD: // Incoming return from call to 0x2B52 at 0x1AAC // Inputs[1] { @1AB1 stack[-1] } 1AAD 5B JUMPDEST 1AAE 61 PUSH2 0x1ab8 1AB1 90 SWAP1 1AB2 60 PUSH1 0x01 1AB4 61 PUSH2 0x2bc4 1AB7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1AB1 stack[0] = stack[-1] // @1AB1 stack[-1] = 0x1ab8 // @1AB2 stack[1] = 0x01 // } // Block ends with call to 0x2bc4, returns to 0x1AB8 label_1AB8: // Incoming return from call to 0x2BC4 at 0x1AB7 // Inputs[2] // { // @1AB9 stack[-2] // @1AB9 stack[-1] // } 1AB8 5B JUMPDEST 1AB9 90 SWAP1 1ABA 50 POP 1ABB 5B JUMPDEST 1ABC 60 PUSH1 0x01 1ABE 81 DUP2 1ABF 11 GT 1AC0 15 ISZERO 1AC1 61 PUSH2 0x1b55 1AC4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1AB9 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1b55, if !(stack[-1] > 0x01) label_1AC5: // Incoming jump from 0x1AC4, if not !(stack[-1] > 0x01) // Incoming jump from 0x1AC4, if not !(stack[-1] > 0x01) // Inputs[1] { @1AE6 stack[-5] } 1AC5 7F PUSH32 0x3031323334353637383961626364656600000000000000000000000000000000 1AE6 85 DUP6 1AE7 60 PUSH1 0x0f 1AE9 16 AND 1AEA 60 PUSH1 0x10 1AEC 81 DUP2 1AED 10 LT 1AEE 61 PUSH2 0x1af9 1AF1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1AC5 stack[0] = 0x3031323334353637383961626364656600000000000000000000000000000000 // @1AE9 stack[1] = 0x0f & stack[-5] // } // Block ends with conditional jump to 0x1af9, if 0x0f & stack[-5] < 0x10 label_1AF2: // Incoming jump from 0x1AF1, if not 0x0f & stack[-5] < 0x10 1AF2 61 PUSH2 0x1af9 1AF5 61 PUSH2 0x2b93 1AF8 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AF2 stack[0] = 0x1af9 } // Block ends with unconditional jump to 0x2b93 label_1AF9: // Incoming jump from 0x1AF1, if 0x0f & stack[-5] < 0x10 // Inputs[5] // { // @1AFA stack[-1] // @1AFA stack[-2] // @1AFE stack[-4] // @1AFF stack[-3] // @1B01 memory[stack[-4]:stack[-4] + 0x20] // } 1AF9 5B JUMPDEST 1AFA 1A BYTE 1AFB 60 PUSH1 0xf8 1AFD 1B SHL 1AFE 82 DUP3 1AFF 82 DUP3 1B00 81 DUP2 1B01 51 MLOAD 1B02 81 DUP2 1B03 10 LT 1B04 61 PUSH2 0x1b0f 1B07 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1AFD stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @1AFE stack[-1] = stack[-4] // @1AFF stack[0] = stack[-3] // } // Block ends with conditional jump to 0x1b0f, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_1B08: // Incoming jump from 0x1B07, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 1B08 61 PUSH2 0x1b0f 1B0B 61 PUSH2 0x2b93 1B0E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B08 stack[0] = 0x1b0f } // Block ends with unconditional jump to 0x2b93 label_1B0F: // Incoming jump from 0x1B07, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @1B12 stack[-1] // @1B13 stack[-2] // @1B14 stack[-3] // @1B41 stack[-8] // @1B42 stack[-4] // } 1B0F 5B JUMPDEST 1B10 60 PUSH1 0x20 1B12 01 ADD 1B13 01 ADD 1B14 90 SWAP1 1B15 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1B35 19 NOT 1B36 16 AND 1B37 90 SWAP1 1B38 81 DUP2 1B39 60 PUSH1 0x00 1B3B 1A BYTE 1B3C 90 SWAP1 1B3D 53 MSTORE8 1B3E 50 POP 1B3F 60 PUSH1 0x04 1B41 94 SWAP5 1B42 90 SWAP1 1B43 94 SWAP5 1B44 1C SHR 1B45 93 SWAP4 1B46 61 PUSH2 0x1b4e 1B49 81 DUP2 1B4A 61 PUSH2 0x2dc3 1B4D 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1B3D memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @1B45 stack[-4] = stack[-4] // @1B45 stack[-8] = stack[-8] >> 0x04 // @1B46 stack[-3] = 0x1b4e // @1B49 stack[-2] = stack[-4] // } // Block ends with call to 0x2dc3, returns to 0x1B4E label_1B4E: // Incoming return from call to 0x2DC3 at 0x1B4D // Inputs[2] // { // @1B4F stack[-1] // @1B4F stack[-2] // } 1B4E 5B JUMPDEST 1B4F 90 SWAP1 1B50 50 POP 1B51 61 PUSH2 0x1abb 1B54 56 *JUMP // Stack delta = -1 // Outputs[1] { @1B4F stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x1abb label_1B55: // Incoming jump from 0x1AC4, if !(stack[-1] > 0x01) // Incoming jump from 0x1AC4, if !(stack[-1] > 0x01) // Inputs[1] { @1B57 stack[-5] } 1B55 5B JUMPDEST 1B56 50 POP 1B57 83 DUP4 1B58 15 ISZERO 1B59 61 PUSH2 0x1ba4 1B5C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1ba4, if !stack[-5] label_1B5D: // Incoming jump from 0x1B5C, if not !stack[-5] // Inputs[1] { @1B5F memory[0x40:0x60] } 1B5D 60 PUSH1 0x40 1B5F 51 MLOAD 1B60 62 PUSH3 0x461bcd 1B64 60 PUSH1 0xe5 1B66 1B SHL 1B67 81 DUP2 1B68 52 MSTORE 1B69 60 PUSH1 0x20 1B6B 60 PUSH1 0x04 1B6D 82 DUP3 1B6E 01 ADD 1B6F 81 DUP2 1B70 90 SWAP1 1B71 52 MSTORE 1B72 60 PUSH1 0x24 1B74 82 DUP3 1B75 01 ADD 1B76 52 MSTORE 1B77 7F PUSH32 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 1B98 60 PUSH1 0x44 1B9A 82 DUP3 1B9B 01 ADD 1B9C 52 MSTORE 1B9D 60 PUSH1 0x64 1B9F 01 ADD 1BA0 61 PUSH2 0x05b7 1BA3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1B68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B71 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B76 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1B9C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 // @1B9F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_1BA4: // Incoming return from call to 0x232B at 0x2A90 // Incoming jump from 0x1B5C, if !stack[-5] // Incoming return from call to 0x2371 at 0x2D1C // Incoming return from call to 0x2371 at 0x23A3 // Incoming return from call to 0x23E9 at 0x2427 // Inputs[3] // { // @1BA5 stack[-1] // @1BA5 stack[-5] // @1BA6 stack[-4] // } 1BA4 5B JUMPDEST 1BA5 93 SWAP4 1BA6 92 SWAP3 1BA7 50 POP 1BA8 50 POP 1BA9 50 POP 1BAA 56 *JUMP // Stack delta = -4 // Outputs[1] { @1BA5 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1BAB: // Incoming jump from 0x1466 // Inputs[1] { @1BB4 stack[-4] } 1BAB 5B JUMPDEST 1BAC 60 PUSH1 0x01 1BAE 60 PUSH1 0x01 1BB0 60 PUSH1 0xa0 1BB2 1B SHL 1BB3 03 SUB 1BB4 84 DUP5 1BB5 16 AND 1BB6 61 PUSH2 0x1c27 1BB9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c27, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1BBA: // Incoming jump from 0x1BB9, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1BBC memory[0x40:0x60] } 1BBA 60 PUSH1 0x40 1BBC 51 MLOAD 1BBD 62 PUSH3 0x461bcd 1BC1 60 PUSH1 0xe5 1BC3 1B SHL 1BC4 81 DUP2 1BC5 52 MSTORE 1BC6 60 PUSH1 0x20 1BC8 60 PUSH1 0x04 1BCA 82 DUP3 1BCB 01 ADD 1BCC 52 MSTORE 1BCD 60 PUSH1 0x21 1BCF 60 PUSH1 0x24 1BD1 82 DUP3 1BD2 01 ADD 1BD3 52 MSTORE 1BD4 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 1BF5 60 PUSH1 0x44 1BF7 82 DUP3 1BF8 01 ADD 1BF9 52 MSTORE 1BFA 7F PUSH32 0x7300000000000000000000000000000000000000000000000000000000000000 1C1B 60 PUSH1 0x64 1C1D 82 DUP3 1C1E 01 ADD 1C1F 52 MSTORE 1C20 60 PUSH1 0x84 1C22 01 ADD 1C23 61 PUSH2 0x05b7 1C26 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1BC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1BCC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1BD3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @1BF9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @1C1F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7300000000000000000000000000000000000000000000000000000000000000 // @1C22 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_1C27: // Incoming jump from 0x1BB9, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1C28 msg.sender // @1C2F stack[-4] // @1C33 stack[-3] // } 1C27 5B JUMPDEST 1C28 33 CALLER 1C29 61 PUSH2 0x1c38 1C2C 81 DUP2 1C2D 60 PUSH1 0x00 1C2F 87 DUP8 1C30 61 PUSH2 0x15f0 1C33 88 DUP9 1C34 61 PUSH2 0x1f12 1C37 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1C28 stack[0] = msg.sender // @1C29 stack[1] = 0x1c38 // @1C2C stack[2] = msg.sender // @1C2D stack[3] = 0x00 // @1C2F stack[4] = stack[-4] // @1C30 stack[5] = 0x15f0 // @1C33 stack[6] = stack[-3] // } // Block ends with call to 0x1f12, returns to 0x15F0 label_1C38: // Incoming return from call to 0x15F0 at 0x1C37 // Inputs[6] // { // @1C3B stack[-4] // @1C47 memory[0x00:0x40] // @1C50 stack[-5] // @1C58 memory[0x00:0x40] // @1C5A storage[keccak256(memory[0x00:0x40])] // @1C5B stack[-3] // } 1C38 5B JUMPDEST 1C39 60 PUSH1 0x00 1C3B 84 DUP5 1C3C 81 DUP2 1C3D 52 MSTORE 1C3E 60 PUSH1 0x20 1C40 81 DUP2 1C41 81 DUP2 1C42 52 MSTORE 1C43 60 PUSH1 0x40 1C45 80 DUP1 1C46 83 DUP4 1C47 20 SHA3 1C48 60 PUSH1 0x01 1C4A 60 PUSH1 0x01 1C4C 60 PUSH1 0xa0 1C4E 1B SHL 1C4F 03 SUB 1C50 89 DUP10 1C51 16 AND 1C52 84 DUP5 1C53 52 MSTORE 1C54 90 SWAP1 1C55 91 SWAP2 1C56 52 MSTORE 1C57 81 DUP2 1C58 20 SHA3 1C59 80 DUP1 1C5A 54 SLOAD 1C5B 85 DUP6 1C5C 92 SWAP3 1C5D 90 SWAP1 1C5E 61 PUSH2 0x1c68 1C61 90 SWAP1 1C62 84 DUP5 1C63 90 SWAP1 1C64 61 PUSH2 0x2bc4 1C67 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @1C3D memory[0x00:0x20] = stack[-4] // @1C42 memory[0x20:0x40] = 0x00 // @1C53 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1C56 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1C58 stack[1] = keccak256(memory[0x00:0x40]) // @1C5C stack[0] = stack[-3] // @1C5D stack[2] = 0x00 // @1C61 stack[3] = 0x1c68 // @1C63 stack[4] = stack[-3] // @1C63 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2bc4, returns to 0x1C68 label_1C68: // Incoming return from call to 0x2BC4 at 0x1C67 // Inputs[11] // { // @1C69 stack[-2] // @1C69 stack[-1] // @1C6A stack[-3] // @1C71 memory[0x40:0x60] // @1C72 stack[-8] // @1C79 stack[-7] // @1C85 stack[-9] // @1C8C stack[-5] // @1CB4 memory[0x40:0x60] // @1CB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1CC3 stack[-6] // } 1C68 5B JUMPDEST 1C69 90 SWAP1 1C6A 91 SWAP2 1C6B 55 SSTORE 1C6C 50 POP 1C6D 50 POP 1C6E 60 PUSH1 0x40 1C70 80 DUP1 1C71 51 MLOAD 1C72 85 DUP6 1C73 81 DUP2 1C74 52 MSTORE 1C75 60 PUSH1 0x20 1C77 81 DUP2 1C78 01 ADD 1C79 85 DUP6 1C7A 90 SWAP1 1C7B 52 MSTORE 1C7C 60 PUSH1 0x01 1C7E 60 PUSH1 0x01 1C80 60 PUSH1 0xa0 1C82 1B SHL 1C83 03 SUB 1C84 80 DUP1 1C85 88 DUP9 1C86 16 AND 1C87 92 SWAP3 1C88 60 PUSH1 0x00 1C8A 92 SWAP3 1C8B 91 SWAP2 1C8C 85 DUP6 1C8D 16 AND 1C8E 91 SWAP2 1C8F 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1CB0 91 SWAP2 1CB1 01 ADD 1CB2 60 PUSH1 0x40 1CB4 51 MLOAD 1CB5 80 DUP1 1CB6 91 SWAP2 1CB7 03 SUB 1CB8 90 SWAP1 1CB9 A4 LOG4 1CBA 61 PUSH2 0x0795 1CBD 81 DUP2 1CBE 60 PUSH1 0x00 1CC0 87 DUP8 1CC1 87 DUP8 1CC2 87 DUP8 1CC3 87 DUP8 1CC4 61 PUSH2 0x1f5d 1CC7 56 *JUMP // Stack delta = +3 // Outputs[11] // { // @1C6B storage[stack[-3]] = stack[-1] // @1C74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-8] // @1C7B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-7] // @1CB9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, stack[-5] & (0x01 << 0xa0) - 0x01, 0x00, stack[-9] & (0x01 << 0xa0) - 0x01]); // @1CBA stack[-4] = 0x0795 // @1CBD stack[-3] = stack[-5] // @1CBE stack[-2] = 0x00 // @1CC0 stack[-1] = stack[-9] // @1CC1 stack[0] = stack[-8] // @1CC2 stack[1] = stack[-7] // @1CC3 stack[2] = stack[-6] // } // Block ends with call to 0x1f5d, returns to 0x0795 label_1CC8: // Incoming call from 0x149A, returns to 0x149B // Inputs[1] { @1CD1 stack[-3] } 1CC8 5B JUMPDEST 1CC9 60 PUSH1 0x01 1CCB 60 PUSH1 0x01 1CCD 60 PUSH1 0xa0 1CCF 1B SHL 1CD0 03 SUB 1CD1 83 DUP4 1CD2 16 AND 1CD3 61 PUSH2 0x1d2a 1CD6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d2a, if stack[-3] & (0x01 << 0xa0) - 0x01 label_1CD7: // Incoming jump from 0x1CD6, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1CD9 memory[0x40:0x60] } 1CD7 60 PUSH1 0x40 1CD9 51 MLOAD 1CDA 62 PUSH3 0x461bcd 1CDE 60 PUSH1 0xe5 1CE0 1B SHL 1CE1 81 DUP2 1CE2 52 MSTORE 1CE3 60 PUSH1 0x20 1CE5 60 PUSH1 0x04 1CE7 82 DUP3 1CE8 01 ADD 1CE9 52 MSTORE 1CEA 60 PUSH1 0x23 1CEC 60 PUSH1 0x24 1CEE 82 DUP3 1CEF 01 ADD 1CF0 52 MSTORE 1CF1 7F PUSH32 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 1D12 60 PUSH1 0x44 1D14 82 DUP3 1D15 01 ADD 1D16 52 MSTORE 1D17 62 PUSH3 0x657373 1D1B 60 PUSH1 0xe8 1D1D 1B SHL 1D1E 60 PUSH1 0x64 1D20 82 DUP3 1D21 01 ADD 1D22 52 MSTORE 1D23 60 PUSH1 0x84 1D25 01 ADD 1D26 61 PUSH2 0x05b7 1D29 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1CE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1CE9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1CF0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @1D16 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 // @1D22 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x657373 << 0xe8 // @1D25 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_1D2A: // Incoming jump from 0x1CD6, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1D2B stack[-1] // @1D2C memory[stack[-1]:stack[-1] + 0x20] // @1D2D stack[-2] // @1D2E memory[stack[-2]:stack[-2] + 0x20] // } 1D2A 5B JUMPDEST 1D2B 80 DUP1 1D2C 51 MLOAD 1D2D 82 DUP3 1D2E 51 MLOAD 1D2F 14 EQ 1D30 61 PUSH2 0x1da1 1D33 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1da1, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_1D34: // Incoming jump from 0x1D33, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @1D36 memory[0x40:0x60] } 1D34 60 PUSH1 0x40 1D36 51 MLOAD 1D37 62 PUSH3 0x461bcd 1D3B 60 PUSH1 0xe5 1D3D 1B SHL 1D3E 81 DUP2 1D3F 52 MSTORE 1D40 60 PUSH1 0x20 1D42 60 PUSH1 0x04 1D44 82 DUP3 1D45 01 ADD 1D46 52 MSTORE 1D47 60 PUSH1 0x28 1D49 60 PUSH1 0x24 1D4B 82 DUP3 1D4C 01 ADD 1D4D 52 MSTORE 1D4E 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 1D6F 60 PUSH1 0x44 1D71 82 DUP3 1D72 01 ADD 1D73 52 MSTORE 1D74 7F PUSH32 0x6d69736d61746368000000000000000000000000000000000000000000000000 1D95 60 PUSH1 0x64 1D97 82 DUP3 1D98 01 ADD 1D99 52 MSTORE 1D9A 60 PUSH1 0x84 1D9C 01 ADD 1D9D 61 PUSH2 0x05b7 1DA0 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1D3F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D46 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D4D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @1D73 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 // @1D99 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6d69736d61746368000000000000000000000000000000000000000000000000 // @1D9C stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_1DA1: // Incoming jump from 0x1D33, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[4] // { // @1DA5 memory[0x40:0x60] // @1DB3 msg.sender // @1DB6 stack[-2] // @1DB7 memory[stack[-2]:stack[-2] + 0x20] // } 1DA1 5B JUMPDEST 1DA2 60 PUSH1 0x40 1DA4 80 DUP1 1DA5 51 MLOAD 1DA6 60 PUSH1 0x20 1DA8 81 DUP2 1DA9 01 ADD 1DAA 90 SWAP1 1DAB 91 SWAP2 1DAC 52 MSTORE 1DAD 60 PUSH1 0x00 1DAF 90 SWAP1 1DB0 81 DUP2 1DB1 90 SWAP1 1DB2 52 MSTORE 1DB3 33 CALLER 1DB4 90 SWAP1 1DB5 5B JUMPDEST 1DB6 83 DUP4 1DB7 51 MLOAD 1DB8 81 DUP2 1DB9 10 LT 1DBA 15 ISZERO 1DBB 61 PUSH2 0x1eb3 1DBE 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1DAC memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1DB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1DB4 stack[0] = msg.sender // @1DB4 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1eb3, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1DBF: // Incoming jump from 0x1DBE, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1DBE, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @1DC1 stack[-4] // @1DC2 stack[-1] // @1DC4 memory[stack[-4]:stack[-4] + 0x20] // } 1DBF 60 PUSH1 0x00 1DC1 84 DUP5 1DC2 82 DUP3 1DC3 81 DUP2 1DC4 51 MLOAD 1DC5 81 DUP2 1DC6 10 LT 1DC7 61 PUSH2 0x1dd2 1DCA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1DBF stack[0] = 0x00 // @1DC1 stack[1] = stack[-4] // @1DC2 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1dd2, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_1DCB: // Incoming jump from 0x1DCA, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 1DCB 61 PUSH2 0x1dd2 1DCE 61 PUSH2 0x2b93 1DD1 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DCB stack[0] = 0x1dd2 } // Block ends with unconditional jump to 0x2b93 label_1DD2: // Incoming jump from 0x1DCA, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @1DD5 stack[-1] // @1DD9 stack[-2] // @1DDA memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1DDB stack[-3] // @1DDF stack[-6] // @1DE0 stack[-4] // @1DE2 memory[stack[-6]:stack[-6] + 0x20] // } 1DD2 5B JUMPDEST 1DD3 60 PUSH1 0x20 1DD5 02 MUL 1DD6 60 PUSH1 0x20 1DD8 01 ADD 1DD9 01 ADD 1DDA 51 MLOAD 1DDB 90 SWAP1 1DDC 50 POP 1DDD 60 PUSH1 0x00 1DDF 84 DUP5 1DE0 83 DUP4 1DE1 81 DUP2 1DE2 51 MLOAD 1DE3 81 DUP2 1DE4 10 LT 1DE5 61 PUSH2 0x1df0 1DE8 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1DDB stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1DDD stack[-2] = 0x00 // @1DDF stack[-1] = stack[-6] // @1DE0 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x1df0, if stack[-4] < memory[stack[-6]:stack[-6] + 0x20] label_1DE9: // Incoming jump from 0x1DE8, if not stack[-4] < memory[stack[-6]:stack[-6] + 0x20] 1DE9 61 PUSH2 0x1df0 1DEC 61 PUSH2 0x2b93 1DEF 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DE9 stack[0] = 0x1df0 } // Block ends with unconditional jump to 0x2b93 label_1DF0: // Incoming jump from 0x1DE8, if stack[-4] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[9] // { // @1DF3 stack[-1] // @1DF6 stack[-2] // @1DFC memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1DFF stack[-4] // @1E09 memory[0x00:0x40] // @1E12 stack[-9] // @1E1C memory[0x00:0x40] // @1E1D storage[keccak256(memory[0x00:0x40])] // @1E1F stack[-3] // } 1DF0 5B JUMPDEST 1DF1 60 PUSH1 0x20 1DF3 90 SWAP1 1DF4 81 DUP2 1DF5 02 MUL 1DF6 91 SWAP2 1DF7 90 SWAP1 1DF8 91 SWAP2 1DF9 01 ADD 1DFA 81 DUP2 1DFB 01 ADD 1DFC 51 MLOAD 1DFD 60 PUSH1 0x00 1DFF 84 DUP5 1E00 81 DUP2 1E01 52 MSTORE 1E02 80 DUP1 1E03 83 DUP4 1E04 52 MSTORE 1E05 60 PUSH1 0x40 1E07 80 DUP1 1E08 82 DUP3 1E09 20 SHA3 1E0A 60 PUSH1 0x01 1E0C 60 PUSH1 0x01 1E0E 60 PUSH1 0xa0 1E10 1B SHL 1E11 03 SUB 1E12 8C DUP13 1E13 16 AND 1E14 83 DUP4 1E15 52 MSTORE 1E16 90 SWAP1 1E17 93 SWAP4 1E18 52 MSTORE 1E19 91 SWAP2 1E1A 90 SWAP1 1E1B 91 SWAP2 1E1C 20 SHA3 1E1D 54 SLOAD 1E1E 90 SWAP1 1E1F 91 SWAP2 1E20 50 POP 1E21 81 DUP2 1E22 81 DUP2 1E23 10 LT 1E24 15 ISZERO 1E25 61 PUSH2 0x1e7c 1E28 57 *JUMPI // Stack delta = -1 // Outputs[6] // { // @1E01 memory[0x00:0x20] = stack[-4] // @1E04 memory[0x20:0x40] = 0x00 // @1E15 memory[0x00:0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @1E18 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1E1E stack[-2] = storage[keccak256(memory[0x00:0x40])] // @1E1F stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1e7c, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) label_1E29: // Incoming jump from 0x1E28, if not !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[1] { @1E2B memory[0x40:0x60] } 1E29 60 PUSH1 0x40 1E2B 51 MLOAD 1E2C 62 PUSH3 0x461bcd 1E30 60 PUSH1 0xe5 1E32 1B SHL 1E33 81 DUP2 1E34 52 MSTORE 1E35 60 PUSH1 0x20 1E37 60 PUSH1 0x04 1E39 82 DUP3 1E3A 01 ADD 1E3B 52 MSTORE 1E3C 60 PUSH1 0x24 1E3E 80 DUP1 1E3F 82 DUP3 1E40 01 ADD 1E41 52 MSTORE 1E42 7F PUSH32 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c 1E63 60 PUSH1 0x44 1E65 82 DUP3 1E66 01 ADD 1E67 52 MSTORE 1E68 63 PUSH4 0x616e6365 1E6D 60 PUSH1 0xe0 1E6F 1B SHL 1E70 60 PUSH1 0x64 1E72 82 DUP3 1E73 01 ADD 1E74 52 MSTORE 1E75 60 PUSH1 0x84 1E77 01 ADD 1E78 61 PUSH2 0x05b7 1E7B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1E34 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E3B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E41 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @1E67 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c // @1E74 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616e6365 << 0xe0 // @1E77 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_1E7C: // Incoming jump from 0x1E28, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[7] // { // @1E7F stack[-3] // @1E8B memory[0x00:0x40] // @1E94 stack[-8] // @1E9B stack[-1] // @1E9D memory[0x00:0x40] // @1E9F stack[-2] // @1EA2 stack[-4] // } 1E7C 5B JUMPDEST 1E7D 60 PUSH1 0x00 1E7F 92 SWAP3 1E80 83 DUP4 1E81 52 MSTORE 1E82 60 PUSH1 0x20 1E84 83 DUP4 1E85 81 DUP2 1E86 52 MSTORE 1E87 60 PUSH1 0x40 1E89 80 DUP1 1E8A 85 DUP6 1E8B 20 SHA3 1E8C 60 PUSH1 0x01 1E8E 60 PUSH1 0x01 1E90 60 PUSH1 0xa0 1E92 1B SHL 1E93 03 SUB 1E94 8B DUP12 1E95 16 AND 1E96 86 DUP7 1E97 52 MSTORE 1E98 90 SWAP1 1E99 91 SWAP2 1E9A 52 MSTORE 1E9B 90 SWAP1 1E9C 92 SWAP3 1E9D 20 SHA3 1E9E 91 SWAP2 1E9F 03 SUB 1EA0 90 SWAP1 1EA1 55 SSTORE 1EA2 80 DUP1 1EA3 61 PUSH2 0x1eab 1EA6 81 DUP2 1EA7 61 PUSH2 0x2ba9 1EAA 56 *JUMP // Stack delta = +0 // Outputs[8] // { // @1E81 memory[0x00:0x20] = stack[-3] // @1E86 memory[0x20:0x40] = 0x00 // @1E97 memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1E9A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1EA1 storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-2] // @1EA2 stack[-3] = stack[-4] // @1EA3 stack[-2] = 0x1eab // @1EA6 stack[-1] = stack[-4] // } // Block ends with call to 0x2ba9, returns to 0x1EAB label_1EAB: // Incoming return from call to 0x2BA9 at 0x1EAA // Inputs[2] // { // @1EAC stack[-3] // @1EAC stack[-1] // } 1EAB 5B JUMPDEST 1EAC 91 SWAP2 1EAD 50 POP 1EAE 50 POP 1EAF 61 PUSH2 0x1db5 1EB2 56 *JUMP // Stack delta = -2 // Outputs[1] { @1EAC stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1db5 label_1EB3: // Incoming jump from 0x1DBE, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1DBE, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[5] // { // @1EC0 stack[-5] // @1ECA stack[-2] // @1EF5 stack[-4] // @1EF6 stack[-3] // @1EF9 memory[0x40:0x60] // } 1EB3 5B JUMPDEST 1EB4 50 POP 1EB5 60 PUSH1 0x00 1EB7 60 PUSH1 0x01 1EB9 60 PUSH1 0x01 1EBB 60 PUSH1 0xa0 1EBD 1B SHL 1EBE 03 SUB 1EBF 16 AND 1EC0 84 DUP5 1EC1 60 PUSH1 0x01 1EC3 60 PUSH1 0x01 1EC5 60 PUSH1 0xa0 1EC7 1B SHL 1EC8 03 SUB 1EC9 16 AND 1ECA 82 DUP3 1ECB 60 PUSH1 0x01 1ECD 60 PUSH1 0x01 1ECF 60 PUSH1 0xa0 1ED1 1B SHL 1ED2 03 SUB 1ED3 16 AND 1ED4 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1EF5 86 DUP7 1EF6 86 DUP7 1EF7 60 PUSH1 0x40 1EF9 51 MLOAD 1EFA 61 PUSH2 0x1f04 1EFD 92 SWAP3 1EFE 91 SWAP2 1EFF 90 SWAP1 1F00 61 PUSH2 0x2bdc 1F03 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @1EBF stack[-1] = (0x01 << 0xa0) - 0x01 & 0x00 // @1EC9 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1ED3 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1ED4 stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @1EFD stack[3] = 0x1f04 // @1EFE stack[4] = stack[-4] // @1EFF stack[6] = memory[0x40:0x60] // @1EFF stack[5] = stack[-3] // } // Block ends with call to 0x2bdc, returns to 0x1F04 label_1F04: // Incoming return from call to 0x2BDC at 0x1F03 // Inputs[8] // { // @1F07 memory[0x40:0x60] // @1F09 stack[-1] // @1F0C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1F0C stack[-3] // @1F0C stack[-4] // @1F0C stack[-2] // @1F0C stack[-5] // @1F11 stack[-10] // } 1F04 5B JUMPDEST 1F05 60 PUSH1 0x40 1F07 51 MLOAD 1F08 80 DUP1 1F09 91 SWAP2 1F0A 03 SUB 1F0B 90 SWAP1 1F0C A4 LOG4 1F0D 50 POP 1F0E 50 POP 1F0F 50 POP 1F10 50 POP 1F11 56 *JUMP // Stack delta = -10 // Outputs[1] { @1F0C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); } // Block ends with unconditional jump to stack[-10] label_1F12: // Incoming call from 0x1C37, returns to 0x15F0 // Incoming call from 0x20F8, returns to 0x20F9 // Incoming call from 0x15F8, returns to 0x0795 // Incoming call from 0x20EF, returns to 0x20F0 // Inputs[5] // { // @1F16 memory[0x40:0x60] // @1F30 msg.data.length // @1F32 msg.data[msg.data.length:msg.data.length + 0x20] // @1F39 stack[-1] // @1F3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1F12 5B JUMPDEST 1F13 60 PUSH1 0x40 1F15 80 DUP1 1F16 51 MLOAD 1F17 60 PUSH1 0x01 1F19 80 DUP1 1F1A 82 DUP3 1F1B 52 MSTORE 1F1C 81 DUP2 1F1D 83 DUP4 1F1E 01 ADD 1F1F 90 SWAP1 1F20 92 SWAP3 1F21 52 MSTORE 1F22 60 PUSH1 0x60 1F24 91 SWAP2 1F25 60 PUSH1 0x00 1F27 91 SWAP2 1F28 90 SWAP1 1F29 60 PUSH1 0x20 1F2B 80 DUP1 1F2C 83 DUP4 1F2D 01 ADD 1F2E 90 SWAP1 1F2F 80 DUP1 1F30 36 CALLDATASIZE 1F31 83 DUP4 1F32 37 CALLDATACOPY 1F33 01 ADD 1F34 90 SWAP1 1F35 50 POP 1F36 50 POP 1F37 90 SWAP1 1F38 50 POP 1F39 82 DUP3 1F3A 81 DUP2 1F3B 60 PUSH1 0x00 1F3D 81 DUP2 1F3E 51 MLOAD 1F3F 81 DUP2 1F40 10 LT 1F41 61 PUSH2 0x1f4c 1F44 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @1F1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1F21 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1F24 stack[0] = 0x60 // @1F32 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[msg.data.length:msg.data.length + 0x20] // @1F37 stack[1] = memory[0x40:0x60] // @1F39 stack[2] = stack[-1] // @1F3A stack[3] = memory[0x40:0x60] // @1F3B stack[4] = 0x00 // } // Block ends with conditional jump to 0x1f4c, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_1F45: // Incoming jump from 0x1F44, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] 1F45 61 PUSH2 0x1f4c 1F48 61 PUSH2 0x2b93 1F4B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F45 stack[0] = 0x1f4c } // Block ends with unconditional jump to 0x2b93 label_1F4C: // Incoming jump from 0x1F44, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[6] // { // @1F4F stack[-1] // @1F52 stack[-2] // @1F57 stack[-3] // @1F58 stack[-4] // @1F58 stack[-7] // @1F59 stack[-6] // } 1F4C 5B JUMPDEST 1F4D 60 PUSH1 0x20 1F4F 90 SWAP1 1F50 81 DUP2 1F51 02 MUL 1F52 91 SWAP2 1F53 90 SWAP1 1F54 91 SWAP2 1F55 01 ADD 1F56 01 ADD 1F57 52 MSTORE 1F58 92 SWAP3 1F59 91 SWAP2 1F5A 50 POP 1F5B 50 POP 1F5C 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1F57 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @1F58 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1F5D: // Incoming call from 0x1CC7, returns to 0x0795 // Inputs[2] // { // @1F66 stack[-4] // @1F68 address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 1F5D 5B JUMPDEST 1F5E 60 PUSH1 0x01 1F60 60 PUSH1 0x01 1F62 60 PUSH1 0xa0 1F64 1B SHL 1F65 03 SUB 1F66 84 DUP5 1F67 16 AND 1F68 3B EXTCODESIZE 1F69 15 ISZERO 1F6A 61 PUSH2 0x0c35 1F6D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c35, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_1F6E: // Incoming jump from 0x1F6D, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[7] // { // @1F70 memory[0x40:0x60] // @1F83 stack[-4] // @1F90 stack[-6] // @1F92 stack[-5] // @1F94 stack[-3] // @1F96 stack[-2] // @1F98 stack[-1] // } 1F6E 60 PUSH1 0x40 1F70 51 MLOAD 1F71 63 PUSH4 0xf23a6e61 1F76 60 PUSH1 0xe0 1F78 1B SHL 1F79 81 DUP2 1F7A 52 MSTORE 1F7B 60 PUSH1 0x01 1F7D 60 PUSH1 0x01 1F7F 60 PUSH1 0xa0 1F81 1B SHL 1F82 03 SUB 1F83 85 DUP6 1F84 16 AND 1F85 90 SWAP1 1F86 63 PUSH4 0xf23a6e61 1F8B 90 SWAP1 1F8C 61 PUSH2 0x1fa1 1F8F 90 SWAP1 1F90 89 DUP10 1F91 90 SWAP1 1F92 89 DUP10 1F93 90 SWAP1 1F94 88 DUP9 1F95 90 SWAP1 1F96 88 DUP9 1F97 90 SWAP1 1F98 88 DUP9 1F99 90 SWAP1 1F9A 60 PUSH1 0x04 1F9C 01 ADD 1F9D 61 PUSH2 0x2dda 1FA0 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1F7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf23a6e61 << 0xe0 // @1F85 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1F8B stack[1] = 0xf23a6e61 // @1F8F stack[2] = 0x1fa1 // @1F91 stack[3] = stack[-6] // @1F93 stack[4] = stack[-5] // @1F95 stack[5] = stack[-3] // @1F97 stack[6] = stack[-2] // @1F99 stack[7] = stack[-1] // @1F9C stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2dda, returns to 0x1FA1 label_1FA1: // Incoming return from call to 0x2DDA at 0x1FA0 // Inputs[4] // { // @1FA6 memory[0x40:0x60] // @1FA8 stack[-1] // @1FAD stack[-3] // @1FAF address(stack[-3]).code.length // } 1FA1 5B JUMPDEST 1FA2 60 PUSH1 0x20 1FA4 60 PUSH1 0x40 1FA6 51 MLOAD 1FA7 80 DUP1 1FA8 83 DUP4 1FA9 03 SUB 1FAA 81 DUP2 1FAB 60 PUSH1 0x00 1FAD 87 DUP8 1FAE 80 DUP1 1FAF 3B EXTCODESIZE 1FB0 15 ISZERO 1FB1 80 DUP1 1FB2 15 ISZERO 1FB3 61 PUSH2 0x1fbb 1FB6 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1FA2 stack[0] = 0x20 // @1FA6 stack[1] = memory[0x40:0x60] // @1FA9 stack[2] = stack[-1] - memory[0x40:0x60] // @1FAA stack[3] = memory[0x40:0x60] // @1FAB stack[4] = 0x00 // @1FAD stack[5] = stack[-3] // @1FB0 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1fbb, if !!address(stack[-3]).code.length label_1FB7: // Incoming jump from 0x1FB6, if not !!address(stack[-3]).code.length // Inputs[1] { @1FBA memory[0x00:0x00] } 1FB7 60 PUSH1 0x00 1FB9 80 DUP1 1FBA FD *REVERT // Stack delta = +0 // Outputs[1] { @1FBA revert(memory[0x00:0x00]); } // Block terminates label_1FBB: // Incoming jump from 0x1FB6, if !!address(stack[-3]).code.length // Inputs[10] // { // @1FBD msg.gas // @1FBE address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1FBE stack[-2] // @1FBE stack[-5] // @1FBE memory[stack[-4]:stack[-4] + stack[-5]] // @1FBE stack[-4] // @1FBE stack[-7] // @1FBE stack[-6] // @1FBE stack[-3] // @1FBF stack[-10] // } 1FBB 5B JUMPDEST 1FBC 50 POP 1FBD 5A GAS 1FBE F1 CALL 1FBF 92 SWAP3 1FC0 50 POP 1FC1 50 POP 1FC2 50 POP 1FC3 80 DUP1 1FC4 15 ISZERO 1FC5 61 PUSH2 0x1feb 1FC8 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1FBE memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1FBF 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 0x1feb, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1FC9: // Incoming jump from 0x1FC8, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1FCD memory[0x40:0x60] // @1FD0 returndata.length // } 1FC9 50 POP 1FCA 60 PUSH1 0x40 1FCC 80 DUP1 1FCD 51 MLOAD 1FCE 60 PUSH1 0x1f 1FD0 3D RETURNDATASIZE 1FD1 90 SWAP1 1FD2 81 DUP2 1FD3 01 ADD 1FD4 60 PUSH1 0x1f 1FD6 19 NOT 1FD7 16 AND 1FD8 82 DUP3 1FD9 01 ADD 1FDA 90 SWAP1 1FDB 92 SWAP3 1FDC 52 MSTORE 1FDD 61 PUSH2 0x1fe8 1FE0 91 SWAP2 1FE1 81 DUP2 1FE2 01 ADD 1FE3 90 SWAP1 1FE4 61 PUSH2 0x2d00 1FE7 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1FDC memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1FE0 stack[-1] = 0x1fe8 // @1FE3 stack[1] = memory[0x40:0x60] // @1FE3 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2d00 1FE8 5B JUMPDEST 1FE9 60 PUSH1 0x01 label_1FEB: // Incoming jump from 0x1FC8, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1FEF stack[-1] } 1FEB 5B JUMPDEST 1FEC 61 PUSH2 0x1ff7 1FEF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1ff7, if stack[-1] label_1FF0: // Incoming jump from 0x1FEF, if not stack[-1] 1FF0 61 PUSH2 0x184b 1FF3 61 PUSH2 0x2d1d 1FF6 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FF0 stack[0] = 0x184b } // Block ends with call to 0x2d1d, returns to 0x184B label_1FF7: // Incoming jump from 0x1FEF, if stack[-1] // Inputs[1] { @2001 stack[-1] } 1FF7 5B JUMPDEST 1FF8 60 PUSH1 0x01 1FFA 60 PUSH1 0x01 1FFC 60 PUSH1 0xe0 1FFE 1B SHL 1FFF 03 SUB 2000 19 NOT 2001 81 DUP2 2002 16 AND 2003 63 PUSH4 0xf23a6e61 2008 60 PUSH1 0xe0 200A 1B SHL 200B 14 EQ 200C 61 PUSH2 0x0a0b 200F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a0b, if 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2010: // Incoming jump from 0x200F, if not 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2012 memory[0x40:0x60] } 2010 60 PUSH1 0x40 2012 51 MLOAD 2013 62 PUSH3 0x461bcd 2017 60 PUSH1 0xe5 2019 1B SHL 201A 81 DUP2 201B 52 MSTORE 201C 60 PUSH1 0x20 201E 60 PUSH1 0x04 2020 82 DUP3 2021 01 ADD 2022 52 MSTORE 2023 60 PUSH1 0x28 2025 60 PUSH1 0x24 2027 82 DUP3 2028 01 ADD 2029 52 MSTORE 202A 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 204B 60 PUSH1 0x44 204D 82 DUP3 204E 01 ADD 204F 52 MSTORE 2050 7F PUSH32 0x6420746f6b656e73000000000000000000000000000000000000000000000000 2071 60 PUSH1 0x64 2073 82 DUP3 2074 01 ADD 2075 52 MSTORE 2076 60 PUSH1 0x84 2078 01 ADD 2079 61 PUSH2 0x05b7 207C 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @201B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2022 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2029 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @204F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @2075 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6420746f6b656e73000000000000000000000000000000000000000000000000 // @2078 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_207D: // Incoming call from 0x1737, returns to 0x1738 // Inputs[1] { @2086 stack[-3] } 207D 5B JUMPDEST 207E 60 PUSH1 0x01 2080 60 PUSH1 0x01 2082 60 PUSH1 0xa0 2084 1B SHL 2085 03 SUB 2086 83 DUP4 2087 16 AND 2088 61 PUSH2 0x20df 208B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20df, if stack[-3] & (0x01 << 0xa0) - 0x01 label_208C: // Incoming jump from 0x208B, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @208E memory[0x40:0x60] } 208C 60 PUSH1 0x40 208E 51 MLOAD 208F 62 PUSH3 0x461bcd 2093 60 PUSH1 0xe5 2095 1B SHL 2096 81 DUP2 2097 52 MSTORE 2098 60 PUSH1 0x20 209A 60 PUSH1 0x04 209C 82 DUP3 209D 01 ADD 209E 52 MSTORE 209F 60 PUSH1 0x23 20A1 60 PUSH1 0x24 20A3 82 DUP3 20A4 01 ADD 20A5 52 MSTORE 20A6 7F PUSH32 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 20C7 60 PUSH1 0x44 20C9 82 DUP3 20CA 01 ADD 20CB 52 MSTORE 20CC 62 PUSH3 0x657373 20D0 60 PUSH1 0xe8 20D2 1B SHL 20D3 60 PUSH1 0x64 20D5 82 DUP3 20D6 01 ADD 20D7 52 MSTORE 20D8 60 PUSH1 0x84 20DA 01 ADD 20DB 61 PUSH2 0x05b7 20DE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2097 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @209E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @20A5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @20CB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 // @20D7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x657373 << 0xe8 // @20DA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_20DF: // Incoming jump from 0x208B, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @20E0 msg.sender // @20E5 stack[-3] // @20EB stack[-2] // } 20DF 5B JUMPDEST 20E0 33 CALLER 20E1 61 PUSH2 0x210f 20E4 81 DUP2 20E5 85 DUP6 20E6 60 PUSH1 0x00 20E8 61 PUSH2 0x20f0 20EB 87 DUP8 20EC 61 PUSH2 0x1f12 20EF 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @20E0 stack[0] = msg.sender // @20E1 stack[1] = 0x210f // @20E4 stack[2] = msg.sender // @20E5 stack[3] = stack[-3] // @20E6 stack[4] = 0x00 // @20E8 stack[5] = 0x20f0 // @20EB stack[6] = stack[-2] // } // Block ends with call to 0x1f12, returns to 0x20F0 label_20F0: // Incoming return from call to 0x1F12 at 0x20EF // Inputs[1] { @20F4 stack[-7] } 20F0 5B JUMPDEST 20F1 61 PUSH2 0x20f9 20F4 87 DUP8 20F5 61 PUSH2 0x1f12 20F8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20F1 stack[0] = 0x20f9 // @20F4 stack[1] = stack[-7] // } // Block ends with call to 0x1f12, returns to 0x20F9 label_20F9: // Incoming return from call to 0x1F12 at 0x20F8 // Inputs[2] // { // @20FF memory[0x40:0x60] // @210E stack[-6] // } 20F9 5B JUMPDEST 20FA 50 POP 20FB 50 POP 20FC 60 PUSH1 0x40 20FE 80 DUP1 20FF 51 MLOAD 2100 60 PUSH1 0x20 2102 81 DUP2 2103 01 ADD 2104 90 SWAP1 2105 91 SWAP2 2106 52 MSTORE 2107 60 PUSH1 0x00 2109 90 SWAP1 210A 52 MSTORE 210B 50 POP 210C 50 POP 210D 50 POP 210E 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @2106 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @210A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-6] label_210F: // Incoming return from call to 0x20F0 at 0x20EF // Inputs[6] // { // @2112 stack[-3] // @211E memory[0x00:0x40] // @2127 stack[-4] // @212F memory[0x00:0x40] // @2130 storage[keccak256(memory[0x00:0x40])] // @2131 stack[-2] // } 210F 5B JUMPDEST 2110 60 PUSH1 0x00 2112 83 DUP4 2113 81 DUP2 2114 52 MSTORE 2115 60 PUSH1 0x20 2117 81 DUP2 2118 81 DUP2 2119 52 MSTORE 211A 60 PUSH1 0x40 211C 80 DUP1 211D 83 DUP4 211E 20 SHA3 211F 60 PUSH1 0x01 2121 60 PUSH1 0x01 2123 60 PUSH1 0xa0 2125 1B SHL 2126 03 SUB 2127 88 DUP9 2128 16 AND 2129 84 DUP5 212A 52 MSTORE 212B 90 SWAP1 212C 91 SWAP2 212D 52 MSTORE 212E 90 SWAP1 212F 20 SHA3 2130 54 SLOAD 2131 82 DUP3 2132 81 DUP2 2133 10 LT 2134 15 ISZERO 2135 61 PUSH2 0x218c 2138 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2114 memory[0x00:0x20] = stack[-3] // @2119 memory[0x20:0x40] = 0x00 // @212A memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @212D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2130 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x218c, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) label_2139: // Incoming jump from 0x2138, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[1] { @213B memory[0x40:0x60] } 2139 60 PUSH1 0x40 213B 51 MLOAD 213C 62 PUSH3 0x461bcd 2140 60 PUSH1 0xe5 2142 1B SHL 2143 81 DUP2 2144 52 MSTORE 2145 60 PUSH1 0x20 2147 60 PUSH1 0x04 2149 82 DUP3 214A 01 ADD 214B 52 MSTORE 214C 60 PUSH1 0x24 214E 80 DUP1 214F 82 DUP3 2150 01 ADD 2151 52 MSTORE 2152 7F PUSH32 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c 2173 60 PUSH1 0x44 2175 82 DUP3 2176 01 ADD 2177 52 MSTORE 2178 63 PUSH4 0x616e6365 217D 60 PUSH1 0xe0 217F 1B SHL 2180 60 PUSH1 0x64 2182 82 DUP3 2183 01 ADD 2184 52 MSTORE 2185 60 PUSH1 0x84 2187 01 ADD 2188 61 PUSH2 0x05b7 218B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2144 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @214B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2151 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @2177 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c // @2184 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616e6365 << 0xe0 // @2187 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05b7 label_218C: // Incoming jump from 0x2138, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[11] // { // @218F stack[-4] // @219B memory[0x00:0x40] // @21A4 stack[-5] // @21AF memory[0x00:0x40] // @21B0 stack[-3] // @21B1 stack[-1] // @21B6 memory[0x40:0x60] // @21C3 stack[-2] // @21EB memory[0x40:0x60] // @21F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x40) - memory[0x40:0x60]] // @21F6 stack[-6] // } 218C 5B JUMPDEST 218D 60 PUSH1 0x00 218F 84 DUP5 2190 81 DUP2 2191 52 MSTORE 2192 60 PUSH1 0x20 2194 81 DUP2 2195 81 DUP2 2196 52 MSTORE 2197 60 PUSH1 0x40 2199 80 DUP1 219A 83 DUP4 219B 20 SHA3 219C 60 PUSH1 0x01 219E 60 PUSH1 0x01 21A0 60 PUSH1 0xa0 21A2 1B SHL 21A3 03 SUB 21A4 89 DUP10 21A5 81 DUP2 21A6 16 AND 21A7 80 DUP1 21A8 86 DUP7 21A9 52 MSTORE 21AA 91 SWAP2 21AB 84 DUP5 21AC 52 MSTORE 21AD 82 DUP3 21AE 85 DUP6 21AF 20 SHA3 21B0 88 DUP9 21B1 87 DUP8 21B2 03 SUB 21B3 90 SWAP1 21B4 55 SSTORE 21B5 82 DUP3 21B6 51 MLOAD 21B7 89 DUP10 21B8 81 DUP2 21B9 52 MSTORE 21BA 93 SWAP4 21BB 84 DUP5 21BC 01 ADD 21BD 88 DUP9 21BE 90 SWAP1 21BF 52 MSTORE 21C0 90 SWAP1 21C1 92 SWAP3 21C2 90 SWAP1 21C3 86 DUP7 21C4 16 AND 21C5 91 SWAP2 21C6 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 21E7 91 SWAP2 21E8 01 ADD 21E9 60 PUSH1 0x40 21EB 51 MLOAD 21EC 80 DUP1 21ED 91 SWAP2 21EE 03 SUB 21EF 90 SWAP1 21F0 A4 LOG4 21F1 50 POP 21F2 50 POP 21F3 50 POP 21F4 50 POP 21F5 50 POP 21F6 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @2191 memory[0x00:0x20] = stack[-4] // @2196 memory[0x20:0x40] = 0x00 // @21A9 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @21AC memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @21B4 storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-3] // @21B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @21BF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] // @21F0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x40) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, 0x00]); // } // Block ends with unconditional jump to stack[-6] label_21F7: // Incoming call from 0x17B0, returns to 0x05F1 // Inputs[1] { @2203 stack[-1] } 21F7 5B JUMPDEST 21F8 60 PUSH1 0x00 21FA 60 PUSH1 0x01 21FC 60 PUSH1 0x01 21FE 60 PUSH1 0xe0 2200 1B SHL 2201 03 SUB 2202 19 NOT 2203 82 DUP3 2204 16 AND 2205 7F PUSH32 0xd9b67a2600000000000000000000000000000000000000000000000000000000 2226 14 EQ 2227 80 DUP1 2228 61 PUSH2 0x225a 222B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21F8 stack[0] = 0x00 // @2226 stack[1] = 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x225a, if 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_222C: // Incoming jump from 0x222B, if not 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2236 stack[-3] } 222C 50 POP 222D 60 PUSH1 0x01 222F 60 PUSH1 0x01 2231 60 PUSH1 0xe0 2233 1B SHL 2234 03 SUB 2235 19 NOT 2236 82 DUP3 2237 16 AND 2238 7F PUSH32 0x0e89341c00000000000000000000000000000000000000000000000000000000 2259 14 EQ 225A 5B JUMPDEST 225B 80 DUP1 225C 61 PUSH2 0x05f1 225F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2259 stack[-1] = 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x05f1, if 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_2260: // Incoming jump from 0x225F, if not stack[-1] // Incoming jump from 0x225F, if not 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @228B stack[-3] } 2260 50 POP 2261 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 2282 60 PUSH1 0x01 2284 60 PUSH1 0x01 2286 60 PUSH1 0xe0 2288 1B SHL 2289 03 SUB 228A 19 NOT 228B 83 DUP4 228C 16 AND 228D 14 EQ 228E 61 PUSH2 0x05f1 2291 56 *JUMP // Stack delta = +0 // Outputs[1] { @228D stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to 0x05f1 label_2292: // Incoming jump from 0x0B36 // Incoming jump from 0x1772 // Inputs[2] // { // @2293 stack[-3] // @2295 storage[stack[-3]] // } 2292 5B JUMPDEST 2293 82 DUP3 2294 80 DUP1 2295 54 SLOAD 2296 61 PUSH2 0x229e 2299 90 SWAP1 229A 61 PUSH2 0x2b01 229D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2293 stack[0] = stack[-3] // @2299 stack[1] = 0x229e // @2299 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2b01, returns to 0x229E label_229E: // Incoming return from call to 0x2B01 at 0x229D // Inputs[5] // { // @229F stack[-2] // @229F stack[-1] // @22A7 memory[0x00:0x20] // @22B2 stack[-4] // @22B3 stack[-3] // } 229E 5B JUMPDEST 229F 90 SWAP1 22A0 60 PUSH1 0x00 22A2 52 MSTORE 22A3 60 PUSH1 0x20 22A5 60 PUSH1 0x00 22A7 20 SHA3 22A8 90 SWAP1 22A9 60 PUSH1 0x1f 22AB 01 ADD 22AC 60 PUSH1 0x20 22AE 90 SWAP1 22AF 04 DIV 22B0 81 DUP2 22B1 01 ADD 22B2 92 SWAP3 22B3 82 DUP3 22B4 61 PUSH2 0x22c0 22B7 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @22A2 memory[0x00:0x20] = stack[-2] // @22A8 stack[-2] = keccak256(memory[0x00:0x20]) // @22B2 stack[-1] = stack[-4] // @22B2 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x22c0, if stack[-3] label_22B8: // Incoming jump from 0x22B7, if not stack[-3] // Inputs[1] { @22BA stack[-5] } 22B8 60 PUSH1 0x00 22BA 85 DUP6 22BB 55 SSTORE 22BC 61 PUSH2 0x2306 22BF 56 *JUMP // Stack delta = +0 // Outputs[1] { @22BB storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x2306 label_22C0: // Incoming jump from 0x22B7, if stack[-3] // Inputs[1] { @22C1 stack[-3] } 22C0 5B JUMPDEST 22C1 82 DUP3 22C2 60 PUSH1 0x1f 22C4 10 LT 22C5 61 PUSH2 0x22d9 22C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x22d9, if 0x1f < stack[-3] label_22C9: // Incoming jump from 0x22C8, if not 0x1f < stack[-3] // Inputs[4] // { // @22C9 stack[-1] // @22CA memory[stack[-1]:stack[-1] + 0x20] // @22CF stack[-3] // @22D3 stack[-5] // } 22C9 80 DUP1 22CA 51 MLOAD 22CB 60 PUSH1 0xff 22CD 19 NOT 22CE 16 AND 22CF 83 DUP4 22D0 80 DUP1 22D1 01 ADD 22D2 17 OR 22D3 85 DUP6 22D4 55 SSTORE 22D5 61 PUSH2 0x2306 22D8 56 *JUMP // Stack delta = +0 // Outputs[1] { @22D4 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x2306 label_22D9: // Incoming jump from 0x22C8, if 0x1f < stack[-3] // Inputs[2] // { // @22DA stack[-3] // @22E0 stack[-5] // } 22D9 5B JUMPDEST 22DA 82 DUP3 22DB 80 DUP1 22DC 01 ADD 22DD 60 PUSH1 0x01 22DF 01 ADD 22E0 85 DUP6 22E1 55 SSTORE 22E2 82 DUP3 22E3 15 ISZERO 22E4 61 PUSH2 0x2306 22E7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22E1 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2306, if !stack[-3] label_22E8: // Incoming jump from 0x22E7, if not !stack[-3] // Inputs[2] // { // @22E8 stack[-3] // @22E8 stack[-1] // } 22E8 91 SWAP2 22E9 82 DUP3 22EA 01 ADD 22EB 5B JUMPDEST 22EC 82 DUP3 22ED 81 DUP2 22EE 11 GT 22EF 15 ISZERO 22F0 61 PUSH2 0x2306 22F3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @22E8 stack[-3] = stack[-1] // @22EA stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2306, if !(stack[-1] + stack[-3] > stack[-1]) label_22F4: // Incoming jump from 0x22F3, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x22F3, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @22F4 stack[-3] // @22F5 memory[stack[-3]:stack[-3] + 0x20] // @22F6 stack[-2] // @22F8 stack[-1] // } 22F4 82 DUP3 22F5 51 MLOAD 22F6 82 DUP3 22F7 55 SSTORE 22F8 91 SWAP2 22F9 60 PUSH1 0x20 22FB 01 ADD 22FC 91 SWAP2 22FD 90 SWAP1 22FE 60 PUSH1 0x01 2300 01 ADD 2301 90 SWAP1 2302 61 PUSH2 0x22eb 2305 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @22F7 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @22FC stack[-3] = 0x20 + stack[-3] // @2301 stack[-2] = 0x01 + stack[-2] // @2301 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x22eb label_2306: // Incoming jump from 0x22F3, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x22BF // Incoming jump from 0x22E7, if !stack[-3] // Incoming jump from 0x22D8 // Incoming jump from 0x22F3, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @230B stack[-4] // @230C stack[-3] // } 2306 5B JUMPDEST 2307 50 POP 2308 61 PUSH2 0x2312 230B 92 SWAP3 230C 91 SWAP2 230D 50 POP 230E 61 PUSH2 0x2316 2311 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @230B stack[-4] = 0x2312 // @230C stack[-3] = stack[-4] // } // Block ends with call to 0x2316, returns to 0x2312 label_2312: // Incoming jump from 0x231F, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2316 at 0x2311 // Incoming jump from 0x231F, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @2314 stack[-2] // @2314 stack[-3] // } 2312 5B JUMPDEST 2313 50 POP 2314 90 SWAP1 2315 56 *JUMP // Stack delta = -2 // Outputs[1] { @2314 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2316: // Incoming call from 0x2311, returns to 0x2312 // Inputs[2] // { // @2318 stack[-1] // @2319 stack[-2] // } 2316 5B JUMPDEST 2317 5B JUMPDEST 2318 80 DUP1 2319 82 DUP3 231A 11 GT 231B 15 ISZERO 231C 61 PUSH2 0x2312 231F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2312, if !(stack[-2] > stack[-1]) label_2320: // Incoming jump from 0x231F, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x231F, if not !(stack[-2] > stack[-1]) // Inputs[1] { @2322 stack[-1] } 2320 60 PUSH1 0x00 2322 81 DUP2 2323 55 SSTORE 2324 60 PUSH1 0x01 2326 01 ADD 2327 61 PUSH2 0x2317 232A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2323 storage[stack[-1]] = 0x00 // @2326 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2317 label_232B: // Incoming call from 0x2A90, returns to 0x1BA4 // Incoming call from 0x2662, returns to 0x06F1 // Incoming call from 0x25C4, returns to 0x25C5 // Incoming call from 0x29C6, returns to 0x29C7 // Incoming call from 0x2A3F, returns to 0x2A40 // Incoming call from 0x26C2, returns to 0x26C3 // Incoming call from 0x2830, returns to 0x2831 // Incoming call from 0x2362, returns to 0x2363 // Incoming call from 0x28A5, returns to 0x28A6 // Incoming call from 0x2A02, returns to 0x2A03 // Incoming call from 0x2AAE, returns to 0x2AAF // Incoming call from 0x2A31, returns to 0x2A32 // Incoming call from 0x2A10, returns to 0x06F1 // Incoming call from 0x25B6, returns to 0x25B7 // Inputs[2] // { // @232C stack[-1] // @232D msg.data[stack[-1]:stack[-1] + 0x20] // } 232B 5B JUMPDEST 232C 80 DUP1 232D 35 CALLDATALOAD 232E 60 PUSH1 0x01 2330 60 PUSH1 0x01 2332 60 PUSH1 0xa0 2334 1B SHL 2335 03 SUB 2336 81 DUP2 2337 16 AND 2338 81 DUP2 2339 14 EQ 233A 61 PUSH2 0x2342 233D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @232D stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2342, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_233E: // Incoming jump from 0x233D, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2341 memory[0x00:0x00] } 233E 60 PUSH1 0x00 2340 80 DUP1 2341 FD *REVERT // Stack delta = +0 // Outputs[1] { @2341 revert(memory[0x00:0x00]); } // Block terminates label_2342: // Incoming jump from 0x233D, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2343 stack[-3] // @2343 stack[-1] // @2344 stack[-2] // } 2342 5B JUMPDEST 2343 91 SWAP2 2344 90 SWAP1 2345 50 POP 2346 56 *JUMP // Stack delta = -2 // Outputs[1] { @2343 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2347: // Incoming call from 0x01F6, returns to 0x01F7 // Incoming call from 0x0488, returns to 0x0489 // Inputs[2] // { // @234D stack[-1] // @234E stack[-2] // } 2347 5B JUMPDEST 2348 60 PUSH1 0x00 234A 80 DUP1 234B 60 PUSH1 0x40 234D 83 DUP4 234E 85 DUP6 234F 03 SUB 2350 12 SLT 2351 15 ISZERO 2352 61 PUSH2 0x235a 2355 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2348 stack[0] = 0x00 // @234A stack[1] = 0x00 // } // Block ends with conditional jump to 0x235a, if !(stack[-2] - stack[-1] i< 0x40) label_2356: // Incoming jump from 0x2355, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2359 memory[0x00:0x00] } 2356 60 PUSH1 0x00 2358 80 DUP1 2359 FD *REVERT // Stack delta = +0 // Outputs[1] { @2359 revert(memory[0x00:0x00]); } // Block terminates label_235A: // Incoming jump from 0x2355, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @235E stack[-3] } 235A 5B JUMPDEST 235B 61 PUSH2 0x2363 235E 83 DUP4 235F 61 PUSH2 0x232b 2362 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @235B stack[0] = 0x2363 // @235E stack[1] = stack[-3] // } // Block ends with call to 0x232b, returns to 0x2363 label_2363: // Incoming return from call to 0x232B at 0x2362 // Inputs[5] // { // @2364 stack[-1] // @2364 stack[-6] // @2367 stack[-4] // @236B msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @236C stack[-5] // } 2363 5B JUMPDEST 2364 94 SWAP5 2365 60 PUSH1 0x20 2367 93 SWAP4 2368 90 SWAP1 2369 93 SWAP4 236A 01 ADD 236B 35 CALLDATALOAD 236C 93 SWAP4 236D 50 POP 236E 50 POP 236F 50 POP 2370 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2364 stack[-6] = stack[-1] // @236C stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_2371: // Incoming call from 0x2D1C, returns to 0x1BA4 // Incoming call from 0x23A3, returns to 0x1BA4 // Inputs[1] { @237B stack[-1] } 2371 5B JUMPDEST 2372 60 PUSH1 0x01 2374 60 PUSH1 0x01 2376 60 PUSH1 0xe0 2378 1B SHL 2379 03 SUB 237A 19 NOT 237B 81 DUP2 237C 16 AND 237D 81 DUP2 237E 14 EQ 237F 61 PUSH2 0x0f8b 2382 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f8b, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2383: // Incoming jump from 0x2382, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2386 memory[0x00:0x00] } 2383 60 PUSH1 0x00 2385 80 DUP1 2386 FD *REVERT // Stack delta = +0 // Outputs[1] { @2386 revert(memory[0x00:0x00]); } // Block terminates label_2387: // Incoming call from 0x021C, returns to 0x021D // Inputs[2] // { // @238C stack[-1] // @238D stack[-2] // } 2387 5B JUMPDEST 2388 60 PUSH1 0x00 238A 60 PUSH1 0x20 238C 82 DUP3 238D 84 DUP5 238E 03 SUB 238F 12 SLT 2390 15 ISZERO 2391 61 PUSH2 0x2399 2394 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2388 stack[0] = 0x00 } // Block ends with conditional jump to 0x2399, if !(stack[-2] - stack[-1] i< 0x20) label_2395: // Incoming jump from 0x2394, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2398 memory[0x00:0x00] } 2395 60 PUSH1 0x00 2397 80 DUP1 2398 FD *REVERT // Stack delta = +0 // Outputs[1] { @2398 revert(memory[0x00:0x00]); } // Block terminates label_2399: // Incoming jump from 0x2394, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @239A stack[-2] // @239B msg.data[stack[-2]:stack[-2] + 0x20] // } 2399 5B JUMPDEST 239A 81 DUP2 239B 35 CALLDATALOAD 239C 61 PUSH2 0x1ba4 239F 81 DUP2 23A0 61 PUSH2 0x2371 23A3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @239B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @239C stack[1] = 0x1ba4 // @239F stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2371, returns to 0x1BA4 label_23A4: // Incoming call from 0x035D, returns to 0x035E // Incoming call from 0x0286, returns to 0x0287 // Incoming call from 0x0455, returns to 0x0456 // Incoming call from 0x0266, returns to 0x0267 // Inputs[2] // { // @23A9 stack[-1] // @23AA stack[-2] // } 23A4 5B JUMPDEST 23A5 60 PUSH1 0x00 23A7 60 PUSH1 0x20 23A9 82 DUP3 23AA 84 DUP5 23AB 03 SUB 23AC 12 SLT 23AD 15 ISZERO 23AE 61 PUSH2 0x23b6 23B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23A5 stack[0] = 0x00 } // Block ends with conditional jump to 0x23b6, if !(stack[-2] - stack[-1] i< 0x20) label_23B2: // Incoming jump from 0x23B1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @23B5 memory[0x00:0x00] } 23B2 60 PUSH1 0x00 23B4 80 DUP1 23B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @23B5 revert(memory[0x00:0x00]); } // Block terminates label_23B6: // Incoming jump from 0x23B1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @23B8 msg.data[stack[-2]:stack[-2] + 0x20] // @23B8 stack[-2] // @23B9 stack[-4] // @23BA stack[-3] // } 23B6 5B JUMPDEST 23B7 50 POP 23B8 35 CALLDATALOAD 23B9 91 SWAP2 23BA 90 SWAP1 23BB 50 POP 23BC 56 *JUMP // Stack delta = -3 // Outputs[1] { @23B9 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_23BD: // Incoming call from 0x2C41, returns to 0x2C42 // Incoming call from 0x2C7E, returns to 0x2C7F // Incoming call from 0x2400, returns to 0x2401 // Inputs[1] { @23C1 stack[-3] } 23BD 5B JUMPDEST 23BE 60 PUSH1 0x00 23C0 5B JUMPDEST 23C1 83 DUP4 23C2 81 DUP2 23C3 10 LT 23C4 15 ISZERO 23C5 61 PUSH2 0x23d8 23C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23BE stack[0] = 0x00 } // Block ends with conditional jump to 0x23d8, if !(0x00 < stack[-3]) label_23C9: // Incoming jump from 0x23C8, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x23C8, if not !(0x00 < stack[-3]) // Inputs[4] // { // @23C9 stack[-2] // @23CA stack[-1] // @23CC memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @23CD stack[-3] // } 23C9 81 DUP2 23CA 81 DUP2 23CB 01 ADD 23CC 51 MLOAD 23CD 83 DUP4 23CE 82 DUP3 23CF 01 ADD 23D0 52 MSTORE 23D1 60 PUSH1 0x20 23D3 01 ADD 23D4 61 PUSH2 0x23c0 23D7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @23D0 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @23D3 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x23c0 label_23D8: // Incoming jump from 0x23C8, if !(stack[-1] < stack[-4]) // Incoming jump from 0x23C8, if !(0x00 < stack[-3]) // Inputs[2] // { // @23D9 stack[-4] // @23DA stack[-1] // } 23D8 5B JUMPDEST 23D9 83 DUP4 23DA 81 DUP2 23DB 11 GT 23DC 15 ISZERO 23DD 61 PUSH2 0x0a4a 23E0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a4a, if !(stack[-1] > stack[-4]) label_23E1: // Incoming jump from 0x23E0, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @23E5 stack[-4] // @23E6 stack[-3] // @23E8 stack[-5] // } 23E1 50 POP 23E2 50 POP 23E3 60 PUSH1 0x00 23E5 91 SWAP2 23E6 01 ADD 23E7 52 MSTORE 23E8 56 *JUMP // Stack delta = -5 // Outputs[1] { @23E7 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_23E9: // Incoming call from 0x2CF3, returns to 0x2CF4 // Incoming call from 0x2427, returns to 0x1BA4 // Incoming call from 0x2E11, returns to 0x2E12 // Inputs[3] // { // @23EC stack[-1] // @23ED memory[stack[-1]:stack[-1] + 0x20] // @23EF stack[-2] // } 23E9 5B JUMPDEST 23EA 60 PUSH1 0x00 23EC 81 DUP2 23ED 51 MLOAD 23EE 80 DUP1 23EF 84 DUP5 23F0 52 MSTORE 23F1 61 PUSH2 0x2401 23F4 81 DUP2 23F5 60 PUSH1 0x20 23F7 86 DUP7 23F8 01 ADD 23F9 60 PUSH1 0x20 23FB 86 DUP7 23FC 01 ADD 23FD 61 PUSH2 0x23bd 2400 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @23EA stack[0] = 0x00 // @23ED stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @23F0 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @23F1 stack[2] = 0x2401 // @23F4 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @23F8 stack[4] = stack[-2] + 0x20 // @23FC stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x23bd, returns to 0x2401 label_2401: // Incoming return from call to 0x23BD at 0x2400 // Inputs[4] // { // @2404 stack[-1] // @2409 stack[-4] // @240A stack[-2] // @2410 stack[-5] // } 2401 5B JUMPDEST 2402 60 PUSH1 0x1f 2404 01 ADD 2405 60 PUSH1 0x1f 2407 19 NOT 2408 16 AND 2409 92 SWAP3 240A 90 SWAP1 240B 92 SWAP3 240C 01 ADD 240D 60 PUSH1 0x20 240F 01 ADD 2410 92 SWAP3 2411 91 SWAP2 2412 50 POP 2413 50 POP 2414 56 *JUMP // Stack delta = -4 // Outputs[1] { @2410 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2415: // Incoming jump from 0x1884 // Incoming jump from 0x1335 // Incoming jump from 0x0278 // Inputs[2] // { // @2418 stack[-1] // @2423 stack[-2] // } 2415 5B JUMPDEST 2416 60 PUSH1 0x20 2418 81 DUP2 2419 52 MSTORE 241A 60 PUSH1 0x00 241C 61 PUSH2 0x1ba4 241F 60 PUSH1 0x20 2421 83 DUP4 2422 01 ADD 2423 84 DUP5 2424 61 PUSH2 0x23e9 2427 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2419 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @241A stack[0] = 0x00 // @241C stack[1] = 0x1ba4 // @2422 stack[2] = stack[-1] + 0x20 // @2423 stack[3] = stack[-2] // } // Block ends with call to 0x23e9, returns to 0x1BA4 label_2428: // Incoming call from 0x02D0, returns to 0x02D1 // Inputs[2] // { // @242E stack[-1] // @242F stack[-2] // } 2428 5B JUMPDEST 2429 60 PUSH1 0x00 242B 80 DUP1 242C 60 PUSH1 0x40 242E 83 DUP4 242F 85 DUP6 2430 03 SUB 2431 12 SLT 2432 15 ISZERO 2433 61 PUSH2 0x243b 2436 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2429 stack[0] = 0x00 // @242B stack[1] = 0x00 // } // Block ends with conditional jump to 0x243b, if !(stack[-2] - stack[-1] i< 0x40) label_2437: // Incoming jump from 0x2436, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @243A memory[0x00:0x00] } 2437 60 PUSH1 0x00 2439 80 DUP1 243A FD *REVERT // Stack delta = +0 // Outputs[1] { @243A revert(memory[0x00:0x00]); } // Block terminates label_243B: // Incoming jump from 0x2436, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @243E stack[-3] // @243F msg.data[stack[-3]:stack[-3] + 0x20] // @2440 stack[-5] // @2446 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2447 stack[-4] // } 243B 5B JUMPDEST 243C 50 POP 243D 50 POP 243E 80 DUP1 243F 35 CALLDATALOAD 2440 92 SWAP3 2441 60 PUSH1 0x20 2443 90 SWAP1 2444 91 SWAP2 2445 01 ADD 2446 35 CALLDATALOAD 2447 91 SWAP2 2448 50 POP 2449 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2440 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @2447 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_244A: // Incoming jump from 0x19AC // Incoming jump from 0x24A6 // Incoming jump from 0x254C // Incoming jump from 0x2485 // Inputs[1] { @245F memory[0x00:0x24] } 244A 5B JUMPDEST 244B 63 PUSH4 0x4e487b71 2450 60 PUSH1 0xe0 2452 1B SHL 2453 60 PUSH1 0x00 2455 52 MSTORE 2456 60 PUSH1 0x41 2458 60 PUSH1 0x04 245A 52 MSTORE 245B 60 PUSH1 0x24 245D 60 PUSH1 0x00 245F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2455 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @245A memory[0x04:0x24] = 0x41 // @245F revert(memory[0x00:0x24]); // } // Block terminates label_2460: // Incoming call from 0x2563, returns to 0x2564 // Incoming call from 0x2DB7, returns to 0x2DB8 // Incoming call from 0x268D, returns to 0x268E // Incoming call from 0x24DB, returns to 0x24DC // Inputs[2] // { // @2463 stack[-2] // @2469 stack[-1] // } 2460 5B JUMPDEST 2461 60 PUSH1 0x1f 2463 82 DUP3 2464 01 ADD 2465 60 PUSH1 0x1f 2467 19 NOT 2468 16 AND 2469 81 DUP2 246A 01 ADD 246B 67 PUSH8 0xffffffffffffffff 2474 81 DUP2 2475 11 GT 2476 82 DUP3 2477 82 DUP3 2478 10 LT 2479 17 OR 247A 15 ISZERO 247B 61 PUSH2 0x2486 247E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @246A stack[0] = stack[-1] + (~0x1f & stack[-2] + 0x1f) } // Block ends with conditional jump to 0x2486, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) label_247F: // Incoming jump from 0x247E, if not !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) 247F 61 PUSH2 0x2486 2482 61 PUSH2 0x244a 2485 56 *JUMP // Stack delta = +1 // Outputs[1] { @247F stack[0] = 0x2486 } // Block ends with unconditional jump to 0x244a label_2486: // Incoming jump from 0x247E, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) // Inputs[2] // { // @2489 stack[-1] // @248C stack[-4] // } 2486 5B JUMPDEST 2487 60 PUSH1 0x40 2489 52 MSTORE 248A 50 POP 248B 50 POP 248C 56 *JUMP // Stack delta = -4 // Outputs[1] { @2489 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_248D: // Incoming call from 0x24CE, returns to 0x24CF // Incoming call from 0x2680, returns to 0x2681 // Inputs[1] { @2499 stack[-1] } 248D 5B JUMPDEST 248E 60 PUSH1 0x00 2490 67 PUSH8 0xffffffffffffffff 2499 82 DUP3 249A 11 GT 249B 15 ISZERO 249C 61 PUSH2 0x24a7 249F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @248E stack[0] = 0x00 } // Block ends with conditional jump to 0x24a7, if !(stack[-1] > 0xffffffffffffffff) label_24A0: // Incoming jump from 0x249F, if not !(stack[-1] > 0xffffffffffffffff) 24A0 61 PUSH2 0x24a7 24A3 61 PUSH2 0x244a 24A6 56 *JUMP // Stack delta = +1 // Outputs[1] { @24A0 stack[0] = 0x24a7 } // Block ends with unconditional jump to 0x244a label_24A7: // Incoming jump from 0x249F, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @24AB stack[-2] // @24AF stack[-3] // } 24A7 5B JUMPDEST 24A8 50 POP 24A9 60 PUSH1 0x05 24AB 1B SHL 24AC 60 PUSH1 0x20 24AE 01 ADD 24AF 90 SWAP1 24B0 56 *JUMP // Stack delta = -2 // Outputs[1] { @24AF stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_24B1: // Incoming call from 0x25ED, returns to 0x25EE // Incoming call from 0x260F, returns to 0x2610 // Incoming call from 0x2729, returns to 0x272A // Incoming call from 0x287C, returns to 0x287D // Incoming call from 0x2859, returns to 0x285A // Incoming call from 0x2980, returns to 0x2981 // Inputs[2] // { // @24B4 stack[-2] // @24B7 stack[-1] // } 24B1 5B JUMPDEST 24B2 60 PUSH1 0x00 24B4 82 DUP3 24B5 60 PUSH1 0x1f 24B7 83 DUP4 24B8 01 ADD 24B9 12 SLT 24BA 61 PUSH2 0x24c2 24BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24B2 stack[0] = 0x00 } // Block ends with conditional jump to 0x24c2, if stack[-1] + 0x1f i< stack[-2] label_24BE: // Incoming jump from 0x24BD, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @24C1 memory[0x00:0x00] } 24BE 60 PUSH1 0x00 24C0 80 DUP1 24C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @24C1 revert(memory[0x00:0x00]); } // Block terminates label_24C2: // Incoming jump from 0x24BD, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @24C3 stack[-2] // @24C4 msg.data[stack[-2]:stack[-2] + 0x20] // } 24C2 5B JUMPDEST 24C3 81 DUP2 24C4 35 CALLDATALOAD 24C5 60 PUSH1 0x20 24C7 61 PUSH2 0x24cf 24CA 82 DUP3 24CB 61 PUSH2 0x248d 24CE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @24C4 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @24C5 stack[1] = 0x20 // @24C7 stack[2] = 0x24cf // @24CA stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x248d, returns to 0x24CF label_24CF: // Incoming return from call to 0x248D at 0x24CE // Inputs[2] // { // @24D2 memory[0x40:0x60] // @24D6 stack[-1] // } 24CF 5B JUMPDEST 24D0 60 PUSH1 0x40 24D2 51 MLOAD 24D3 61 PUSH2 0x24dc 24D6 82 DUP3 24D7 82 DUP3 24D8 61 PUSH2 0x2460 24DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @24D2 stack[0] = memory[0x40:0x60] // @24D3 stack[1] = 0x24dc // @24D6 stack[2] = stack[-1] // @24D7 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2460, returns to 0x24DC label_24DC: // Incoming return from call to 0x2460 at 0x24DB // Inputs[6] // { // @24DD stack[-4] // @24DE stack[-1] // @24E6 stack[-6] // @24E8 stack[-3] // @24EE stack[-2] // @24F0 stack[-7] // } 24DC 5B JUMPDEST 24DD 83 DUP4 24DE 81 DUP2 24DF 52 MSTORE 24E0 60 PUSH1 0x05 24E2 93 SWAP4 24E3 90 SWAP1 24E4 93 SWAP4 24E5 1B SHL 24E6 85 DUP6 24E7 01 ADD 24E8 82 DUP3 24E9 01 ADD 24EA 92 SWAP3 24EB 82 DUP3 24EC 81 DUP2 24ED 01 ADD 24EE 91 SWAP2 24EF 50 POP 24F0 86 DUP7 24F1 84 DUP5 24F2 11 GT 24F3 15 ISZERO 24F4 61 PUSH2 0x24fc 24F7 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @24DF memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @24EA stack[-1] = stack[-1] // @24EA stack[-4] = stack[-3] + stack[-6] + (stack[-4] << 0x05) // @24EE stack[-2] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x24fc, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) label_24F8: // Incoming jump from 0x24F7, if not !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[1] { @24FB memory[0x00:0x00] } 24F8 60 PUSH1 0x00 24FA 80 DUP1 24FB FD *REVERT // Stack delta = +0 // Outputs[1] { @24FB revert(memory[0x00:0x00]); } // Block terminates label_24FC: // Incoming jump from 0x24F7, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[3] // { // @24FD stack[-3] // @24FE stack[-6] // @2501 stack[-4] // } 24FC 5B JUMPDEST 24FD 82 DUP3 24FE 86 DUP7 24FF 01 ADD 2500 5B JUMPDEST 2501 84 DUP5 2502 81 DUP2 2503 10 LT 2504 15 ISZERO 2505 61 PUSH2 0x2517 2508 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24FF stack[0] = stack[-6] + stack[-3] } // Block ends with conditional jump to 0x2517, if !(stack[-6] + stack[-3] < stack[-4]) label_2509: // Incoming jump from 0x2508, if not !(stack[-1] < stack[-5]) // Incoming jump from 0x2508, if not !(stack[-6] + stack[-3] < stack[-4]) // Inputs[4] // { // @2509 stack[-1] // @250A msg.data[stack[-1]:stack[-1] + 0x20] // @250B stack[-3] // @250E stack[-4] // } 2509 80 DUP1 250A 35 CALLDATALOAD 250B 83 DUP4 250C 52 MSTORE 250D 91 SWAP2 250E 83 DUP4 250F 01 ADD 2510 91 SWAP2 2511 83 DUP4 2512 01 ADD 2513 61 PUSH2 0x2500 2516 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @250C memory[stack[-3]:stack[-3] + 0x20] = msg.data[stack[-1]:stack[-1] + 0x20] // @2510 stack[-3] = stack[-4] + stack[-3] // @2512 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x2500 label_2517: // Incoming jump from 0x26BA, if !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x2508, if !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x2508, if !(stack[-1] < stack[-5]) // Incoming jump from 0x26BA, if !(stack[-1] < stack[-5]) // Inputs[3] // { // @2519 stack[-9] // @2519 stack[-2] // @251A stack[-8] // } 2517 5B JUMPDEST 2518 50 POP 2519 96 SWAP7 251A 95 SWAP6 251B 50 POP 251C 50 POP 251D 50 POP 251E 50 POP 251F 50 POP 2520 50 POP 2521 56 *JUMP // Stack delta = -8 // Outputs[1] { @2519 stack[-9] = stack[-2] } // Block ends with unconditional jump to stack[-9] label_2522: // Incoming call from 0x28DB, returns to 0x28DC // Incoming call from 0x2632, returns to 0x2633 // Incoming call from 0x29AA, returns to 0x28DC // Incoming call from 0x2AF8, returns to 0x2AF9 // Incoming call from 0x2924, returns to 0x272A // Incoming call from 0x2A75, returns to 0x2633 // Inputs[2] // { // @2525 stack[-2] // @2528 stack[-1] // } 2522 5B JUMPDEST 2523 60 PUSH1 0x00 2525 82 DUP3 2526 60 PUSH1 0x1f 2528 83 DUP4 2529 01 ADD 252A 12 SLT 252B 61 PUSH2 0x2533 252E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2523 stack[0] = 0x00 } // Block ends with conditional jump to 0x2533, if stack[-1] + 0x1f i< stack[-2] label_252F: // Incoming jump from 0x252E, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2532 memory[0x00:0x00] } 252F 60 PUSH1 0x00 2531 80 DUP1 2532 FD *REVERT // Stack delta = +0 // Outputs[1] { @2532 revert(memory[0x00:0x00]); } // Block terminates label_2533: // Incoming jump from 0x252E, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2534 stack[-2] // @2535 msg.data[stack[-2]:stack[-2] + 0x20] // } 2533 5B JUMPDEST 2534 81 DUP2 2535 35 CALLDATALOAD 2536 67 PUSH8 0xffffffffffffffff 253F 81 DUP2 2540 11 GT 2541 15 ISZERO 2542 61 PUSH2 0x254d 2545 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2535 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x254d, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2546: // Incoming jump from 0x2545, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 2546 61 PUSH2 0x254d 2549 61 PUSH2 0x244a 254C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2546 stack[0] = 0x254d } // Block ends with unconditional jump to 0x244a label_254D: // Incoming jump from 0x2545, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2550 memory[0x40:0x60] // @2556 stack[-1] // } 254D 5B JUMPDEST 254E 60 PUSH1 0x40 2550 51 MLOAD 2551 61 PUSH2 0x2564 2554 60 PUSH1 0x1f 2556 83 DUP4 2557 01 ADD 2558 60 PUSH1 0x1f 255A 19 NOT 255B 16 AND 255C 60 PUSH1 0x20 255E 01 ADD 255F 82 DUP3 2560 61 PUSH2 0x2460 2563 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2550 stack[0] = memory[0x40:0x60] // @2551 stack[1] = 0x2564 // @255E stack[2] = 0x20 + (~0x1f & stack[-1] + 0x1f) // @255F stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2460, returns to 0x2564 label_2564: // Incoming return from call to 0x2460 at 0x2563 // Inputs[4] // { // @2565 stack[-2] // @2566 stack[-1] // @2568 stack[-5] // @256C stack[-4] // } 2564 5B JUMPDEST 2565 81 DUP2 2566 81 DUP2 2567 52 MSTORE 2568 84 DUP5 2569 60 PUSH1 0x20 256B 83 DUP4 256C 86 DUP7 256D 01 ADD 256E 01 ADD 256F 11 GT 2570 15 ISZERO 2571 61 PUSH2 0x2579 2574 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2567 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x2579, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_2575: // Incoming jump from 0x2574, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @2578 memory[0x00:0x00] } 2575 60 PUSH1 0x00 2577 80 DUP1 2578 FD *REVERT // Stack delta = +0 // Outputs[1] { @2578 revert(memory[0x00:0x00]); } // Block terminates label_2579: // Incoming jump from 0x2574, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[6] // { // @257A stack[-2] // @257D stack[-4] // @2581 stack[-1] // @2583 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @2590 stack[-6] // @2591 stack[-5] // } 2579 5B JUMPDEST 257A 81 DUP2 257B 60 PUSH1 0x20 257D 85 DUP6 257E 01 ADD 257F 60 PUSH1 0x20 2581 83 DUP4 2582 01 ADD 2583 37 CALLDATACOPY 2584 60 PUSH1 0x00 2586 91 SWAP2 2587 81 DUP2 2588 01 ADD 2589 60 PUSH1 0x20 258B 01 ADD 258C 91 SWAP2 258D 90 SWAP1 258E 91 SWAP2 258F 52 MSTORE 2590 93 SWAP4 2591 92 SWAP3 2592 50 POP 2593 50 POP 2594 50 POP 2595 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @2583 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @258F memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] = 0x00 // @2590 stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_2596: // Incoming call from 0x0302, returns to 0x0303 // Inputs[2] // { // @25A1 stack[-1] // @25A2 stack[-2] // } 2596 5B JUMPDEST 2597 60 PUSH1 0x00 2599 80 DUP1 259A 60 PUSH1 0x00 259C 80 DUP1 259D 60 PUSH1 0x00 259F 60 PUSH1 0xa0 25A1 86 DUP7 25A2 88 DUP9 25A3 03 SUB 25A4 12 SLT 25A5 15 ISZERO 25A6 61 PUSH2 0x25ae 25A9 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2597 stack[0] = 0x00 // @2599 stack[1] = 0x00 // @259A stack[2] = 0x00 // @259C stack[3] = 0x00 // @259D stack[4] = 0x00 // } // Block ends with conditional jump to 0x25ae, if !(stack[-2] - stack[-1] i< 0xa0) label_25AA: // Incoming jump from 0x25A9, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @25AD memory[0x00:0x00] } 25AA 60 PUSH1 0x00 25AC 80 DUP1 25AD FD *REVERT // Stack delta = +0 // Outputs[1] { @25AD revert(memory[0x00:0x00]); } // Block terminates label_25AE: // Incoming jump from 0x25A9, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @25B2 stack[-6] } 25AE 5B JUMPDEST 25AF 61 PUSH2 0x25b7 25B2 86 DUP7 25B3 61 PUSH2 0x232b 25B6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @25AF stack[0] = 0x25b7 // @25B2 stack[1] = stack[-6] // } // Block ends with call to 0x232b, returns to 0x25B7 label_25B7: // Incoming return from call to 0x232B at 0x25B6 // Inputs[3] // { // @25B8 stack[-6] // @25B8 stack[-1] // @25BF stack[-7] // } 25B7 5B JUMPDEST 25B8 94 SWAP5 25B9 50 POP 25BA 61 PUSH2 0x25c5 25BD 60 PUSH1 0x20 25BF 87 DUP8 25C0 01 ADD 25C1 61 PUSH2 0x232b 25C4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @25B8 stack[-6] = stack[-1] // @25BA stack[-1] = 0x25c5 // @25C0 stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x232b, returns to 0x25C5 label_25C5: // Incoming return from call to 0x232B at 0x25C4 // Inputs[4] // { // @25C6 stack[-1] // @25C6 stack[-5] // @25CA stack[-7] // @25CC msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 25C5 5B JUMPDEST 25C6 93 SWAP4 25C7 50 POP 25C8 60 PUSH1 0x40 25CA 86 DUP7 25CB 01 ADD 25CC 35 CALLDATALOAD 25CD 67 PUSH8 0xffffffffffffffff 25D6 80 DUP1 25D7 82 DUP3 25D8 11 GT 25D9 15 ISZERO 25DA 61 PUSH2 0x25e2 25DD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @25C6 stack[-5] = stack[-1] // @25CC stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @25CD stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x25e2, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) label_25DE: // Incoming jump from 0x25DD, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @25E1 memory[0x00:0x00] } 25DE 60 PUSH1 0x00 25E0 80 DUP1 25E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @25E1 revert(memory[0x00:0x00]); } // Block terminates label_25E2: // Incoming jump from 0x25DD, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @25E6 stack[-9] // @25E7 stack[-2] // @25E8 stack[-8] // } 25E2 5B JUMPDEST 25E3 61 PUSH2 0x25ee 25E6 89 DUP10 25E7 83 DUP4 25E8 8A DUP11 25E9 01 ADD 25EA 61 PUSH2 0x24b1 25ED 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @25E3 stack[0] = 0x25ee // @25E6 stack[1] = stack[-9] // @25E9 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x24b1, returns to 0x25EE label_25EE: // Incoming return from call to 0x24B1 at 0x25ED // Inputs[6] // { // @25EF stack[-1] // @25EF stack[-6] // @25F3 stack[-9] // @25F5 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @25F6 stack[-3] // @25F8 stack[-2] // } 25EE 5B JUMPDEST 25EF 94 SWAP5 25F0 50 POP 25F1 60 PUSH1 0x60 25F3 88 DUP9 25F4 01 ADD 25F5 35 CALLDATALOAD 25F6 91 SWAP2 25F7 50 POP 25F8 80 DUP1 25F9 82 DUP3 25FA 11 GT 25FB 15 ISZERO 25FC 61 PUSH2 0x2604 25FF 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @25EF stack[-6] = stack[-1] // @25F6 stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2604, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_2600: // Incoming jump from 0x25FF, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[1] { @2603 memory[0x00:0x00] } 2600 60 PUSH1 0x00 2602 80 DUP1 2603 FD *REVERT // Stack delta = +0 // Outputs[1] { @2603 revert(memory[0x00:0x00]); } // Block terminates label_2604: // Incoming jump from 0x25FF, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @2608 stack[-9] // @2609 stack[-2] // @260A stack[-8] // } 2604 5B JUMPDEST 2605 61 PUSH2 0x2610 2608 89 DUP10 2609 83 DUP4 260A 8A DUP11 260B 01 ADD 260C 61 PUSH2 0x24b1 260F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2605 stack[0] = 0x2610 // @2608 stack[1] = stack[-9] // @260B stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x24b1, returns to 0x2610 label_2610: // Incoming return from call to 0x24B1 at 0x260F // Inputs[6] // { // @2611 stack[-1] // @2611 stack[-5] // @2615 stack[-9] // @2617 msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @2618 stack[-3] // @261A stack[-2] // } 2610 5B JUMPDEST 2611 93 SWAP4 2612 50 POP 2613 60 PUSH1 0x80 2615 88 DUP9 2616 01 ADD 2617 35 CALLDATALOAD 2618 91 SWAP2 2619 50 POP 261A 80 DUP1 261B 82 DUP3 261C 11 GT 261D 15 ISZERO 261E 61 PUSH2 0x2626 2621 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2611 stack[-5] = stack[-1] // @2618 stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x2626, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_2622: // Incoming jump from 0x2621, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[1] { @2625 memory[0x00:0x00] } 2622 60 PUSH1 0x00 2624 80 DUP1 2625 FD *REVERT // Stack delta = +0 // Outputs[1] { @2625 revert(memory[0x00:0x00]); } // Block terminates label_2626: // Incoming jump from 0x280E, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Incoming jump from 0x2621, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @262B stack[-9] // @262C stack[-2] // @262D stack[-8] // } 2626 5B JUMPDEST 2627 50 POP 2628 61 PUSH2 0x2633 262B 88 DUP9 262C 82 DUP3 262D 89 DUP10 262E 01 ADD 262F 61 PUSH2 0x2522 2632 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2628 stack[-1] = 0x2633 // @262B stack[0] = stack[-9] // @262E stack[1] = stack[-8] + stack[-2] // } // Block ends with call to 0x2522, returns to 0x2633 label_2633: // Incoming return from call to 0x2522 at 0x2632 // Incoming return from call to 0x2522 at 0x2A75 // Inputs[9] // { // @2634 stack[-1] // @2634 stack[-3] // @2637 stack[-6] // @2638 stack[-9] // @263A stack[-7] // @263A stack[-4] // @263B stack[-10] // @263C stack[-5] // @263D stack[-8] // } 2633 5B JUMPDEST 2634 91 SWAP2 2635 50 POP 2636 50 POP 2637 92 SWAP3 2638 95 SWAP6 2639 50 POP 263A 92 SWAP3 263B 95 SWAP6 263C 90 SWAP1 263D 93 SWAP4 263E 50 POP 263F 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @2637 stack[-6] = stack[-1] // @2638 stack[-9] = stack[-6] // @263A stack[-7] = stack[-4] // @263B stack[-10] = stack[-7] // @263D stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_2640: // Incoming call from 0x032A, returns to 0x032B // Incoming call from 0x0475, returns to 0x0476 // Incoming call from 0x0317, returns to 0x0318 // Incoming call from 0x0401, returns to 0x0402 // Inputs[2] // { // @2646 stack[-1] // @2647 stack[-2] // } 2640 5B JUMPDEST 2641 60 PUSH1 0x00 2643 80 DUP1 2644 60 PUSH1 0x40 2646 83 DUP4 2647 85 DUP6 2648 03 SUB 2649 12 SLT 264A 15 ISZERO 264B 61 PUSH2 0x2653 264E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2641 stack[0] = 0x00 // @2643 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2653, if !(stack[-2] - stack[-1] i< 0x40) label_264F: // Incoming jump from 0x264E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2652 memory[0x00:0x00] } 264F 60 PUSH1 0x00 2651 80 DUP1 2652 FD *REVERT // Stack delta = +0 // Outputs[1] { @2652 revert(memory[0x00:0x00]); } // Block terminates label_2653: // Incoming jump from 0x264E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @2654 stack[-3] // @2655 msg.data[stack[-3]:stack[-3] + 0x20] // @2656 stack[-2] // } 2653 5B JUMPDEST 2654 82 DUP3 2655 35 CALLDATALOAD 2656 91 SWAP2 2657 50 POP 2658 61 PUSH2 0x06f1 265B 60 PUSH1 0x20 265D 84 DUP5 265E 01 ADD 265F 61 PUSH2 0x232b 2662 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2656 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @2658 stack[0] = 0x06f1 // @265E stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x232b, returns to 0x06F1 label_2663: // Incoming call from 0x295E, returns to 0x295F // Incoming call from 0x2706, returns to 0x2707 // Inputs[2] // { // @2666 stack[-2] // @2669 stack[-1] // } 2663 5B JUMPDEST 2664 60 PUSH1 0x00 2666 82 DUP3 2667 60 PUSH1 0x1f 2669 83 DUP4 266A 01 ADD 266B 12 SLT 266C 61 PUSH2 0x2674 266F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2664 stack[0] = 0x00 } // Block ends with conditional jump to 0x2674, if stack[-1] + 0x1f i< stack[-2] label_2670: // Incoming jump from 0x266F, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2673 memory[0x00:0x00] } 2670 60 PUSH1 0x00 2672 80 DUP1 2673 FD *REVERT // Stack delta = +0 // Outputs[1] { @2673 revert(memory[0x00:0x00]); } // Block terminates label_2674: // Incoming jump from 0x266F, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2675 stack[-2] // @2676 msg.data[stack[-2]:stack[-2] + 0x20] // } 2674 5B JUMPDEST 2675 81 DUP2 2676 35 CALLDATALOAD 2677 60 PUSH1 0x20 2679 61 PUSH2 0x2681 267C 82 DUP3 267D 61 PUSH2 0x248d 2680 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2676 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2677 stack[1] = 0x20 // @2679 stack[2] = 0x2681 // @267C stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x248d, returns to 0x2681 label_2681: // Incoming return from call to 0x248D at 0x2680 // Inputs[2] // { // @2684 memory[0x40:0x60] // @2688 stack[-1] // } 2681 5B JUMPDEST 2682 60 PUSH1 0x40 2684 51 MLOAD 2685 61 PUSH2 0x268e 2688 82 DUP3 2689 82 DUP3 268A 61 PUSH2 0x2460 268D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2684 stack[0] = memory[0x40:0x60] // @2685 stack[1] = 0x268e // @2688 stack[2] = stack[-1] // @2689 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2460, returns to 0x268E label_268E: // Incoming return from call to 0x2460 at 0x268D // Inputs[6] // { // @268F stack[-4] // @2690 stack[-1] // @2698 stack[-6] // @269A stack[-3] // @26A0 stack[-2] // @26A2 stack[-7] // } 268E 5B JUMPDEST 268F 83 DUP4 2690 81 DUP2 2691 52 MSTORE 2692 60 PUSH1 0x05 2694 93 SWAP4 2695 90 SWAP1 2696 93 SWAP4 2697 1B SHL 2698 85 DUP6 2699 01 ADD 269A 82 DUP3 269B 01 ADD 269C 92 SWAP3 269D 82 DUP3 269E 81 DUP2 269F 01 ADD 26A0 91 SWAP2 26A1 50 POP 26A2 86 DUP7 26A3 84 DUP5 26A4 11 GT 26A5 15 ISZERO 26A6 61 PUSH2 0x26ae 26A9 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2691 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @269C stack[-1] = stack[-1] // @269C stack[-4] = stack[-3] + stack[-6] + (stack[-4] << 0x05) // @26A0 stack[-2] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x26ae, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) label_26AA: // Incoming jump from 0x26A9, if not !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[1] { @26AD memory[0x00:0x00] } 26AA 60 PUSH1 0x00 26AC 80 DUP1 26AD FD *REVERT // Stack delta = +0 // Outputs[1] { @26AD revert(memory[0x00:0x00]); } // Block terminates label_26AE: // Incoming jump from 0x26A9, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[3] // { // @26AF stack[-3] // @26B0 stack[-6] // @26B3 stack[-4] // } 26AE 5B JUMPDEST 26AF 82 DUP3 26B0 86 DUP7 26B1 01 ADD 26B2 5B JUMPDEST 26B3 84 DUP5 26B4 81 DUP2 26B5 10 LT 26B6 15 ISZERO 26B7 61 PUSH2 0x2517 26BA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26B1 stack[0] = stack[-6] + stack[-3] } // Block ends with conditional jump to 0x2517, if !(stack[-6] + stack[-3] < stack[-4]) label_26BB: // Incoming jump from 0x26BA, if not !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x26BA, if not !(stack[-1] < stack[-5]) // Inputs[1] { @26BE stack[-1] } 26BB 61 PUSH2 0x26c3 26BE 81 DUP2 26BF 61 PUSH2 0x232b 26C2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @26BB stack[0] = 0x26c3 // @26BE stack[1] = stack[-1] // } // Block ends with call to 0x232b, returns to 0x26C3 label_26C3: // Incoming return from call to 0x232B at 0x26C2 // Inputs[4] // { // @26C4 stack[-4] // @26C5 stack[-1] // @26C6 stack[-2] // @26C7 stack[-5] // } 26C3 5B JUMPDEST 26C4 83 DUP4 26C5 52 MSTORE 26C6 91 SWAP2 26C7 83 DUP4 26C8 01 ADD 26C9 91 SWAP2 26CA 83 DUP4 26CB 01 ADD 26CC 61 PUSH2 0x26b2 26CF 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @26C5 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @26C9 stack[-4] = stack[-5] + stack[-4] // @26CB stack[-2] = stack[-5] + stack[-2] // } // Block ends with unconditional jump to 0x26b2 label_26D0: // Incoming jump from 0x033D // Inputs[2] // { // @26D6 stack[-1] // @26D7 stack[-2] // } 26D0 5B JUMPDEST 26D1 60 PUSH1 0x00 26D3 80 DUP1 26D4 60 PUSH1 0x40 26D6 83 DUP4 26D7 85 DUP6 26D8 03 SUB 26D9 12 SLT 26DA 15 ISZERO 26DB 61 PUSH2 0x26e3 26DE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @26D1 stack[0] = 0x00 // @26D3 stack[1] = 0x00 // } // Block ends with conditional jump to 0x26e3, if !(stack[-2] - stack[-1] i< 0x40) label_26DF: // Incoming jump from 0x26DE, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @26E2 memory[0x00:0x00] } 26DF 60 PUSH1 0x00 26E1 80 DUP1 26E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @26E2 revert(memory[0x00:0x00]); } // Block terminates label_26E3: // Incoming jump from 0x26DE, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @26E4 stack[-3] // @26E5 msg.data[stack[-3]:stack[-3] + 0x20] // } 26E3 5B JUMPDEST 26E4 82 DUP3 26E5 35 CALLDATALOAD 26E6 67 PUSH8 0xffffffffffffffff 26EF 80 DUP1 26F0 82 DUP3 26F1 11 GT 26F2 15 ISZERO 26F3 61 PUSH2 0x26fb 26F6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @26E5 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @26E6 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x26fb, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_26F7: // Incoming jump from 0x26F6, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @26FA memory[0x00:0x00] } 26F7 60 PUSH1 0x00 26F9 80 DUP1 26FA FD *REVERT // Stack delta = +0 // Outputs[1] { @26FA revert(memory[0x00:0x00]); } // Block terminates label_26FB: // Incoming jump from 0x26F6, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @26FF stack[-6] // @2700 stack[-2] // @2701 stack[-5] // } 26FB 5B JUMPDEST 26FC 61 PUSH2 0x2707 26FF 86 DUP7 2700 83 DUP4 2701 87 DUP8 2702 01 ADD 2703 61 PUSH2 0x2663 2706 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @26FC stack[0] = 0x2707 // @26FF stack[1] = stack[-6] // @2702 stack[2] = stack[-5] + stack[-2] // } // Block ends with call to 0x2663, returns to 0x2707 label_2707: // Incoming return from call to 0x2663 at 0x2706 // Inputs[6] // { // @2708 stack[-1] // @2708 stack[-5] // @270C stack[-6] // @270E msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @270F stack[-3] // @2711 stack[-2] // } 2707 5B JUMPDEST 2708 93 SWAP4 2709 50 POP 270A 60 PUSH1 0x20 270C 85 DUP6 270D 01 ADD 270E 35 CALLDATALOAD 270F 91 SWAP2 2710 50 POP 2711 80 DUP1 2712 82 DUP3 2713 11 GT 2714 15 ISZERO 2715 61 PUSH2 0x271d 2718 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2708 stack[-5] = stack[-1] // @270F stack[-3] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x271d, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) label_2719: // Incoming jump from 0x2718, if not !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) // Inputs[1] { @271C memory[0x00:0x00] } 2719 60 PUSH1 0x00 271B 80 DUP1 271C FD *REVERT // Stack delta = +0 // Outputs[1] { @271C revert(memory[0x00:0x00]); } // Block terminates label_271D: // Incoming jump from 0x2718, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @2722 stack[-6] // @2723 stack[-2] // @2724 stack[-5] // } 271D 5B JUMPDEST 271E 50 POP 271F 61 PUSH2 0x272a 2722 85 DUP6 2723 82 DUP3 2724 86 DUP7 2725 01 ADD 2726 61 PUSH2 0x24b1 2729 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @271F stack[-1] = 0x272a // @2722 stack[0] = stack[-6] // @2725 stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x24b1, returns to 0x272A label_272A: // Incoming return from call to 0x24B1 at 0x2729 // Incoming return from call to 0x2522 at 0x2924 // Inputs[6] // { // @272B stack[-1] // @272B stack[-3] // @272E stack[-6] // @2730 stack[-7] // @2730 stack[-4] // @2731 stack[-5] // } 272A 5B JUMPDEST 272B 91 SWAP2 272C 50 POP 272D 50 POP 272E 92 SWAP3 272F 50 POP 2730 92 SWAP3 2731 90 SWAP1 2732 50 POP 2733 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @272E stack[-6] = stack[-1] // @2730 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2734: // Incoming call from 0x2BEE, returns to 0x2BEF // Incoming call from 0x2CDF, returns to 0x2CE0 // Incoming call from 0x2C00, returns to 0x2C01 // Incoming call from 0x2CCD, returns to 0x2CCE // Inputs[3] // { // @2737 stack[-1] // @2738 memory[stack[-1]:stack[-1] + 0x20] // @273A stack[-2] // } 2734 5B JUMPDEST 2735 60 PUSH1 0x00 2737 81 DUP2 2738 51 MLOAD 2739 80 DUP1 273A 84 DUP5 273B 52 MSTORE 273C 60 PUSH1 0x20 273E 80 DUP1 273F 85 DUP6 2740 01 ADD 2741 94 SWAP5 2742 50 POP 2743 80 DUP1 2744 84 DUP5 2745 01 ADD 2746 60 PUSH1 0x00 2748 5B JUMPDEST 2749 83 DUP4 274A 81 DUP2 274B 10 LT 274C 15 ISZERO 274D 61 PUSH2 0x2764 2750 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @2735 stack[0] = 0x00 // @2738 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @273B memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @273C stack[2] = 0x20 // @2741 stack[-2] = stack[-2] + 0x20 // @2745 stack[3] = stack[-1] + 0x20 // @2746 stack[4] = 0x00 // } // Block ends with conditional jump to 0x2764, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_2751: // Incoming jump from 0x2750, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2750, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @2751 stack[-2] // @2752 memory[stack[-2]:stack[-2] + 0x20] // @2753 stack[-7] // @2755 stack[-1] // @2756 stack[-3] // } 2751 81 DUP2 2752 51 MLOAD 2753 87 DUP8 2754 52 MSTORE 2755 95 SWAP6 2756 82 DUP3 2757 01 ADD 2758 95 SWAP6 2759 90 SWAP1 275A 82 DUP3 275B 01 ADD 275C 90 SWAP1 275D 60 PUSH1 0x01 275F 01 ADD 2760 61 PUSH2 0x2748 2763 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2754 memory[stack[-7]:stack[-7] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @2758 stack[-7] = stack[-3] + stack[-7] // @275C stack[-2] = stack[-3] + stack[-2] // @275F stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2748 label_2764: // Incoming jump from 0x2750, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2750, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @2766 stack[-7] // @2766 stack[-2] // @2767 stack[-8] // } 2764 5B JUMPDEST 2765 50 POP 2766 94 SWAP5 2767 95 SWAP6 2768 94 SWAP5 2769 50 POP 276A 50 POP 276B 50 POP 276C 50 POP 276D 50 POP 276E 56 *JUMP // Stack delta = -7 // Outputs[1] { @2767 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] 276F 5B JUMPDEST 2770 60 PUSH1 0x20 2772 81 DUP2 2773 52 MSTORE 2774 60 PUSH1 0x00 2776 61 PUSH2 0x1ba4 2779 60 PUSH1 0x20 277B 83 DUP4 277C 01 ADD 277D 84 DUP5 277E 61 PUSH2 0x2734 2781 56 *JUMP label_2782: // Incoming call from 0x037F, returns to 0x0380 // Inputs[2] // { // @278D stack[-1] // @278E stack[-2] // } 2782 5B JUMPDEST 2783 60 PUSH1 0x00 2785 80 DUP1 2786 60 PUSH1 0x00 2788 80 DUP1 2789 60 PUSH1 0x00 278B 60 PUSH1 0x80 278D 86 DUP7 278E 88 DUP9 278F 03 SUB 2790 12 SLT 2791 15 ISZERO 2792 61 PUSH2 0x279a 2795 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2783 stack[0] = 0x00 // @2785 stack[1] = 0x00 // @2786 stack[2] = 0x00 // @2788 stack[3] = 0x00 // @2789 stack[4] = 0x00 // } // Block ends with conditional jump to 0x279a, if !(stack[-2] - stack[-1] i< 0x80) label_2796: // Incoming jump from 0x2795, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2799 memory[0x00:0x00] } 2796 60 PUSH1 0x00 2798 80 DUP1 2799 FD *REVERT // Stack delta = +0 // Outputs[1] { @2799 revert(memory[0x00:0x00]); } // Block terminates label_279A: // Incoming jump from 0x2795, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @279B stack[-6] // @279C msg.data[stack[-6]:stack[-6] + 0x20] // } 279A 5B JUMPDEST 279B 85 DUP6 279C 35 CALLDATALOAD 279D 67 PUSH8 0xffffffffffffffff 27A6 80 DUP1 27A7 82 DUP3 27A8 11 GT 27A9 15 ISZERO 27AA 61 PUSH2 0x27b2 27AD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @279C stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @279D stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x27b2, if !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) label_27AE: // Incoming jump from 0x27AD, if not !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @27B1 memory[0x00:0x00] } 27AE 60 PUSH1 0x00 27B0 80 DUP1 27B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @27B1 revert(memory[0x00:0x00]); } // Block terminates label_27B2: // Incoming jump from 0x27AD, if !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @27B3 stack[-2] // @27B4 stack[-8] // @27B8 stack[-9] // } 27B2 5B JUMPDEST 27B3 81 DUP2 27B4 88 DUP9 27B5 01 ADD 27B6 91 SWAP2 27B7 50 POP 27B8 88 DUP9 27B9 60 PUSH1 0x1f 27BB 83 DUP4 27BC 01 ADD 27BD 12 SLT 27BE 61 PUSH2 0x27c6 27C1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @27B6 stack[-2] = stack[-8] + stack[-2] } // Block ends with conditional jump to 0x27c6, if stack[-8] + stack[-2] + 0x1f i< stack[-9] label_27C2: // Incoming jump from 0x27C1, if not stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[1] { @27C5 memory[0x00:0x00] } 27C2 60 PUSH1 0x00 27C4 80 DUP1 27C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @27C5 revert(memory[0x00:0x00]); } // Block terminates label_27C6: // Incoming jump from 0x27C1, if stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[3] // { // @27C7 stack[-2] // @27C8 msg.data[stack[-2]:stack[-2] + 0x20] // @27C9 stack[-1] // } 27C6 5B JUMPDEST 27C7 81 DUP2 27C8 35 CALLDATALOAD 27C9 81 DUP2 27CA 81 DUP2 27CB 11 GT 27CC 15 ISZERO 27CD 61 PUSH2 0x27d5 27D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27C8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x27d5, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_27D1: // Incoming jump from 0x27D0, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @27D4 memory[0x00:0x00] } 27D1 60 PUSH1 0x00 27D3 80 DUP1 27D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @27D4 revert(memory[0x00:0x00]); } // Block terminates label_27D5: // Incoming jump from 0x27D0, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @27D6 stack[-10] // @27D9 stack[-1] // @27DD stack[-3] // } 27D5 5B JUMPDEST 27D6 89 DUP10 27D7 60 PUSH1 0x20 27D9 82 DUP3 27DA 60 PUSH1 0x05 27DC 1B SHL 27DD 85 DUP6 27DE 01 ADD 27DF 01 ADD 27E0 11 GT 27E1 15 ISZERO 27E2 61 PUSH2 0x27ea 27E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x27ea, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) label_27E6: // Incoming jump from 0x27E5, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) // Inputs[1] { @27E9 memory[0x00:0x00] } 27E6 60 PUSH1 0x00 27E8 80 DUP1 27E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @27E9 revert(memory[0x00:0x00]); } // Block terminates label_27EA: // Incoming jump from 0x27E5, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) // Inputs[11] // { // @27ED stack[-3] // @27F0 stack[-8] // @27F2 stack[-7] // @27F2 stack[-1] // @27F4 stack[-2] // @27F5 stack[-9] // @27F7 msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @27F8 stack[-6] // @27FE msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @27FF stack[-5] // @2805 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } 27EA 5B JUMPDEST 27EB 60 PUSH1 0x20 27ED 92 SWAP3 27EE 83 DUP4 27EF 01 ADD 27F0 97 SWAP8 27F1 50 POP 27F2 95 SWAP6 27F3 50 POP 27F4 90 SWAP1 27F5 87 DUP8 27F6 01 ADD 27F7 35 CALLDATALOAD 27F8 93 SWAP4 27F9 50 POP 27FA 60 PUSH1 0x40 27FC 87 DUP8 27FD 01 ADD 27FE 35 CALLDATALOAD 27FF 92 SWAP3 2800 50 POP 2801 60 PUSH1 0x60 2803 87 DUP8 2804 01 ADD 2805 35 CALLDATALOAD 2806 90 SWAP1 2807 80 DUP1 2808 82 DUP3 2809 11 GT 280A 15 ISZERO 280B 61 PUSH2 0x2626 280E 57 *JUMPI // Stack delta = -1 // Outputs[6] // { // @27F0 stack[-8] = 0x20 + stack[-3] // @27F2 stack[-7] = stack[-1] // @27F8 stack[-6] = msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @27FF stack[-5] = msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @2806 stack[-2] = stack[-2] // @2806 stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2626, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_280F: // Incoming jump from 0x280E, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[1] { @2812 memory[0x00:0x00] } 280F 60 PUSH1 0x00 2811 80 DUP1 2812 FD *REVERT // Stack delta = +0 // Outputs[1] { @2812 revert(memory[0x00:0x00]); } // Block terminates label_2813: // Incoming call from 0x0392, returns to 0x0393 // Inputs[2] // { // @281B stack[-1] // @281C stack[-2] // } 2813 5B JUMPDEST 2814 60 PUSH1 0x00 2816 80 DUP1 2817 60 PUSH1 0x00 2819 60 PUSH1 0x60 281B 84 DUP5 281C 86 DUP7 281D 03 SUB 281E 12 SLT 281F 15 ISZERO 2820 61 PUSH2 0x2828 2823 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2814 stack[0] = 0x00 // @2816 stack[1] = 0x00 // @2817 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2828, if !(stack[-2] - stack[-1] i< 0x60) label_2824: // Incoming jump from 0x2823, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2827 memory[0x00:0x00] } 2824 60 PUSH1 0x00 2826 80 DUP1 2827 FD *REVERT // Stack delta = +0 // Outputs[1] { @2827 revert(memory[0x00:0x00]); } // Block terminates label_2828: // Incoming jump from 0x2823, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @282C stack[-4] } 2828 5B JUMPDEST 2829 61 PUSH2 0x2831 282C 84 DUP5 282D 61 PUSH2 0x232b 2830 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2829 stack[0] = 0x2831 // @282C stack[1] = stack[-4] // } // Block ends with call to 0x232b, returns to 0x2831 label_2831: // Incoming return from call to 0x232B at 0x2830 // Inputs[4] // { // @2832 stack[-1] // @2832 stack[-4] // @2836 stack[-5] // @2838 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 2831 5B JUMPDEST 2832 92 SWAP3 2833 50 POP 2834 60 PUSH1 0x20 2836 84 DUP5 2837 01 ADD 2838 35 CALLDATALOAD 2839 67 PUSH8 0xffffffffffffffff 2842 80 DUP1 2843 82 DUP3 2844 11 GT 2845 15 ISZERO 2846 61 PUSH2 0x284e 2849 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2832 stack[-4] = stack[-1] // @2838 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2839 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x284e, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_284A: // Incoming jump from 0x2849, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @284D memory[0x00:0x00] } 284A 60 PUSH1 0x00 284C 80 DUP1 284D FD *REVERT // Stack delta = +0 // Outputs[1] { @284D revert(memory[0x00:0x00]); } // Block terminates label_284E: // Incoming jump from 0x2849, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2852 stack[-7] // @2853 stack[-2] // @2854 stack[-6] // } 284E 5B JUMPDEST 284F 61 PUSH2 0x285a 2852 87 DUP8 2853 83 DUP4 2854 88 DUP9 2855 01 ADD 2856 61 PUSH2 0x24b1 2859 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @284F stack[0] = 0x285a // @2852 stack[1] = stack[-7] // @2855 stack[2] = stack[-6] + stack[-2] // } // Block ends with call to 0x24b1, returns to 0x285A label_285A: // Incoming return from call to 0x24B1 at 0x2859 // Inputs[6] // { // @285B stack[-5] // @285B stack[-1] // @285F stack[-7] // @2861 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2862 stack[-3] // @2864 stack[-2] // } 285A 5B JUMPDEST 285B 93 SWAP4 285C 50 POP 285D 60 PUSH1 0x40 285F 86 DUP7 2860 01 ADD 2861 35 CALLDATALOAD 2862 91 SWAP2 2863 50 POP 2864 80 DUP1 2865 82 DUP3 2866 11 GT 2867 15 ISZERO 2868 61 PUSH2 0x2870 286B 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @285B stack[-5] = stack[-1] // @2862 stack[-3] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x2870, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) label_286C: // Incoming jump from 0x286B, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) // Inputs[1] { @286F memory[0x00:0x00] } 286C 60 PUSH1 0x00 286E 80 DUP1 286F FD *REVERT // Stack delta = +0 // Outputs[1] { @286F revert(memory[0x00:0x00]); } // Block terminates label_2870: // Incoming jump from 0x286B, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) // Inputs[3] // { // @2875 stack[-7] // @2876 stack[-2] // @2877 stack[-6] // } 2870 5B JUMPDEST 2871 50 POP 2872 61 PUSH2 0x287d 2875 86 DUP7 2876 82 DUP3 2877 87 DUP8 2878 01 ADD 2879 61 PUSH2 0x24b1 287C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2872 stack[-1] = 0x287d // @2875 stack[0] = stack[-7] // @2878 stack[1] = stack[-6] + stack[-2] // } // Block ends with call to 0x24b1, returns to 0x287D label_287D: // Incoming return from call to 0x24B1 at 0x287C // Inputs[7] // { // @287E stack[-3] // @287E stack[-1] // @2881 stack[-6] // @2883 stack[-7] // @2883 stack[-4] // @2885 stack[-8] // @2885 stack[-5] // } 287D 5B JUMPDEST 287E 91 SWAP2 287F 50 POP 2880 50 POP 2881 92 SWAP3 2882 50 POP 2883 92 SWAP3 2884 50 POP 2885 92 SWAP3 2886 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @2881 stack[-6] = stack[-1] // @2883 stack[-7] = stack[-4] // @2885 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_2887: // Incoming call from 0x03AD, returns to 0x03AE // Inputs[2] // { // @2890 stack[-1] // @2891 stack[-2] // } 2887 5B JUMPDEST 2888 60 PUSH1 0x00 288A 80 DUP1 288B 60 PUSH1 0x00 288D 80 DUP1 288E 60 PUSH1 0x80 2890 85 DUP6 2891 87 DUP8 2892 03 SUB 2893 12 SLT 2894 15 ISZERO 2895 61 PUSH2 0x289d 2898 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2888 stack[0] = 0x00 // @288A stack[1] = 0x00 // @288B stack[2] = 0x00 // @288D stack[3] = 0x00 // } // Block ends with conditional jump to 0x289d, if !(stack[-2] - stack[-1] i< 0x80) label_2899: // Incoming jump from 0x2898, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @289C memory[0x00:0x00] } 2899 60 PUSH1 0x00 289B 80 DUP1 289C FD *REVERT // Stack delta = +0 // Outputs[1] { @289C revert(memory[0x00:0x00]); } // Block terminates label_289D: // Incoming jump from 0x2898, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @28A1 stack[-5] } 289D 5B JUMPDEST 289E 61 PUSH2 0x28a6 28A1 85 DUP6 28A2 61 PUSH2 0x232b 28A5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @289E stack[0] = 0x28a6 // @28A1 stack[1] = stack[-5] // } // Block ends with call to 0x232b, returns to 0x28A6 label_28A6: // Incoming return from call to 0x232B at 0x28A5 // Inputs[8] // { // @28A7 stack[-5] // @28A7 stack[-1] // @28AB stack[-6] // @28AD msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @28AE stack[-4] // @28B4 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @28B5 stack[-3] // @28BB msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 28A6 5B JUMPDEST 28A7 93 SWAP4 28A8 50 POP 28A9 60 PUSH1 0x20 28AB 85 DUP6 28AC 01 ADD 28AD 35 CALLDATALOAD 28AE 92 SWAP3 28AF 50 POP 28B0 60 PUSH1 0x40 28B2 85 DUP6 28B3 01 ADD 28B4 35 CALLDATALOAD 28B5 91 SWAP2 28B6 50 POP 28B7 60 PUSH1 0x60 28B9 85 DUP6 28BA 01 ADD 28BB 35 CALLDATALOAD 28BC 67 PUSH8 0xffffffffffffffff 28C5 81 DUP2 28C6 11 GT 28C7 15 ISZERO 28C8 61 PUSH2 0x28d0 28CB 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @28A7 stack[-5] = stack[-1] // @28AE stack[-4] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @28B5 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @28BB stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x28d0, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_28CC: // Incoming jump from 0x28CB, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @28CF memory[0x00:0x00] } 28CC 60 PUSH1 0x00 28CE 80 DUP1 28CF FD *REVERT // Stack delta = +0 // Outputs[1] { @28CF revert(memory[0x00:0x00]); } // Block terminates label_28D0: // Incoming jump from 0x28CB, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @28D4 stack[-7] // @28D5 stack[-1] // @28D6 stack[-6] // } 28D0 5B JUMPDEST 28D1 61 PUSH2 0x28dc 28D4 87 DUP8 28D5 82 DUP3 28D6 88 DUP9 28D7 01 ADD 28D8 61 PUSH2 0x2522 28DB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @28D1 stack[0] = 0x28dc // @28D4 stack[1] = stack[-7] // @28D7 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x2522, returns to 0x28DC label_28DC: // Incoming return from call to 0x2522 at 0x29AA // Incoming return from call to 0x2522 at 0x28DB // Inputs[8] // { // @28DD stack[-3] // @28DD stack[-1] // @28E0 stack[-6] // @28E1 stack[-9] // @28E2 stack[-5] // @28E3 stack[-8] // @28E5 stack[-7] // @28E5 stack[-4] // } 28DC 5B JUMPDEST 28DD 91 SWAP2 28DE 50 POP 28DF 50 POP 28E0 92 SWAP3 28E1 95 SWAP6 28E2 91 SWAP2 28E3 94 SWAP5 28E4 50 POP 28E5 92 SWAP3 28E6 50 POP 28E7 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @28E0 stack[-6] = stack[-1] // @28E1 stack[-9] = stack[-6] // @28E3 stack[-8] = stack[-5] // @28E5 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_28E8: // Incoming call from 0x03C0, returns to 0x03C1 // Inputs[2] // { // @28EE stack[-1] // @28EF stack[-2] // } 28E8 5B JUMPDEST 28E9 60 PUSH1 0x00 28EB 80 DUP1 28EC 60 PUSH1 0x40 28EE 83 DUP4 28EF 85 DUP6 28F0 03 SUB 28F1 12 SLT 28F2 15 ISZERO 28F3 61 PUSH2 0x28fb 28F6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28E9 stack[0] = 0x00 // @28EB stack[1] = 0x00 // } // Block ends with conditional jump to 0x28fb, if !(stack[-2] - stack[-1] i< 0x40) label_28F7: // Incoming jump from 0x28F6, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28FA memory[0x00:0x00] } 28F7 60 PUSH1 0x00 28F9 80 DUP1 28FA FD *REVERT // Stack delta = +0 // Outputs[1] { @28FA revert(memory[0x00:0x00]); } // Block terminates label_28FB: // Incoming jump from 0x28F6, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @28FC stack[-3] // @28FD msg.data[stack[-3]:stack[-3] + 0x20] // @28FE stack[-2] // @2904 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 28FB 5B JUMPDEST 28FC 82 DUP3 28FD 35 CALLDATALOAD 28FE 91 SWAP2 28FF 50 POP 2900 60 PUSH1 0x20 2902 83 DUP4 2903 01 ADD 2904 35 CALLDATALOAD 2905 67 PUSH8 0xffffffffffffffff 290E 81 DUP2 290F 11 GT 2910 15 ISZERO 2911 61 PUSH2 0x2919 2914 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @28FE stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @2904 stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2919, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) label_2915: // Incoming jump from 0x2914, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2918 memory[0x00:0x00] } 2915 60 PUSH1 0x00 2917 80 DUP1 2918 FD *REVERT // Stack delta = +0 // Outputs[1] { @2918 revert(memory[0x00:0x00]); } // Block terminates label_2919: // Incoming jump from 0x2914, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @291D stack[-5] // @291E stack[-1] // @291F stack[-4] // } 2919 5B JUMPDEST 291A 61 PUSH2 0x272a 291D 85 DUP6 291E 82 DUP3 291F 86 DUP7 2920 01 ADD 2921 61 PUSH2 0x2522 2924 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @291A stack[0] = 0x272a // @291D stack[1] = stack[-5] // @2920 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x2522, returns to 0x272A label_2925: // Incoming jump from 0x03D3 // Inputs[2] // { // @292E stack[-1] // @292F stack[-2] // } 2925 5B JUMPDEST 2926 60 PUSH1 0x00 2928 80 DUP1 2929 60 PUSH1 0x00 292B 80 DUP1 292C 60 PUSH1 0x80 292E 85 DUP6 292F 87 DUP8 2930 03 SUB 2931 12 SLT 2932 15 ISZERO 2933 61 PUSH2 0x293b 2936 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2926 stack[0] = 0x00 // @2928 stack[1] = 0x00 // @2929 stack[2] = 0x00 // @292B stack[3] = 0x00 // } // Block ends with conditional jump to 0x293b, if !(stack[-2] - stack[-1] i< 0x80) label_2937: // Incoming jump from 0x2936, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @293A memory[0x00:0x00] } 2937 60 PUSH1 0x00 2939 80 DUP1 293A FD *REVERT // Stack delta = +0 // Outputs[1] { @293A revert(memory[0x00:0x00]); } // Block terminates label_293B: // Incoming jump from 0x2936, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @293C stack[-5] // @293D msg.data[stack[-5]:stack[-5] + 0x20] // } 293B 5B JUMPDEST 293C 84 DUP5 293D 35 CALLDATALOAD 293E 67 PUSH8 0xffffffffffffffff 2947 80 DUP1 2948 82 DUP3 2949 11 GT 294A 15 ISZERO 294B 61 PUSH2 0x2953 294E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @293D stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @293E stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2953, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) label_294F: // Incoming jump from 0x294E, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2952 memory[0x00:0x00] } 294F 60 PUSH1 0x00 2951 80 DUP1 2952 FD *REVERT // Stack delta = +0 // Outputs[1] { @2952 revert(memory[0x00:0x00]); } // Block terminates label_2953: // Incoming jump from 0x294E, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2957 stack[-8] // @2958 stack[-2] // @2959 stack[-7] // } 2953 5B JUMPDEST 2954 61 PUSH2 0x295f 2957 88 DUP9 2958 83 DUP4 2959 89 DUP10 295A 01 ADD 295B 61 PUSH2 0x2663 295E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2954 stack[0] = 0x295f // @2957 stack[1] = stack[-8] // @295A stack[2] = stack[-7] + stack[-2] // } // Block ends with call to 0x2663, returns to 0x295F label_295F: // Incoming return from call to 0x2663 at 0x295E // Inputs[6] // { // @2960 stack[-7] // @2960 stack[-1] // @2964 stack[-8] // @2966 msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // @2967 stack[-3] // @2969 stack[-2] // } 295F 5B JUMPDEST 2960 95 SWAP6 2961 50 POP 2962 60 PUSH1 0x20 2964 87 DUP8 2965 01 ADD 2966 35 CALLDATALOAD 2967 91 SWAP2 2968 50 POP 2969 80 DUP1 296A 82 DUP3 296B 11 GT 296C 15 ISZERO 296D 61 PUSH2 0x2975 2970 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2960 stack[-7] = stack[-1] // @2967 stack[-3] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2975, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > stack[-2]) label_2971: // Incoming jump from 0x2970, if not !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > stack[-2]) // Inputs[1] { @2974 memory[0x00:0x00] } 2971 60 PUSH1 0x00 2973 80 DUP1 2974 FD *REVERT // Stack delta = +0 // Outputs[1] { @2974 revert(memory[0x00:0x00]); } // Block terminates label_2975: // Incoming jump from 0x2970, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @2979 stack[-8] // @297A stack[-2] // @297B stack[-7] // } 2975 5B JUMPDEST 2976 61 PUSH2 0x2981 2979 88 DUP9 297A 83 DUP4 297B 89 DUP10 297C 01 ADD 297D 61 PUSH2 0x24b1 2980 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2976 stack[0] = 0x2981 // @2979 stack[1] = stack[-8] // @297C stack[2] = stack[-7] + stack[-2] // } // Block ends with call to 0x24b1, returns to 0x2981 label_2981: // Incoming return from call to 0x24B1 at 0x2980 // Inputs[8] // { // @2982 stack[-1] // @2982 stack[-6] // @2986 stack[-8] // @2988 msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @2989 stack[-5] // @298F msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // @2990 stack[-3] // @2992 stack[-2] // } 2981 5B JUMPDEST 2982 94 SWAP5 2983 50 POP 2984 60 PUSH1 0x40 2986 87 DUP8 2987 01 ADD 2988 35 CALLDATALOAD 2989 93 SWAP4 298A 50 POP 298B 60 PUSH1 0x60 298D 87 DUP8 298E 01 ADD 298F 35 CALLDATALOAD 2990 91 SWAP2 2991 50 POP 2992 80 DUP1 2993 82 DUP3 2994 11 GT 2995 15 ISZERO 2996 61 PUSH2 0x299e 2999 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @2982 stack[-6] = stack[-1] // @2989 stack[-5] = msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @2990 stack[-3] = msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x299e, if !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > stack[-2]) label_299A: // Incoming jump from 0x2999, if not !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > stack[-2]) // Inputs[1] { @299D memory[0x00:0x00] } 299A 60 PUSH1 0x00 299C 80 DUP1 299D FD *REVERT // Stack delta = +0 // Outputs[1] { @299D revert(memory[0x00:0x00]); } // Block terminates label_299E: // Incoming jump from 0x2999, if !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @29A3 stack[-8] // @29A4 stack[-2] // @29A5 stack[-7] // } 299E 5B JUMPDEST 299F 50 POP 29A0 61 PUSH2 0x28dc 29A3 87 DUP8 29A4 82 DUP3 29A5 88 DUP9 29A6 01 ADD 29A7 61 PUSH2 0x2522 29AA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @29A0 stack[-1] = 0x28dc // @29A3 stack[0] = stack[-8] // @29A6 stack[1] = stack[-7] + stack[-2] // } // Block ends with call to 0x2522, returns to 0x28DC label_29AB: // Incoming call from 0x0442, returns to 0x0443 // Inputs[2] // { // @29B1 stack[-1] // @29B2 stack[-2] // } 29AB 5B JUMPDEST 29AC 60 PUSH1 0x00 29AE 80 DUP1 29AF 60 PUSH1 0x40 29B1 83 DUP4 29B2 85 DUP6 29B3 03 SUB 29B4 12 SLT 29B5 15 ISZERO 29B6 61 PUSH2 0x29be 29B9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @29AC stack[0] = 0x00 // @29AE stack[1] = 0x00 // } // Block ends with conditional jump to 0x29be, if !(stack[-2] - stack[-1] i< 0x40) label_29BA: // Incoming jump from 0x29B9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @29BD memory[0x00:0x00] } 29BA 60 PUSH1 0x00 29BC 80 DUP1 29BD FD *REVERT // Stack delta = +0 // Outputs[1] { @29BD revert(memory[0x00:0x00]); } // Block terminates label_29BE: // Incoming jump from 0x29B9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @29C2 stack[-3] } 29BE 5B JUMPDEST 29BF 61 PUSH2 0x29c7 29C2 83 DUP4 29C3 61 PUSH2 0x232b 29C6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @29BF stack[0] = 0x29c7 // @29C2 stack[1] = stack[-3] // } // Block ends with call to 0x232b, returns to 0x29C7 label_29C7: // Incoming return from call to 0x232B at 0x29C6 // Inputs[4] // { // @29C8 stack[-3] // @29C8 stack[-1] // @29CC stack[-4] // @29CE msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 29C7 5B JUMPDEST 29C8 91 SWAP2 29C9 50 POP 29CA 60 PUSH1 0x20 29CC 83 DUP4 29CD 01 ADD 29CE 35 CALLDATALOAD 29CF 80 DUP1 29D0 15 ISZERO 29D1 15 ISZERO 29D2 81 DUP2 29D3 14 EQ 29D4 61 PUSH2 0x29dc 29D7 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @29C8 stack[-3] = stack[-1] // @29CE stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x29dc, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_29D8: // Incoming jump from 0x29D7, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @29DB memory[0x00:0x00] } 29D8 60 PUSH1 0x00 29DA 80 DUP1 29DB FD *REVERT // Stack delta = +0 // Outputs[1] { @29DB revert(memory[0x00:0x00]); } // Block terminates label_29DC: // Incoming jump from 0x29D7, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @29DD stack[-1] // @29DE stack[-2] // @29E1 stack[-5] // @29E3 stack[-6] // @29E3 stack[-3] // @29E4 stack[-4] // } 29DC 5B JUMPDEST 29DD 80 DUP1 29DE 91 SWAP2 29DF 50 POP 29E0 50 POP 29E1 92 SWAP3 29E2 50 POP 29E3 92 SWAP3 29E4 90 SWAP1 29E5 50 POP 29E6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @29E1 stack[-5] = stack[-1] // @29E3 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_29E7: // Incoming jump from 0x049B // Inputs[2] // { // @29ED stack[-1] // @29EE stack[-2] // } 29E7 5B JUMPDEST 29E8 60 PUSH1 0x00 29EA 80 DUP1 29EB 60 PUSH1 0x40 29ED 83 DUP4 29EE 85 DUP6 29EF 03 SUB 29F0 12 SLT 29F1 15 ISZERO 29F2 61 PUSH2 0x29fa 29F5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @29E8 stack[0] = 0x00 // @29EA stack[1] = 0x00 // } // Block ends with conditional jump to 0x29fa, if !(stack[-2] - stack[-1] i< 0x40) label_29F6: // Incoming jump from 0x29F5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @29F9 memory[0x00:0x00] } 29F6 60 PUSH1 0x00 29F8 80 DUP1 29F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @29F9 revert(memory[0x00:0x00]); } // Block terminates label_29FA: // Incoming jump from 0x29F5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @29FE stack[-3] } 29FA 5B JUMPDEST 29FB 61 PUSH2 0x2a03 29FE 83 DUP4 29FF 61 PUSH2 0x232b 2A02 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @29FB stack[0] = 0x2a03 // @29FE stack[1] = stack[-3] // } // Block ends with call to 0x232b, returns to 0x2A03 label_2A03: // Incoming return from call to 0x232B at 0x2A02 // Inputs[3] // { // @2A04 stack[-3] // @2A04 stack[-1] // @2A0B stack[-4] // } 2A03 5B JUMPDEST 2A04 91 SWAP2 2A05 50 POP 2A06 61 PUSH2 0x06f1 2A09 60 PUSH1 0x20 2A0B 84 DUP5 2A0C 01 ADD 2A0D 61 PUSH2 0x232b 2A10 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2A04 stack[-3] = stack[-1] // @2A06 stack[-1] = 0x06f1 // @2A0C stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x232b, returns to 0x06F1 label_2A11: // Incoming jump from 0x04FE // Inputs[2] // { // @2A1C stack[-1] // @2A1D stack[-2] // } 2A11 5B JUMPDEST 2A12 60 PUSH1 0x00 2A14 80 DUP1 2A15 60 PUSH1 0x00 2A17 80 DUP1 2A18 60 PUSH1 0x00 2A1A 60 PUSH1 0xa0 2A1C 86 DUP7 2A1D 88 DUP9 2A1E 03 SUB 2A1F 12 SLT 2A20 15 ISZERO 2A21 61 PUSH2 0x2a29 2A24 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2A12 stack[0] = 0x00 // @2A14 stack[1] = 0x00 // @2A15 stack[2] = 0x00 // @2A17 stack[3] = 0x00 // @2A18 stack[4] = 0x00 // } // Block ends with conditional jump to 0x2a29, if !(stack[-2] - stack[-1] i< 0xa0) label_2A25: // Incoming jump from 0x2A24, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @2A28 memory[0x00:0x00] } 2A25 60 PUSH1 0x00 2A27 80 DUP1 2A28 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A28 revert(memory[0x00:0x00]); } // Block terminates label_2A29: // Incoming jump from 0x2A24, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @2A2D stack[-6] } 2A29 5B JUMPDEST 2A2A 61 PUSH2 0x2a32 2A2D 86 DUP7 2A2E 61 PUSH2 0x232b 2A31 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2A2A stack[0] = 0x2a32 // @2A2D stack[1] = stack[-6] // } // Block ends with call to 0x232b, returns to 0x2A32 label_2A32: // Incoming return from call to 0x232B at 0x2A31 // Inputs[3] // { // @2A33 stack[-1] // @2A33 stack[-6] // @2A3A stack[-7] // } 2A32 5B JUMPDEST 2A33 94 SWAP5 2A34 50 POP 2A35 61 PUSH2 0x2a40 2A38 60 PUSH1 0x20 2A3A 87 DUP8 2A3B 01 ADD 2A3C 61 PUSH2 0x232b 2A3F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2A33 stack[-6] = stack[-1] // @2A35 stack[-1] = 0x2a40 // @2A3B stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x232b, returns to 0x2A40 label_2A40: // Incoming return from call to 0x232B at 0x2A3F // Inputs[8] // { // @2A41 stack[-5] // @2A41 stack[-1] // @2A45 stack[-7] // @2A47 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2A48 stack[-4] // @2A4E msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @2A4F stack[-3] // @2A55 msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 2A40 5B JUMPDEST 2A41 93 SWAP4 2A42 50 POP 2A43 60 PUSH1 0x40 2A45 86 DUP7 2A46 01 ADD 2A47 35 CALLDATALOAD 2A48 92 SWAP3 2A49 50 POP 2A4A 60 PUSH1 0x60 2A4C 86 DUP7 2A4D 01 ADD 2A4E 35 CALLDATALOAD 2A4F 91 SWAP2 2A50 50 POP 2A51 60 PUSH1 0x80 2A53 86 DUP7 2A54 01 ADD 2A55 35 CALLDATALOAD 2A56 67 PUSH8 0xffffffffffffffff 2A5F 81 DUP2 2A60 11 GT 2A61 15 ISZERO 2A62 61 PUSH2 0x2a6a 2A65 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2A41 stack[-5] = stack[-1] // @2A48 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2A4F stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @2A55 stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x2a6a, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) label_2A66: // Incoming jump from 0x2A65, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2A69 memory[0x00:0x00] } 2A66 60 PUSH1 0x00 2A68 80 DUP1 2A69 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A69 revert(memory[0x00:0x00]); } // Block terminates label_2A6A: // Incoming jump from 0x2A65, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2A6E stack[-8] // @2A6F stack[-1] // @2A70 stack[-7] // } 2A6A 5B JUMPDEST 2A6B 61 PUSH2 0x2633 2A6E 88 DUP9 2A6F 82 DUP3 2A70 89 DUP10 2A71 01 ADD 2A72 61 PUSH2 0x2522 2A75 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A6B stack[0] = 0x2633 // @2A6E stack[1] = stack[-8] // @2A71 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x2522, returns to 0x2633 label_2A76: // Incoming call from 0x0511, returns to 0x0512 // Incoming call from 0x09F0, returns to 0x09F1 // Inputs[2] // { // @2A7B stack[-1] // @2A7C stack[-2] // } 2A76 5B JUMPDEST 2A77 60 PUSH1 0x00 2A79 60 PUSH1 0x20 2A7B 82 DUP3 2A7C 84 DUP5 2A7D 03 SUB 2A7E 12 SLT 2A7F 15 ISZERO 2A80 61 PUSH2 0x2a88 2A83 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A77 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a88, if !(stack[-2] - stack[-1] i< 0x20) label_2A84: // Incoming jump from 0x2A83, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A87 memory[0x00:0x00] } 2A84 60 PUSH1 0x00 2A86 80 DUP1 2A87 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A87 revert(memory[0x00:0x00]); } // Block terminates label_2A88: // Incoming jump from 0x2A83, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A8C stack[-2] } 2A88 5B JUMPDEST 2A89 61 PUSH2 0x1ba4 2A8C 82 DUP3 2A8D 61 PUSH2 0x232b 2A90 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2A89 stack[0] = 0x1ba4 // @2A8C stack[1] = stack[-2] // } // Block ends with call to 0x232b, returns to 0x1BA4 label_2A91: // Incoming call from 0x0524, returns to 0x0525 // Inputs[2] // { // @2A99 stack[-1] // @2A9A stack[-2] // } 2A91 5B JUMPDEST 2A92 60 PUSH1 0x00 2A94 80 DUP1 2A95 60 PUSH1 0x00 2A97 60 PUSH1 0x60 2A99 84 DUP5 2A9A 86 DUP7 2A9B 03 SUB 2A9C 12 SLT 2A9D 15 ISZERO 2A9E 61 PUSH2 0x2aa6 2AA1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2A92 stack[0] = 0x00 // @2A94 stack[1] = 0x00 // @2A95 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2aa6, if !(stack[-2] - stack[-1] i< 0x60) label_2AA2: // Incoming jump from 0x2AA1, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2AA5 memory[0x00:0x00] } 2AA2 60 PUSH1 0x00 2AA4 80 DUP1 2AA5 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AA5 revert(memory[0x00:0x00]); } // Block terminates label_2AA6: // Incoming jump from 0x2AA1, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2AAA stack[-4] } 2AA6 5B JUMPDEST 2AA7 61 PUSH2 0x2aaf 2AAA 84 DUP5 2AAB 61 PUSH2 0x232b 2AAE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2AA7 stack[0] = 0x2aaf // @2AAA stack[1] = stack[-4] // } // Block ends with call to 0x232b, returns to 0x2AAF label_2AAF: // Incoming return from call to 0x232B at 0x2AAE // Inputs[7] // { // @2AB0 stack[-1] // @2AB0 stack[-7] // @2AB3 stack[-5] // @2AB5 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2AB6 stack[-6] // @2ABD msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2ABF stack[-4] // } 2AAF 5B JUMPDEST 2AB0 95 SWAP6 2AB1 60 PUSH1 0x20 2AB3 85 DUP6 2AB4 01 ADD 2AB5 35 CALLDATALOAD 2AB6 95 SWAP6 2AB7 50 POP 2AB8 60 PUSH1 0x40 2ABA 90 SWAP1 2ABB 94 SWAP5 2ABC 01 ADD 2ABD 35 CALLDATALOAD 2ABE 93 SWAP4 2ABF 92 SWAP3 2AC0 50 POP 2AC1 50 POP 2AC2 50 POP 2AC3 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2AB0 stack[-7] = stack[-1] // @2AB6 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2ABE stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_2AC4: // Incoming call from 0x0537, returns to 0x0538 // Inputs[2] // { // @2AC9 stack[-1] // @2ACA stack[-2] // } 2AC4 5B JUMPDEST 2AC5 60 PUSH1 0x00 2AC7 60 PUSH1 0x20 2AC9 82 DUP3 2ACA 84 DUP5 2ACB 03 SUB 2ACC 12 SLT 2ACD 15 ISZERO 2ACE 61 PUSH2 0x2ad6 2AD1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2AC5 stack[0] = 0x00 } // Block ends with conditional jump to 0x2ad6, if !(stack[-2] - stack[-1] i< 0x20) label_2AD2: // Incoming jump from 0x2AD1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2AD5 memory[0x00:0x00] } 2AD2 60 PUSH1 0x00 2AD4 80 DUP1 2AD5 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AD5 revert(memory[0x00:0x00]); } // Block terminates label_2AD6: // Incoming jump from 0x2AD1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2AD7 stack[-2] // @2AD8 msg.data[stack[-2]:stack[-2] + 0x20] // } 2AD6 5B JUMPDEST 2AD7 81 DUP2 2AD8 35 CALLDATALOAD 2AD9 67 PUSH8 0xffffffffffffffff 2AE2 81 DUP2 2AE3 11 GT 2AE4 15 ISZERO 2AE5 61 PUSH2 0x2aed 2AE8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2AD8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2aed, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2AE9: // Incoming jump from 0x2AE8, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2AEC memory[0x00:0x00] } 2AE9 60 PUSH1 0x00 2AEB 80 DUP1 2AEC FD *REVERT // Stack delta = +0 // Outputs[1] { @2AEC revert(memory[0x00:0x00]); } // Block terminates label_2AED: // Incoming jump from 0x2AE8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2AF1 stack[-4] // @2AF2 stack[-1] // @2AF3 stack[-3] // } 2AED 5B JUMPDEST 2AEE 61 PUSH2 0x2af9 2AF1 84 DUP5 2AF2 82 DUP3 2AF3 85 DUP6 2AF4 01 ADD 2AF5 61 PUSH2 0x2522 2AF8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2AEE stack[0] = 0x2af9 // @2AF1 stack[1] = stack[-4] // @2AF4 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x2522, returns to 0x2AF9 label_2AF9: // Incoming return from call to 0x2522 at 0x2AF8 // Inputs[3] // { // @2AFA stack[-1] // @2AFA stack[-6] // @2AFB stack[-5] // } 2AF9 5B JUMPDEST 2AFA 94 SWAP5 2AFB 93 SWAP4 2AFC 50 POP 2AFD 50 POP 2AFE 50 POP 2AFF 50 POP 2B00 56 *JUMP // Stack delta = -5 // Outputs[1] { @2AFA stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2B01: // Incoming call from 0x0614, returns to 0x0615 // Incoming call from 0x0661, returns to 0x0662 // Incoming call from 0x229D, returns to 0x229E // Incoming call from 0x1037, returns to 0x0636 // Incoming call from 0x0635, returns to 0x0636 // Inputs[1] { @2B04 stack[-1] } 2B01 5B JUMPDEST 2B02 60 PUSH1 0x01 2B04 81 DUP2 2B05 81 DUP2 2B06 1C SHR 2B07 90 SWAP1 2B08 82 DUP3 2B09 16 AND 2B0A 80 DUP1 2B0B 61 PUSH2 0x2b15 2B0E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2B07 stack[0] = stack[-1] >> 0x01 // @2B09 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2b15, if stack[-1] & 0x01 label_2B0F: // Incoming jump from 0x2B0E, if not stack[-1] & 0x01 // Inputs[2] // { // @2B11 stack[-2] // @2B1A stack[-1] // } 2B0F 60 PUSH1 0x7f 2B11 82 DUP3 2B12 16 AND 2B13 91 SWAP2 2B14 50 POP 2B15 5B JUMPDEST 2B16 60 PUSH1 0x20 2B18 82 DUP3 2B19 10 LT 2B1A 81 DUP2 2B1B 14 EQ 2B1C 15 ISZERO 2B1D 61 PUSH2 0x2b36 2B20 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2B13 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2b36, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2B21: // Incoming jump from 0x2B20, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2B20, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @2B35 memory[0x00:0x24] } 2B21 63 PUSH4 0x4e487b71 2B26 60 PUSH1 0xe0 2B28 1B SHL 2B29 60 PUSH1 0x00 2B2B 52 MSTORE 2B2C 60 PUSH1 0x22 2B2E 60 PUSH1 0x04 2B30 52 MSTORE 2B31 60 PUSH1 0x24 2B33 60 PUSH1 0x00 2B35 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B2B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2B30 memory[0x04:0x24] = 0x22 // @2B35 revert(memory[0x00:0x24]); // } // Block terminates label_2B36: // Incoming jump from 0x2B20, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2B20, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @2B38 stack[-2] // @2B38 stack[-4] // @2B39 stack[-3] // } 2B36 5B JUMPDEST 2B37 50 POP 2B38 91 SWAP2 2B39 90 SWAP1 2B3A 50 POP 2B3B 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B38 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2B3C: // Incoming jump from 0x2B6B // Incoming jump from 0x2BBC // Incoming jump from 0x2DD1 // Incoming jump from 0x2C9C // Incoming jump from 0x2BD6 // Inputs[1] { @2B51 memory[0x00:0x24] } 2B3C 5B JUMPDEST 2B3D 63 PUSH4 0x4e487b71 2B42 60 PUSH1 0xe0 2B44 1B SHL 2B45 60 PUSH1 0x00 2B47 52 MSTORE 2B48 60 PUSH1 0x11 2B4A 60 PUSH1 0x04 2B4C 52 MSTORE 2B4D 60 PUSH1 0x24 2B4F 60 PUSH1 0x00 2B51 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B47 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2B4C memory[0x04:0x24] = 0x11 // @2B51 revert(memory[0x00:0x24]); // } // Block terminates label_2B52: // Incoming call from 0x1989, returns to 0x198A // Incoming call from 0x1AAC, returns to 0x1AAD // Incoming call from 0x06E6, returns to 0x06E7 // Inputs[2] // { // @2B55 stack[-1] // @2B5A stack[-2] // } 2B52 5B JUMPDEST 2B53 60 PUSH1 0x00 2B55 81 DUP2 2B56 60 PUSH1 0x00 2B58 19 NOT 2B59 04 DIV 2B5A 83 DUP4 2B5B 11 GT 2B5C 82 DUP3 2B5D 15 ISZERO 2B5E 15 ISZERO 2B5F 16 AND 2B60 15 ISZERO 2B61 61 PUSH2 0x2b6c 2B64 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B53 stack[0] = 0x00 } // Block ends with conditional jump to 0x2b6c, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2B65: // Incoming jump from 0x2B64, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2B65 61 PUSH2 0x2b6c 2B68 61 PUSH2 0x2b3c 2B6B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2B65 stack[0] = 0x2b6c } // Block ends with unconditional jump to 0x2b3c label_2B6C: // Incoming jump from 0x2B64, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2B6E stack[-3] // @2B6E stack[-2] // @2B6F stack[-4] // } 2B6C 5B JUMPDEST 2B6D 50 POP 2B6E 02 MUL 2B6F 90 SWAP1 2B70 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B6F stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_2B71: // Incoming call from 0x06F0, returns to 0x06F1 // Inputs[1] { @2B74 stack[-2] } 2B71 5B JUMPDEST 2B72 60 PUSH1 0x00 2B74 82 DUP3 2B75 61 PUSH2 0x2b8e 2B78 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B72 stack[0] = 0x00 } // Block ends with conditional jump to 0x2b8e, if stack[-2] label_2B79: // Incoming jump from 0x2B78, if not stack[-2] // Inputs[1] { @2B8D memory[0x00:0x24] } 2B79 63 PUSH4 0x4e487b71 2B7E 60 PUSH1 0xe0 2B80 1B SHL 2B81 60 PUSH1 0x00 2B83 52 MSTORE 2B84 60 PUSH1 0x12 2B86 60 PUSH1 0x04 2B88 52 MSTORE 2B89 60 PUSH1 0x24 2B8B 60 PUSH1 0x00 2B8D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B83 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2B88 memory[0x04:0x24] = 0x12 // @2B8D revert(memory[0x00:0x24]); // } // Block terminates label_2B8E: // Incoming jump from 0x2B78, if stack[-2] // Inputs[3] // { // @2B90 stack[-2] // @2B90 stack[-3] // @2B91 stack[-4] // } 2B8E 5B JUMPDEST 2B8F 50 POP 2B90 04 DIV 2B91 90 SWAP1 2B92 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B91 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2B93: // Incoming jump from 0x1F4B // Incoming jump from 0x09DB // Incoming jump from 0x14B8 // Incoming jump from 0x14D6 // Incoming jump from 0x1A0D // Incoming jump from 0x1B0E // Incoming jump from 0x1A70 // Incoming jump from 0x1DEF // Incoming jump from 0x1151 // Incoming jump from 0x1DD1 // Incoming jump from 0x1133 // Incoming jump from 0x1AF8 // Inputs[1] { @2BA8 memory[0x00:0x24] } 2B93 5B JUMPDEST 2B94 63 PUSH4 0x4e487b71 2B99 60 PUSH1 0xe0 2B9B 1B SHL 2B9C 60 PUSH1 0x00 2B9E 52 MSTORE 2B9F 60 PUSH1 0x32 2BA1 60 PUSH1 0x04 2BA3 52 MSTORE 2BA4 60 PUSH1 0x24 2BA6 60 PUSH1 0x00 2BA8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B9E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2BA3 memory[0x04:0x24] = 0x32 // @2BA8 revert(memory[0x00:0x24]); // } // Block terminates label_2BA9: // Incoming call from 0x1EAA, returns to 0x1EAB // Incoming call from 0x150A, returns to 0x150B // Incoming call from 0x1248, returns to 0x1249 // Inputs[1] { @2BAF stack[-1] } 2BA9 5B JUMPDEST 2BAA 60 PUSH1 0x00 2BAC 60 PUSH1 0x00 2BAE 19 NOT 2BAF 82 DUP3 2BB0 14 EQ 2BB1 15 ISZERO 2BB2 61 PUSH2 0x2bbd 2BB5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2BAA stack[0] = 0x00 } // Block ends with conditional jump to 0x2bbd, if !(stack[-1] == ~0x00) label_2BB6: // Incoming jump from 0x2BB5, if not !(stack[-1] == ~0x00) 2BB6 61 PUSH2 0x2bbd 2BB9 61 PUSH2 0x2b3c 2BBC 56 *JUMP // Stack delta = +1 // Outputs[1] { @2BB6 stack[0] = 0x2bbd } // Block ends with unconditional jump to 0x2b3c label_2BBD: // Incoming jump from 0x2BB5, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2BC1 stack[-2] // @2BC2 stack[-3] // } 2BBD 5B JUMPDEST 2BBE 50 POP 2BBF 60 PUSH1 0x01 2BC1 01 ADD 2BC2 90 SWAP1 2BC3 56 *JUMP // Stack delta = -2 // Outputs[1] { @2BC2 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2BC4: // Incoming call from 0x1C67, returns to 0x1C68 // Incoming call from 0x1234, returns to 0x1235 // Incoming call from 0x1994, returns to 0x1995 // Incoming call from 0x1AB7, returns to 0x1AB8 // Inputs[2] // { // @2BC7 stack[-2] // @2BC9 stack[-1] // } 2BC4 5B JUMPDEST 2BC5 60 PUSH1 0x00 2BC7 82 DUP3 2BC8 19 NOT 2BC9 82 DUP3 2BCA 11 GT 2BCB 15 ISZERO 2BCC 61 PUSH2 0x2bd7 2BCF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2BC5 stack[0] = 0x00 } // Block ends with conditional jump to 0x2bd7, if !(stack[-1] > ~stack[-2]) label_2BD0: // Incoming jump from 0x2BCF, if not !(stack[-1] > ~stack[-2]) 2BD0 61 PUSH2 0x2bd7 2BD3 61 PUSH2 0x2b3c 2BD6 56 *JUMP // Stack delta = +1 // Outputs[1] { @2BD0 stack[0] = 0x2bd7 } // Block ends with unconditional jump to 0x2b3c label_2BD7: // Incoming jump from 0x2BCF, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2BD9 stack[-2] // @2BD9 stack[-3] // @2BDA stack[-4] // } 2BD7 5B JUMPDEST 2BD8 50 POP 2BD9 01 ADD 2BDA 90 SWAP1 2BDB 56 *JUMP // Stack delta = -3 // Outputs[1] { @2BDA stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2BDC: // Incoming call from 0x129F, returns to 0x12A0 // Incoming call from 0x1F03, returns to 0x1F04 // Inputs[2] // { // @2BDF stack[-1] // @2BEA stack[-3] // } 2BDC 5B JUMPDEST 2BDD 60 PUSH1 0x40 2BDF 81 DUP2 2BE0 52 MSTORE 2BE1 60 PUSH1 0x00 2BE3 61 PUSH2 0x2bef 2BE6 60 PUSH1 0x40 2BE8 83 DUP4 2BE9 01 ADD 2BEA 85 DUP6 2BEB 61 PUSH2 0x2734 2BEE 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2BE0 memory[stack[-1]:stack[-1] + 0x20] = 0x40 // @2BE1 stack[0] = 0x00 // @2BE3 stack[1] = 0x2bef // @2BE9 stack[2] = stack[-1] + 0x40 // @2BEA stack[3] = stack[-3] // } // Block ends with call to 0x2734, returns to 0x2BEF label_2BEF: // Incoming return from call to 0x2734 at 0x2BEE // Inputs[3] // { // @2BF0 stack[-3] // @2BF1 stack[-1] // @2BFC stack[-4] // } 2BEF 5B JUMPDEST 2BF0 82 DUP3 2BF1 81 DUP2 2BF2 03 SUB 2BF3 60 PUSH1 0x20 2BF5 84 DUP5 2BF6 01 ADD 2BF7 52 MSTORE 2BF8 61 PUSH2 0x2c01 2BFB 81 DUP2 2BFC 85 DUP6 2BFD 61 PUSH2 0x2734 2C00 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2BF7 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] - stack[-3] // @2BF8 stack[0] = 0x2c01 // @2BFB stack[1] = stack[-1] // @2BFC stack[2] = stack[-4] // } // Block ends with call to 0x2734, returns to 0x2C01 label_2C01: // Incoming return from call to 0x2734 at 0x2C00 // Inputs[3] // { // @2C02 stack[-1] // @2C02 stack[-7] // @2C03 stack[-6] // } 2C01 5B JUMPDEST 2C02 95 SWAP6 2C03 94 SWAP5 2C04 50 POP 2C05 50 POP 2C06 50 POP 2C07 50 POP 2C08 50 POP 2C09 56 *JUMP // Stack delta = -6 // Outputs[1] { @2C02 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_2C0A: // Incoming call from 0x130F, returns to 0x1310 // Inputs[3] // { // @2C2C stack[-1] // @2C30 stack[-3] // @2C31 memory[stack[-3]:stack[-3] + 0x20] // } 2C0A 5B JUMPDEST 2C0B 7F PUSH32 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 2C2C 81 DUP2 2C2D 52 MSTORE 2C2E 60 PUSH1 0x00 2C30 83 DUP4 2C31 51 MLOAD 2C32 61 PUSH2 0x2c42 2C35 81 DUP2 2C36 60 PUSH1 0x17 2C38 85 DUP6 2C39 01 ADD 2C3A 60 PUSH1 0x20 2C3C 88 DUP9 2C3D 01 ADD 2C3E 61 PUSH2 0x23bd 2C41 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2C2D memory[stack[-1]:stack[-1] + 0x20] = 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 // @2C2E stack[0] = 0x00 // @2C31 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @2C32 stack[2] = 0x2c42 // @2C35 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @2C39 stack[4] = stack[-1] + 0x17 // @2C3D stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x23bd, returns to 0x2C42 label_2C42: // Incoming return from call to 0x23BD at 0x2C41 // Inputs[4] // { // @2C66 stack[-1] // @2C67 stack[-3] // @2C6D stack[-4] // @2C6E memory[stack[-4]:stack[-4] + 0x20] // } 2C42 5B JUMPDEST 2C43 7F PUSH32 0x206973206d697373696e6720726f6c6520000000000000000000000000000000 2C64 60 PUSH1 0x17 2C66 91 SWAP2 2C67 84 DUP5 2C68 01 ADD 2C69 91 SWAP2 2C6A 82 DUP3 2C6B 01 ADD 2C6C 52 MSTORE 2C6D 83 DUP4 2C6E 51 MLOAD 2C6F 61 PUSH2 0x2c7f 2C72 81 DUP2 2C73 60 PUSH1 0x28 2C75 84 DUP5 2C76 01 ADD 2C77 60 PUSH1 0x20 2C79 88 DUP9 2C7A 01 ADD 2C7B 61 PUSH2 0x23bd 2C7E 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2C69 stack[-1] = stack[-3] + stack[-1] // @2C6C memory[stack[-3] + stack[-1] + 0x17:stack[-3] + stack[-1] + 0x17 + 0x20] = 0x206973206d697373696e6720726f6c6520000000000000000000000000000000 // @2C6E stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @2C6F stack[1] = 0x2c7f // @2C72 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @2C76 stack[3] = stack[-3] + stack[-1] + 0x28 // @2C7A stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x23bd, returns to 0x2C7F label_2C7F: // Incoming return from call to 0x23BD at 0x2C7E // Inputs[4] // { // @2C80 stack[-2] // @2C80 stack[-1] // @2C84 stack[-7] // @2C85 stack[-6] // } 2C7F 5B JUMPDEST 2C80 01 ADD 2C81 60 PUSH1 0x28 2C83 01 ADD 2C84 94 SWAP5 2C85 93 SWAP4 2C86 50 POP 2C87 50 POP 2C88 50 POP 2C89 50 POP 2C8A 56 *JUMP // Stack delta = -6 // Outputs[1] { @2C84 stack[-7] = 0x28 + stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] label_2C8B: // Incoming call from 0x14FB, returns to 0x14FC // Incoming call from 0x1755, returns to 0x1756 // Inputs[2] // { // @2C8E stack[-2] // @2C8F stack[-1] // } 2C8B 5B JUMPDEST 2C8C 60 PUSH1 0x00 2C8E 82 DUP3 2C8F 82 DUP3 2C90 10 LT 2C91 15 ISZERO 2C92 61 PUSH2 0x2c9d 2C95 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C8C stack[0] = 0x00 } // Block ends with conditional jump to 0x2c9d, if !(stack[-1] < stack[-2]) label_2C96: // Incoming jump from 0x2C95, if not !(stack[-1] < stack[-2]) 2C96 61 PUSH2 0x2c9d 2C99 61 PUSH2 0x2b3c 2C9C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2C96 stack[0] = 0x2c9d } // Block ends with unconditional jump to 0x2b3c label_2C9D: // Incoming jump from 0x2C95, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @2C9F stack[-2] // @2C9F stack[-3] // @2CA0 stack[-4] // } 2C9D 5B JUMPDEST 2C9E 50 POP 2C9F 03 SUB 2CA0 90 SWAP1 2CA1 56 *JUMP // Stack delta = -3 // Outputs[1] { @2CA0 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_2CA2: // Incoming call from 0x17F4, returns to 0x17F5 // Inputs[4] // { // @2CAE stack[-6] // @2CB0 stack[-1] // @2CB3 stack[-5] // @2CC9 stack[-4] // } 2CA2 5B JUMPDEST 2CA3 60 PUSH1 0x00 2CA5 60 PUSH1 0x01 2CA7 60 PUSH1 0x01 2CA9 60 PUSH1 0xa0 2CAB 1B SHL 2CAC 03 SUB 2CAD 80 DUP1 2CAE 88 DUP9 2CAF 16 AND 2CB0 83 DUP4 2CB1 52 MSTORE 2CB2 80 DUP1 2CB3 87 DUP8 2CB4 16 AND 2CB5 60 PUSH1 0x20 2CB7 84 DUP5 2CB8 01 ADD 2CB9 52 MSTORE 2CBA 50 POP 2CBB 60 PUSH1 0xa0 2CBD 60 PUSH1 0x40 2CBF 83 DUP4 2CC0 01 ADD 2CC1 52 MSTORE 2CC2 61 PUSH2 0x2cce 2CC5 60 PUSH1 0xa0 2CC7 83 DUP4 2CC8 01 ADD 2CC9 86 DUP7 2CCA 61 PUSH2 0x2734 2CCD 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @2CA3 stack[0] = 0x00 // @2CB1 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2CB9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2CC1 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0xa0 // @2CC2 stack[1] = 0x2cce // @2CC8 stack[2] = stack[-1] + 0xa0 // @2CC9 stack[3] = stack[-4] // } // Block ends with call to 0x2734, returns to 0x2CCE label_2CCE: // Incoming return from call to 0x2734 at 0x2CCD // Inputs[3] // { // @2CCF stack[-3] // @2CD0 stack[-1] // @2CDB stack[-5] // } 2CCE 5B JUMPDEST 2CCF 82 DUP3 2CD0 81 DUP2 2CD1 03 SUB 2CD2 60 PUSH1 0x60 2CD4 84 DUP5 2CD5 01 ADD 2CD6 52 MSTORE 2CD7 61 PUSH2 0x2ce0 2CDA 81 DUP2 2CDB 86 DUP7 2CDC 61 PUSH2 0x2734 2CDF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2CD6 memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] = stack[-1] - stack[-3] // @2CD7 stack[0] = 0x2ce0 // @2CDA stack[1] = stack[-1] // @2CDB stack[2] = stack[-5] // } // Block ends with call to 0x2734, returns to 0x2CE0 label_2CE0: // Incoming return from call to 0x2734 at 0x2CDF // Inputs[4] // { // @2CE1 stack[-2] // @2CE1 stack[-1] // @2CE3 stack[-4] // @2CEF stack[-5] // } 2CE0 5B JUMPDEST 2CE1 90 SWAP1 2CE2 50 POP 2CE3 82 DUP3 2CE4 81 DUP2 2CE5 03 SUB 2CE6 60 PUSH1 0x80 2CE8 84 DUP5 2CE9 01 ADD 2CEA 52 MSTORE 2CEB 61 PUSH2 0x2cf4 2CEE 81 DUP2 2CEF 85 DUP6 2CF0 61 PUSH2 0x23e9 2CF3 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2CE1 stack[-2] = stack[-1] // @2CEA memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] = stack[-1] - stack[-4] // @2CEB stack[-1] = 0x2cf4 // @2CEE stack[0] = stack[-1] // @2CEF stack[1] = stack[-5] // } // Block ends with call to 0x23e9, returns to 0x2CF4 label_2CF4: // Incoming return from call to 0x23E9 at 0x2CF3 // Inputs[3] // { // @2CF5 stack[-1] // @2CF5 stack[-10] // @2CF6 stack[-9] // } 2CF4 5B JUMPDEST 2CF5 98 SWAP9 2CF6 97 SWAP8 2CF7 50 POP 2CF8 50 POP 2CF9 50 POP 2CFA 50 POP 2CFB 50 POP 2CFC 50 POP 2CFD 50 POP 2CFE 50 POP 2CFF 56 *JUMP // Stack delta = -9 // Outputs[1] { @2CF5 stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_2D00: // Incoming jump from 0x1FE7 // Incoming jump from 0x183B // Inputs[2] // { // @2D05 stack[-1] // @2D06 stack[-2] // } 2D00 5B JUMPDEST 2D01 60 PUSH1 0x00 2D03 60 PUSH1 0x20 2D05 82 DUP3 2D06 84 DUP5 2D07 03 SUB 2D08 12 SLT 2D09 15 ISZERO 2D0A 61 PUSH2 0x2d12 2D0D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D01 stack[0] = 0x00 } // Block ends with conditional jump to 0x2d12, if !(stack[-2] - stack[-1] i< 0x20) label_2D0E: // Incoming jump from 0x2D0D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2D11 memory[0x00:0x00] } 2D0E 60 PUSH1 0x00 2D10 80 DUP1 2D11 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D11 revert(memory[0x00:0x00]); } // Block terminates label_2D12: // Incoming jump from 0x2D0D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2D13 stack[-2] // @2D14 memory[stack[-2]:stack[-2] + 0x20] // } 2D12 5B JUMPDEST 2D13 81 DUP2 2D14 51 MLOAD 2D15 61 PUSH2 0x1ba4 2D18 81 DUP2 2D19 61 PUSH2 0x2371 2D1C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2D14 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2D15 stack[1] = 0x1ba4 // @2D18 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2371, returns to 0x1BA4 label_2D1D: // Incoming call from 0x1FF6, returns to 0x184B // Incoming call from 0x184A, returns to 0x184B // Inputs[1] { @2D22 returndata.length } 2D1D 5B JUMPDEST 2D1E 60 PUSH1 0x00 2D20 60 PUSH1 0x03 2D22 3D RETURNDATASIZE 2D23 11 GT 2D24 15 ISZERO 2D25 61 PUSH2 0x2d36 2D28 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D1E stack[0] = 0x00 } // Block ends with conditional jump to 0x2d36, if !(returndata.length > 0x03) label_2D29: // Incoming jump from 0x2D28, if not !(returndata.length > 0x03) // Inputs[3] // { // @2D2E returndata[0x00:0x04] // @2D32 memory[0x00:0x20] // @2D37 stack[-2] // } 2D29 60 PUSH1 0x04 2D2B 60 PUSH1 0x00 2D2D 80 DUP1 2D2E 3E RETURNDATACOPY 2D2F 50 POP 2D30 60 PUSH1 0x00 2D32 51 MLOAD 2D33 60 PUSH1 0xe0 2D35 1C SHR 2D36 5B JUMPDEST 2D37 90 SWAP1 2D38 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2D2E memory[0x00:0x04] = returndata[0x00:0x04] // @2D37 stack[-2] = memory[0x00:0x20] >> 0xe0 // } // Block ends with unconditional jump to stack[-2] label_2D39: // Incoming call from 0x185F, returns to 0x1860 // Inputs[1] { @2D3E returndata.length } 2D39 5B JUMPDEST 2D3A 60 PUSH1 0x00 2D3C 60 PUSH1 0x44 2D3E 3D RETURNDATASIZE 2D3F 10 LT 2D40 15 ISZERO 2D41 61 PUSH2 0x2d47 2D44 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D3A stack[0] = 0x00 } // Block ends with conditional jump to 0x2d47, if !(returndata.length < 0x44) label_2D45: // Incoming jump from 0x2D44, if not !(returndata.length < 0x44) // Inputs[2] // { // @2D45 stack[-2] // @2D45 stack[-1] // } 2D45 90 SWAP1 2D46 56 *JUMP // Stack delta = -1 // Outputs[1] { @2D45 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_2D47: // Incoming jump from 0x2D44, if !(returndata.length < 0x44) // Inputs[5] // { // @2D4A memory[0x40:0x60] // @2D4E returndata.length // @2D54 returndata[0x04:0x04 + ~0x03 + returndata.length] // @2D56 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2D57 returndata.length // } 2D47 5B JUMPDEST 2D48 60 PUSH1 0x40 2D4A 51 MLOAD 2D4B 60 PUSH1 0x03 2D4D 19 NOT 2D4E 3D RETURNDATASIZE 2D4F 81 DUP2 2D50 01 ADD 2D51 60 PUSH1 0x04 2D53 83 DUP4 2D54 3E RETURNDATACOPY 2D55 81 DUP2 2D56 51 MLOAD 2D57 3D RETURNDATASIZE 2D58 67 PUSH8 0xffffffffffffffff 2D61 81 DUP2 2D62 60 PUSH1 0x24 2D64 84 DUP5 2D65 01 ADD 2D66 11 GT 2D67 81 DUP2 2D68 84 DUP5 2D69 11 GT 2D6A 17 OR 2D6B 15 ISZERO 2D6C 61 PUSH2 0x2d77 2D6F 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @2D4A stack[0] = memory[0x40:0x60] // @2D4D stack[1] = ~0x03 // @2D54 memory[memory[0x40:0x60]:memory[0x40:0x60] + ~0x03 + returndata.length] = returndata[0x04:0x04 + ~0x03 + returndata.length] // @2D56 stack[2] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2D57 stack[3] = returndata.length // @2D58 stack[4] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2d77, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) label_2D70: // Incoming jump from 0x2D6F, if not !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[2] // { // @2D75 stack[-7] // @2D75 stack[-6] // } 2D70 50 POP 2D71 50 POP 2D72 50 POP 2D73 50 POP 2D74 50 POP 2D75 90 SWAP1 2D76 56 *JUMP // Stack delta = -6 // Outputs[1] { @2D75 stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_2D77: // Incoming jump from 0x2D6F, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[5] // { // @2D78 stack[-3] // @2D79 stack[-5] // @2D7B stack[-2] // @2D7E memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // @2D7F stack[-1] // } 2D77 5B JUMPDEST 2D78 82 DUP3 2D79 85 DUP6 2D7A 01 ADD 2D7B 91 SWAP2 2D7C 50 POP 2D7D 81 DUP2 2D7E 51 MLOAD 2D7F 81 DUP2 2D80 81 DUP2 2D81 11 GT 2D82 15 ISZERO 2D83 61 PUSH2 0x2d8f 2D86 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2D7B stack[-2] = stack[-5] + stack[-3] // @2D7E stack[0] = memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x2d8f, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) label_2D87: // Incoming jump from 0x2D86, if not !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[2] // { // @2D8D stack[-7] // @2D8D stack[-8] // } 2D87 50 POP 2D88 50 POP 2D89 50 POP 2D8A 50 POP 2D8B 50 POP 2D8C 50 POP 2D8D 90 SWAP1 2D8E 56 *JUMP // Stack delta = -7 // Outputs[1] { @2D8D stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_2D8F: // Incoming jump from 0x2D86, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[5] // { // @2D90 stack[-5] // @2D91 returndata.length // @2D92 stack[-6] // @2D97 stack[-1] // @2D98 stack[-3] // } 2D8F 5B JUMPDEST 2D90 84 DUP5 2D91 3D RETURNDATASIZE 2D92 87 DUP8 2D93 01 ADD 2D94 01 ADD 2D95 60 PUSH1 0x20 2D97 82 DUP3 2D98 85 DUP6 2D99 01 ADD 2D9A 01 ADD 2D9B 11 GT 2D9C 15 ISZERO 2D9D 61 PUSH2 0x2da9 2DA0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2da9, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) label_2DA1: // Incoming jump from 0x2DA0, if not !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[2] // { // @2DA7 stack[-7] // @2DA7 stack[-8] // } 2DA1 50 POP 2DA2 50 POP 2DA3 50 POP 2DA4 50 POP 2DA5 50 POP 2DA6 50 POP 2DA7 90 SWAP1 2DA8 56 *JUMP // Stack delta = -7 // Outputs[1] { @2DA7 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_2DA9: // Incoming jump from 0x2DA0, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[3] // { // @2DAF stack[-1] // @2DB0 stack[-4] // @2DB3 stack[-6] // } 2DA9 5B JUMPDEST 2DAA 61 PUSH2 0x2db8 2DAD 60 PUSH1 0x20 2DAF 82 DUP3 2DB0 86 DUP7 2DB1 01 ADD 2DB2 01 ADD 2DB3 87 DUP8 2DB4 61 PUSH2 0x2460 2DB7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2DAA stack[0] = 0x2db8 // @2DB2 stack[1] = stack[-4] + stack[-1] + 0x20 // @2DB3 stack[2] = stack[-6] // } // Block ends with call to 0x2460, returns to 0x2DB8 label_2DB8: // Incoming return from call to 0x2460 at 0x2DB7 // Inputs[4] // { // @2DBA stack[-2] // @2DBA stack[-3] // @2DBB stack[-8] // @2DBC stack[-7] // } 2DB8 5B JUMPDEST 2DB9 50 POP 2DBA 90 SWAP1 2DBB 95 SWAP6 2DBC 94 SWAP5 2DBD 50 POP 2DBE 50 POP 2DBF 50 POP 2DC0 50 POP 2DC1 50 POP 2DC2 56 *JUMP // Stack delta = -7 // Outputs[1] { @2DBB stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] label_2DC3: // Incoming call from 0x1B4D, returns to 0x1B4E // Inputs[1] { @2DC6 stack[-1] } 2DC3 5B JUMPDEST 2DC4 60 PUSH1 0x00 2DC6 81 DUP2 2DC7 61 PUSH2 0x2dd2 2DCA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2DC4 stack[0] = 0x00 } // Block ends with conditional jump to 0x2dd2, if stack[-1] label_2DCB: // Incoming jump from 0x2DCA, if not stack[-1] 2DCB 61 PUSH2 0x2dd2 2DCE 61 PUSH2 0x2b3c 2DD1 56 *JUMP // Stack delta = +1 // Outputs[1] { @2DCB stack[0] = 0x2dd2 } // Block ends with unconditional jump to 0x2b3c label_2DD2: // Incoming jump from 0x2DCA, if stack[-1] // Inputs[2] // { // @2DD7 stack[-2] // @2DD8 stack[-3] // } 2DD2 5B JUMPDEST 2DD3 50 POP 2DD4 60 PUSH1 0x00 2DD6 19 NOT 2DD7 01 ADD 2DD8 90 SWAP1 2DD9 56 *JUMP // Stack delta = -2 // Outputs[1] { @2DD8 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2DDA: // Incoming call from 0x1FA0, returns to 0x1FA1 // Inputs[6] // { // @2DE6 stack[-6] // @2DE8 stack[-1] // @2DEB stack[-5] // @2DF3 stack[-4] // @2DF9 stack[-3] // @2E0D stack[-2] // } 2DDA 5B JUMPDEST 2DDB 60 PUSH1 0x00 2DDD 60 PUSH1 0x01 2DDF 60 PUSH1 0x01 2DE1 60 PUSH1 0xa0 2DE3 1B SHL 2DE4 03 SUB 2DE5 80 DUP1 2DE6 88 DUP9 2DE7 16 AND 2DE8 83 DUP4 2DE9 52 MSTORE 2DEA 80 DUP1 2DEB 87 DUP8 2DEC 16 AND 2DED 60 PUSH1 0x20 2DEF 84 DUP5 2DF0 01 ADD 2DF1 52 MSTORE 2DF2 50 POP 2DF3 84 DUP5 2DF4 60 PUSH1 0x40 2DF6 83 DUP4 2DF7 01 ADD 2DF8 52 MSTORE 2DF9 83 DUP4 2DFA 60 PUSH1 0x60 2DFC 83 DUP4 2DFD 01 ADD 2DFE 52 MSTORE 2DFF 60 PUSH1 0xa0 2E01 60 PUSH1 0x80 2E03 83 DUP4 2E04 01 ADD 2E05 52 MSTORE 2E06 61 PUSH2 0x2e12 2E09 60 PUSH1 0xa0 2E0B 83 DUP4 2E0C 01 ADD 2E0D 84 DUP5 2E0E 61 PUSH2 0x23e9 2E11 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @2DDB stack[0] = 0x00 // @2DE9 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2DF1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2DF8 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-4] // @2DFE memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-3] // @2E05 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = 0xa0 // @2E06 stack[1] = 0x2e12 // @2E0C stack[2] = stack[-1] + 0xa0 // @2E0D stack[3] = stack[-2] // } // Block ends with call to 0x23e9, returns to 0x2E12 label_2E12: // Incoming return from call to 0x23E9 at 0x2E11 // Inputs[3] // { // @2E13 stack[-1] // @2E13 stack[-9] // @2E14 stack[-8] // } 2E12 5B JUMPDEST 2E13 97 SWAP8 2E14 96 SWAP7 2E15 50 POP 2E16 50 POP 2E17 50 POP 2E18 50 POP 2E19 50 POP 2E1A 50 POP 2E1B 50 POP 2E1C 56 *JUMP // Stack delta = -8 // Outputs[1] { @2E13 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] 2E1D FE *ASSERT 2E1E A2 LOG2 2E1F 64 PUSH5 0x6970667358 2E25 22 22 2E26 12 SLT 2E27 20 SHA3 2E28 9D SWAP14 2E29 A7 A7 2E2A 9E SWAP15 2E2B 30 ADDRESS 2E2C 06 MOD 2E2D 50 POP 2E2E 4F 4F 2E2F 2E 2E 2E30 BB BB 2E31 D6 D6 2E32 43 NUMBER 2E33 B4 B4 2E34 56 *JUMP 2E35 B3 B3 2E36 C2 C2 2E37 03 SUB 2E38 57 *JUMPI 2E39 0F 0F 2E3A D4 D4 2E3B F8 F8 2E3C 08 ADDMOD 2E3D 79 PUSH26 0x8f58fb98d9aa04f6611564736f6c63430008090033