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 0x0197 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0197, 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 0x62a5af3b 0026 11 GT 0027 61 PUSH2 0x00e3 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00e3, if 0x62a5af3b > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x62a5af3b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xdffb8433 0031 11 GT 0032 61 PUSH2 0x008c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008c, if 0xdffb8433 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xdffb8433 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xf242432a 003C 11 GT 003D 61 PUSH2 0x0066 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, 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 0x0389 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0389, 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 0x039c 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039c, 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 0xfd8fd9a5 005D 14 EQ 005E 61 PUSH2 0x03af 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03af, if 0xfd8fd9a5 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xfd8fd9a5 == stack[-1] // Inputs[1] { @0065 memory[0x00:0x00] } 0062 60 PUSH1 0x00 0064 80 DUP1 0065 FD *REVERT // Stack delta = +0 // Outputs[1] { @0065 revert(memory[0x00:0x00]); } // Block terminates label_0066: // Incoming jump from 0x0040, if 0xf242432a > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0xdffb8433 006D 14 EQ 006E 61 PUSH2 0x0327 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0327, if 0xdffb8433 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0xdffb8433 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0xe985e9c5 0078 14 EQ 0079 61 PUSH2 0x033a 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033a, if 0xe985e9c5 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xe9cf98ae 0083 14 EQ 0084 61 PUSH2 0x0376 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0376, if 0xe9cf98ae == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xe9cf98ae == stack[-1] // Inputs[1] { @008B memory[0x00:0x00] } 0088 60 PUSH1 0x00 008A 80 DUP1 008B FD *REVERT // Stack delta = +0 // Outputs[1] { @008B revert(memory[0x00:0x00]); } // Block terminates label_008C: // Incoming jump from 0x0035, if 0xdffb8433 > stack[-1] // Inputs[1] { @008D stack[-1] } 008C 5B JUMPDEST 008D 80 DUP1 008E 63 PUSH4 0x8da5cb5b 0093 11 GT 0094 61 PUSH2 0x00bd 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bd, if 0x8da5cb5b > stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x8da5cb5b 009E 14 EQ 009F 61 PUSH2 0x02f0 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f0, if 0x8da5cb5b == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x9727756a 00A9 14 EQ 00AA 61 PUSH2 0x0301 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0301, if 0x9727756a == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x9727756a == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0xa22cb465 00B4 14 EQ 00B5 61 PUSH2 0x0314 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0314, if 0xa22cb465 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00BC memory[0x00:0x00] } 00B9 60 PUSH1 0x00 00BB 80 DUP1 00BC FD *REVERT // Stack delta = +0 // Outputs[1] { @00BC revert(memory[0x00:0x00]); } // Block terminates label_00BD: // Incoming jump from 0x0097, if 0x8da5cb5b > stack[-1] // Inputs[1] { @00BE stack[-1] } 00BD 5B JUMPDEST 00BE 80 DUP1 00BF 63 PUSH4 0x62a5af3b 00C4 14 EQ 00C5 61 PUSH2 0x02cd 00C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cd, if 0x62a5af3b == stack[-1] label_00C9: // Incoming jump from 0x00C8, if not 0x62a5af3b == stack[-1] // Inputs[1] { @00C9 stack[-1] } 00C9 80 DUP1 00CA 63 PUSH4 0x715018a6 00CF 14 EQ 00D0 61 PUSH2 0x02d5 00D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d5, if 0x715018a6 == stack[-1] label_00D4: // Incoming jump from 0x00D3, if not 0x715018a6 == stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D4 80 DUP1 00D5 63 PUSH4 0x83ca5a05 00DA 14 EQ 00DB 61 PUSH2 0x02dd 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02dd, if 0x83ca5a05 == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x83ca5a05 == stack[-1] // Inputs[1] { @00E2 memory[0x00:0x00] } 00DF 60 PUSH1 0x00 00E1 80 DUP1 00E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E2 revert(memory[0x00:0x00]); } // Block terminates label_00E3: // Incoming jump from 0x002A, if 0x62a5af3b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00E4 stack[-1] } 00E3 5B JUMPDEST 00E4 80 DUP1 00E5 63 PUSH4 0x2eb2c2d6 00EA 11 GT 00EB 61 PUSH2 0x0145 00EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0145, if 0x2eb2c2d6 > stack[-1] label_00EF: // Incoming jump from 0x00EE, if not 0x2eb2c2d6 > stack[-1] // Inputs[1] { @00EF stack[-1] } 00EF 80 DUP1 00F0 63 PUSH4 0x4e1273f4 00F5 11 GT 00F6 61 PUSH2 0x011f 00F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011f, if 0x4e1273f4 > stack[-1] label_00FA: // Incoming jump from 0x00F9, if not 0x4e1273f4 > stack[-1] // Inputs[1] { @00FA stack[-1] } 00FA 80 DUP1 00FB 63 PUSH4 0x4e1273f4 0100 14 EQ 0101 61 PUSH2 0x0287 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0287, if 0x4e1273f4 == stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x4eaa5db3 010B 14 EQ 010C 61 PUSH2 0x02a7 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a7, if 0x4eaa5db3 == stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x4eaa5db3 == stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x5b7633d0 0116 14 EQ 0117 61 PUSH2 0x02ba 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ba, if 0x5b7633d0 == stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x5b7633d0 == stack[-1] // Inputs[1] { @011E memory[0x00:0x00] } 011B 60 PUSH1 0x00 011D 80 DUP1 011E FD *REVERT // Stack delta = +0 // Outputs[1] { @011E revert(memory[0x00:0x00]); } // Block terminates label_011F: // Incoming jump from 0x00F9, if 0x4e1273f4 > stack[-1] // Inputs[1] { @0120 stack[-1] } 011F 5B JUMPDEST 0120 80 DUP1 0121 63 PUSH4 0x2eb2c2d6 0126 14 EQ 0127 61 PUSH2 0x024d 012A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024d, if 0x2eb2c2d6 == stack[-1] label_012B: // Incoming jump from 0x012A, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @012B stack[-1] } 012B 80 DUP1 012C 63 PUSH4 0x326d4388 0131 14 EQ 0132 61 PUSH2 0x0260 0135 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0260, if 0x326d4388 == stack[-1] label_0136: // Incoming jump from 0x0135, if not 0x326d4388 == stack[-1] // Inputs[1] { @0136 stack[-1] } 0136 80 DUP1 0137 63 PUSH4 0x33eeb147 013C 14 EQ 013D 61 PUSH2 0x0273 0140 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0273, if 0x33eeb147 == stack[-1] label_0141: // Incoming jump from 0x0140, if not 0x33eeb147 == stack[-1] // Inputs[1] { @0144 memory[0x00:0x00] } 0141 60 PUSH1 0x00 0143 80 DUP1 0144 FD *REVERT // Stack delta = +0 // Outputs[1] { @0144 revert(memory[0x00:0x00]); } // Block terminates label_0145: // Incoming jump from 0x00EE, if 0x2eb2c2d6 > stack[-1] // Inputs[1] { @0146 stack[-1] } 0145 5B JUMPDEST 0146 80 DUP1 0147 63 PUSH4 0x02fe5305 014C 11 GT 014D 61 PUSH2 0x0176 0150 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0176, if 0x02fe5305 > stack[-1] label_0151: // Incoming jump from 0x0150, if not 0x02fe5305 > stack[-1] // Inputs[1] { @0151 stack[-1] } 0151 80 DUP1 0152 63 PUSH4 0x02fe5305 0157 14 EQ 0158 61 PUSH2 0x0210 015B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0210, if 0x02fe5305 == stack[-1] label_015C: // Incoming jump from 0x015B, if not 0x02fe5305 == stack[-1] // Inputs[1] { @015C stack[-1] } 015C 80 DUP1 015D 63 PUSH4 0x06fdde03 0162 14 EQ 0163 61 PUSH2 0x0225 0166 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0225, if 0x06fdde03 == stack[-1] label_0167: // Incoming jump from 0x0166, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0167 stack[-1] } 0167 80 DUP1 0168 63 PUSH4 0x0e89341c 016D 14 EQ 016E 61 PUSH2 0x023a 0171 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023a, if 0x0e89341c == stack[-1] label_0172: // Incoming jump from 0x0171, if not 0x0e89341c == stack[-1] // Inputs[1] { @0175 memory[0x00:0x00] } 0172 60 PUSH1 0x00 0174 80 DUP1 0175 FD *REVERT // Stack delta = +0 // Outputs[1] { @0175 revert(memory[0x00:0x00]); } // Block terminates label_0176: // Incoming jump from 0x0150, if 0x02fe5305 > stack[-1] // Inputs[1] { @0177 stack[-1] } 0176 5B JUMPDEST 0177 80 DUP1 0178 62 PUSH3 0xfdd58e 017C 14 EQ 017D 61 PUSH2 0x019c 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019c, if 0xfdd58e == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0xfdd58e == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x01ffc9a7 0187 14 EQ 0188 61 PUSH2 0x01c2 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c2, if 0x01ffc9a7 == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x02885097 0192 14 EQ 0193 61 PUSH2 0x01e5 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e5, if 0x02885097 == stack[-1] label_0197: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0196, if not 0x02885097 == stack[-1] // Inputs[1] { @019B memory[0x00:0x00] } 0197 5B JUMPDEST 0198 60 PUSH1 0x00 019A 80 DUP1 019B FD *REVERT // Stack delta = +0 // Outputs[1] { @019B revert(memory[0x00:0x00]); } // Block terminates label_019C: // Incoming jump from 0x0180, if 0xfdd58e == stack[-1] // Inputs[1] { @01A3 msg.data.length } 019C 5B JUMPDEST 019D 61 PUSH2 0x01af 01A0 61 PUSH2 0x01aa 01A3 36 CALLDATASIZE 01A4 60 PUSH1 0x04 01A6 61 PUSH2 0x20b1 01A9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @019D stack[0] = 0x01af // @01A0 stack[1] = 0x01aa // @01A3 stack[2] = msg.data.length // @01A4 stack[3] = 0x04 // } // Block ends with call to 0x20b1, returns to 0x01AA label_01AA: // Incoming return from call to 0x20B1 at 0x01A9 01AA 5B JUMPDEST 01AB 61 PUSH2 0x03c2 01AE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03c2 label_01AF: // Incoming return from call to 0x01AA at 0x01A9 // Inputs[2] // { // @01B2 memory[0x40:0x60] // @01B3 stack[-1] // } 01AF 5B JUMPDEST 01B0 60 PUSH1 0x40 01B2 51 MLOAD 01B3 90 SWAP1 01B4 81 DUP2 01B5 52 MSTORE 01B6 60 PUSH1 0x20 01B8 01 ADD // Stack delta = +0 // Outputs[2] // { // @01B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01B8 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_01B9: // Incoming jump from 0x020F // Incoming jump from 0x01B8 // Incoming jump from 0x01E4 // Inputs[3] // { // @01BC memory[0x40:0x60] // @01BE stack[-1] // @01C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01B9 5B JUMPDEST 01BA 60 PUSH1 0x40 01BC 51 MLOAD 01BD 80 DUP1 01BE 91 SWAP2 01BF 03 SUB 01C0 90 SWAP1 01C1 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01C1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01C2: // Incoming jump from 0x018B, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01C9 msg.data.length } 01C2 5B JUMPDEST 01C3 61 PUSH2 0x01d5 01C6 61 PUSH2 0x01d0 01C9 36 CALLDATASIZE 01CA 60 PUSH1 0x04 01CC 61 PUSH2 0x2109 01CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01C3 stack[0] = 0x01d5 // @01C6 stack[1] = 0x01d0 // @01C9 stack[2] = msg.data.length // @01CA stack[3] = 0x04 // } // Block ends with call to 0x2109, returns to 0x01D0 label_01D0: // Incoming return from call to 0x2109 at 0x01CF 01D0 5B JUMPDEST 01D1 61 PUSH2 0x046b 01D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x046b label_01D5: // Incoming return from call to 0x0348 at 0x0347 // Incoming return from call to 0x01D0 at 0x01CF // Incoming jump from 0x0286 // Inputs[2] // { // @01D8 memory[0x40:0x60] // @01D9 stack[-1] // } 01D5 5B JUMPDEST 01D6 60 PUSH1 0x40 01D8 51 MLOAD 01D9 90 SWAP1 01DA 15 ISZERO 01DB 15 ISZERO 01DC 81 DUP2 01DD 52 MSTORE 01DE 60 PUSH1 0x20 01E0 01 ADD 01E1 61 PUSH2 0x01b9 01E4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01E0 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01b9 label_01E5: // Incoming jump from 0x0196, if 0x02885097 == stack[-1] // Inputs[1] { @01EC msg.data.length } 01E5 5B JUMPDEST 01E6 61 PUSH2 0x01f8 01E9 61 PUSH2 0x01f3 01EC 36 CALLDATASIZE 01ED 60 PUSH1 0x04 01EF 61 PUSH2 0x212d 01F2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01E6 stack[0] = 0x01f8 // @01E9 stack[1] = 0x01f3 // @01EC stack[2] = msg.data.length // @01ED stack[3] = 0x04 // } // Block ends with call to 0x212d, returns to 0x01F3 label_01F3: // Incoming return from call to 0x212D at 0x01F2 01F3 5B JUMPDEST 01F4 61 PUSH2 0x0550 01F7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0550 label_01F8: // Incoming jump from 0x03C1 // Incoming jump from 0x0300 // Incoming return from call to 0x01F3 at 0x01F2 // Incoming jump from 0x02CC // Inputs[2] // { // @01FB memory[0x40:0x60] // @0205 stack[-1] // } 01F8 5B JUMPDEST 01F9 60 PUSH1 0x40 01FB 51 MLOAD 01FC 60 PUSH1 0x01 01FE 60 PUSH1 0x01 0200 60 PUSH1 0xa0 0202 1B SHL 0203 03 SUB 0204 90 SWAP1 0205 91 SWAP2 0206 16 AND 0207 81 DUP2 0208 52 MSTORE 0209 60 PUSH1 0x20 020B 01 ADD 020C 61 PUSH2 0x01b9 020F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0208 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @020B stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01b9 label_0210: // Incoming jump from 0x015B, if 0x02fe5305 == stack[-1] // Inputs[1] { @0217 msg.data.length } 0210 5B JUMPDEST 0211 61 PUSH2 0x0223 0214 61 PUSH2 0x021e 0217 36 CALLDATASIZE 0218 60 PUSH1 0x04 021A 61 PUSH2 0x21e7 021D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0211 stack[0] = 0x0223 // @0214 stack[1] = 0x021e // @0217 stack[2] = msg.data.length // @0218 stack[3] = 0x04 // } // Block ends with call to 0x21e7, returns to 0x021E label_021E: // Incoming return from call to 0x21E7 at 0x021D 021E 5B JUMPDEST 021F 61 PUSH2 0x057a 0222 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x057a label_0223: // Incoming return from call to 0x0335 at 0x0334 // Incoming return from call to 0x026E at 0x026D // Incoming return from call to 0x02EB at 0x02EA // Incoming return from call to 0x0384 at 0x0383 // Incoming return from call to 0x03AA at 0x03A9 // Incoming return from call to 0x0A57 at 0x02DC // Incoming return from call to 0x0322 at 0x0321 // Incoming return from call to 0x09CD at 0x02D4 // Incoming return from call to 0x02B5 at 0x02B4 0223 5B JUMPDEST 0224 00 *STOP // Stack delta = +0 // Outputs[1] { @0224 stop(); } // Block terminates label_0225: // Incoming jump from 0x0166, if 0x06fdde03 == stack[-1] 0225 5B JUMPDEST 0226 61 PUSH2 0x022d 0229 61 PUSH2 0x0660 022C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0226 stack[0] = 0x022d } // Block ends with call to 0x0660, returns to 0x022D label_022D: // Incoming return from call to 0x0660 at 0x022C // Incoming return from call to 0x0248 at 0x0247 // Inputs[2] // { // @0230 memory[0x40:0x60] // @0234 stack[-1] // } 022D 5B JUMPDEST 022E 60 PUSH1 0x40 0230 51 MLOAD 0231 61 PUSH2 0x01b9 0234 91 SWAP2 0235 90 SWAP1 0236 61 PUSH2 0x2288 0239 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0234 stack[-1] = 0x01b9 // @0235 stack[1] = memory[0x40:0x60] // @0235 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2288 label_023A: // Incoming jump from 0x0171, if 0x0e89341c == stack[-1] // Inputs[1] { @0241 msg.data.length } 023A 5B JUMPDEST 023B 61 PUSH2 0x022d 023E 61 PUSH2 0x0248 0241 36 CALLDATASIZE 0242 60 PUSH1 0x04 0244 61 PUSH2 0x212d 0247 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023B stack[0] = 0x022d // @023E stack[1] = 0x0248 // @0241 stack[2] = msg.data.length // @0242 stack[3] = 0x04 // } // Block ends with call to 0x212d, returns to 0x0248 label_0248: // Incoming return from call to 0x212D at 0x0247 0248 5B JUMPDEST 0249 61 PUSH2 0x06ee 024C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06ee label_024D: // Incoming jump from 0x012A, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0254 msg.data.length } 024D 5B JUMPDEST 024E 61 PUSH2 0x0223 0251 61 PUSH2 0x025b 0254 36 CALLDATASIZE 0255 60 PUSH1 0x04 0257 61 PUSH2 0x2350 025A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @024E stack[0] = 0x0223 // @0251 stack[1] = 0x025b // @0254 stack[2] = msg.data.length // @0255 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2350 025B 5B JUMPDEST 025C 61 PUSH2 0x0729 025F 56 *JUMP label_0260: // Incoming jump from 0x0135, if 0x326d4388 == stack[-1] // Inputs[1] { @0267 msg.data.length } 0260 5B JUMPDEST 0261 61 PUSH2 0x0223 0264 61 PUSH2 0x026e 0267 36 CALLDATASIZE 0268 60 PUSH1 0x04 026A 61 PUSH2 0x21e7 026D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0261 stack[0] = 0x0223 // @0264 stack[1] = 0x026e // @0267 stack[2] = msg.data.length // @0268 stack[3] = 0x04 // } // Block ends with call to 0x21e7, returns to 0x026E label_026E: // Incoming return from call to 0x21E7 at 0x026D 026E 5B JUMPDEST 026F 61 PUSH2 0x07cb 0272 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07cb label_0273: // Incoming jump from 0x0140, if 0x33eeb147 == stack[-1] // Inputs[1] { @0276 storage[0x04] } 0273 5B JUMPDEST 0274 60 PUSH1 0x04 0276 54 SLOAD 0277 61 PUSH2 0x01d5 027A 90 SWAP1 027B 60 PUSH1 0x01 027D 60 PUSH1 0xa0 027F 1B SHL 0280 90 SWAP1 0281 04 DIV 0282 60 PUSH1 0xff 0284 16 AND 0285 81 DUP2 0286 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @027A stack[0] = 0x01d5 // @0284 stack[1] = 0xff & storage[0x04] / (0x01 << 0xa0) // } // Block ends with unconditional jump to 0x01d5 label_0287: // Incoming jump from 0x0104, if 0x4e1273f4 == stack[-1] // Inputs[1] { @028E msg.data.length } 0287 5B JUMPDEST 0288 61 PUSH2 0x029a 028B 61 PUSH2 0x0295 028E 36 CALLDATASIZE 028F 60 PUSH1 0x04 0291 61 PUSH2 0x23fa 0294 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0288 stack[0] = 0x029a // @028B stack[1] = 0x0295 // @028E stack[2] = msg.data.length // @028F stack[3] = 0x04 // } // Block ends with call to 0x23fa, returns to 0x0295 label_0295: // Incoming return from call to 0x23FA at 0x0294 0295 5B JUMPDEST 0296 61 PUSH2 0x0825 0299 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0825 label_029A: // Incoming return from call to 0x0295 at 0x0294 // Inputs[2] // { // @029D memory[0x40:0x60] // @02A1 stack[-1] // } 029A 5B JUMPDEST 029B 60 PUSH1 0x40 029D 51 MLOAD 029E 61 PUSH2 0x01b9 02A1 91 SWAP2 02A2 90 SWAP1 02A3 61 PUSH2 0x2500 02A6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02A1 stack[-1] = 0x01b9 // @02A2 stack[1] = memory[0x40:0x60] // @02A2 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2500 label_02A7: // Incoming jump from 0x010F, if 0x4eaa5db3 == stack[-1] // Inputs[1] { @02AE msg.data.length } 02A7 5B JUMPDEST 02A8 61 PUSH2 0x0223 02AB 61 PUSH2 0x02b5 02AE 36 CALLDATASIZE 02AF 60 PUSH1 0x04 02B1 61 PUSH2 0x2513 02B4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A8 stack[0] = 0x0223 // @02AB stack[1] = 0x02b5 // @02AE stack[2] = msg.data.length // @02AF stack[3] = 0x04 // } // Block ends with call to 0x2513, returns to 0x02B5 label_02B5: // Incoming return from call to 0x2513 at 0x02B4 02B5 5B JUMPDEST 02B6 61 PUSH2 0x0963 02B9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0963 label_02BA: // Incoming jump from 0x011A, if 0x5b7633d0 == stack[-1] // Inputs[1] { @02BD storage[0x04] } 02BA 5B JUMPDEST 02BB 60 PUSH1 0x04 02BD 54 SLOAD 02BE 61 PUSH2 0x01f8 02C1 90 SWAP1 02C2 60 PUSH1 0x01 02C4 60 PUSH1 0x01 02C6 60 PUSH1 0xa0 02C8 1B SHL 02C9 03 SUB 02CA 16 AND 02CB 81 DUP2 02CC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02C1 stack[0] = 0x01f8 // @02CA stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x04] // } // Block ends with unconditional jump to 0x01f8 label_02CD: // Incoming jump from 0x00C8, if 0x62a5af3b == stack[-1] 02CD 5B JUMPDEST 02CE 61 PUSH2 0x0223 02D1 61 PUSH2 0x09cd 02D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @02CE stack[0] = 0x0223 } // Block ends with call to 0x09cd, returns to 0x0223 label_02D5: // Incoming jump from 0x00D3, if 0x715018a6 == stack[-1] 02D5 5B JUMPDEST 02D6 61 PUSH2 0x0223 02D9 61 PUSH2 0x0a57 02DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @02D6 stack[0] = 0x0223 } // Block ends with call to 0x0a57, returns to 0x0223 label_02DD: // Incoming jump from 0x00DE, if 0x83ca5a05 == stack[-1] // Inputs[1] { @02E4 msg.data.length } 02DD 5B JUMPDEST 02DE 61 PUSH2 0x0223 02E1 61 PUSH2 0x02eb 02E4 36 CALLDATASIZE 02E5 60 PUSH1 0x04 02E7 61 PUSH2 0x2587 02EA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DE stack[0] = 0x0223 // @02E1 stack[1] = 0x02eb // @02E4 stack[2] = msg.data.length // @02E5 stack[3] = 0x04 // } // Block ends with call to 0x2587, returns to 0x02EB label_02EB: // Incoming return from call to 0x2587 at 0x02EA 02EB 5B JUMPDEST 02EC 61 PUSH2 0x0abd 02EF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0abd label_02F0: // Incoming jump from 0x00A2, if 0x8da5cb5b == stack[-1] // Inputs[1] { @02F3 storage[0x03] } 02F0 5B JUMPDEST 02F1 60 PUSH1 0x03 02F3 54 SLOAD 02F4 60 PUSH1 0x01 02F6 60 PUSH1 0x01 02F8 60 PUSH1 0xa0 02FA 1B SHL 02FB 03 SUB 02FC 16 AND 02FD 61 PUSH2 0x01f8 0300 56 *JUMP // Stack delta = +1 // Outputs[1] { @02FC stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x03] } // Block ends with unconditional jump to 0x01f8 label_0301: // Incoming jump from 0x00AD, if 0x9727756a == stack[-1] // Inputs[1] { @0308 msg.data.length } 0301 5B JUMPDEST 0302 61 PUSH2 0x0223 0305 61 PUSH2 0x030f 0308 36 CALLDATASIZE 0309 60 PUSH1 0x04 030B 61 PUSH2 0x2513 030E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0302 stack[0] = 0x0223 // @0305 stack[1] = 0x030f // @0308 stack[2] = msg.data.length // @0309 stack[3] = 0x04 // } // Block ends with call to 0x2513, returns to 0x030F label_030F: // Incoming return from call to 0x2513 at 0x030E 030F 5B JUMPDEST 0310 61 PUSH2 0x0b76 0313 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b76 label_0314: // Incoming jump from 0x00B8, if 0xa22cb465 == stack[-1] // Inputs[1] { @031B msg.data.length } 0314 5B JUMPDEST 0315 61 PUSH2 0x0223 0318 61 PUSH2 0x0322 031B 36 CALLDATASIZE 031C 60 PUSH1 0x04 031E 61 PUSH2 0x25a2 0321 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0315 stack[0] = 0x0223 // @0318 stack[1] = 0x0322 // @031B stack[2] = msg.data.length // @031C stack[3] = 0x04 // } // Block ends with call to 0x25a2, returns to 0x0322 label_0322: // Incoming return from call to 0x25A2 at 0x0321 0322 5B JUMPDEST 0323 61 PUSH2 0x0cec 0326 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cec label_0327: // Incoming jump from 0x0071, if 0xdffb8433 == stack[-1] // Inputs[1] { @032E msg.data.length } 0327 5B JUMPDEST 0328 61 PUSH2 0x0223 032B 61 PUSH2 0x0335 032E 36 CALLDATASIZE 032F 60 PUSH1 0x04 0331 61 PUSH2 0x2587 0334 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0328 stack[0] = 0x0223 // @032B stack[1] = 0x0335 // @032E stack[2] = msg.data.length // @032F stack[3] = 0x04 // } // Block ends with call to 0x2587, returns to 0x0335 label_0335: // Incoming return from call to 0x2587 at 0x0334 0335 5B JUMPDEST 0336 61 PUSH2 0x0df5 0339 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0df5 label_033A: // Incoming jump from 0x007C, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0341 msg.data.length } 033A 5B JUMPDEST 033B 61 PUSH2 0x01d5 033E 61 PUSH2 0x0348 0341 36 CALLDATASIZE 0342 60 PUSH1 0x04 0344 61 PUSH2 0x25de 0347 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @033B stack[0] = 0x01d5 // @033E stack[1] = 0x0348 // @0341 stack[2] = msg.data.length // @0342 stack[3] = 0x04 // } // Block ends with call to 0x25de, returns to 0x0348 label_0348: // Incoming return from call to 0x25DE at 0x0347 // Inputs[6] // { // @0351 stack[-2] // @0364 memory[0x00:0x40] // @0365 stack[-1] // @036F memory[0x00:0x40] // @0370 storage[keccak256(memory[0x00:0x40])] // @0374 stack[-3] // } 0348 5B JUMPDEST 0349 60 PUSH1 0x01 034B 60 PUSH1 0x01 034D 60 PUSH1 0xa0 034F 1B SHL 0350 03 SUB 0351 91 SWAP2 0352 82 DUP3 0353 16 AND 0354 60 PUSH1 0x00 0356 90 SWAP1 0357 81 DUP2 0358 52 MSTORE 0359 60 PUSH1 0x01 035B 60 PUSH1 0x20 035D 90 SWAP1 035E 81 DUP2 035F 52 MSTORE 0360 60 PUSH1 0x40 0362 80 DUP1 0363 83 DUP4 0364 20 SHA3 0365 93 SWAP4 0366 90 SWAP1 0367 94 SWAP5 0368 16 AND 0369 82 DUP3 036A 52 MSTORE 036B 91 SWAP2 036C 90 SWAP1 036D 91 SWAP2 036E 52 MSTORE 036F 20 SHA3 0370 54 SLOAD 0371 60 PUSH1 0xff 0373 16 AND 0374 90 SWAP1 0375 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0358 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @035F memory[0x20:0x40] = 0x01 // @036A memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @036E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0374 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0376: // Incoming jump from 0x0087, if 0xe9cf98ae == stack[-1] // Inputs[1] { @037D msg.data.length } 0376 5B JUMPDEST 0377 61 PUSH2 0x0223 037A 61 PUSH2 0x0384 037D 36 CALLDATASIZE 037E 60 PUSH1 0x04 0380 61 PUSH2 0x2587 0383 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0377 stack[0] = 0x0223 // @037A stack[1] = 0x0384 // @037D stack[2] = msg.data.length // @037E stack[3] = 0x04 // } // Block ends with call to 0x2587, returns to 0x0384 label_0384: // Incoming return from call to 0x2587 at 0x0383 0384 5B JUMPDEST 0385 61 PUSH2 0x0e7e 0388 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e7e label_0389: // Incoming jump from 0x004B, if 0xf242432a == stack[-1] // Inputs[1] { @0390 msg.data.length } 0389 5B JUMPDEST 038A 61 PUSH2 0x0223 038D 61 PUSH2 0x0397 0390 36 CALLDATASIZE 0391 60 PUSH1 0x04 0393 61 PUSH2 0x2611 0396 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @038A stack[0] = 0x0223 // @038D stack[1] = 0x0397 // @0390 stack[2] = msg.data.length // @0391 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2611 0397 5B JUMPDEST 0398 61 PUSH2 0x0ff2 039B 56 *JUMP label_039C: // Incoming jump from 0x0056, if 0xf2fde38b == stack[-1] // Inputs[1] { @03A3 msg.data.length } 039C 5B JUMPDEST 039D 61 PUSH2 0x0223 03A0 61 PUSH2 0x03aa 03A3 36 CALLDATASIZE 03A4 60 PUSH1 0x04 03A6 61 PUSH2 0x2587 03A9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @039D stack[0] = 0x0223 // @03A0 stack[1] = 0x03aa // @03A3 stack[2] = msg.data.length // @03A4 stack[3] = 0x04 // } // Block ends with call to 0x2587, returns to 0x03AA label_03AA: // Incoming return from call to 0x2587 at 0x03A9 03AA 5B JUMPDEST 03AB 61 PUSH2 0x108d 03AE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x108d label_03AF: // Incoming jump from 0x0061, if 0xfd8fd9a5 == stack[-1] // Inputs[1] { @03B2 storage[0x07] } 03AF 5B JUMPDEST 03B0 60 PUSH1 0x07 03B2 54 SLOAD 03B3 61 PUSH2 0x01f8 03B6 90 SWAP1 03B7 60 PUSH1 0x01 03B9 60 PUSH1 0x01 03BB 60 PUSH1 0xa0 03BD 1B SHL 03BE 03 SUB 03BF 16 AND 03C0 81 DUP2 03C1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03B6 stack[0] = 0x01f8 // @03BF stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x07] // } // Block ends with unconditional jump to 0x01f8 label_03C2: // Incoming jump from 0x01AE // Incoming jump from 0x092D // Inputs[1] { @03CD stack[-2] } 03C2 5B JUMPDEST 03C3 60 PUSH1 0x00 03C5 60 PUSH1 0x01 03C7 60 PUSH1 0x01 03C9 60 PUSH1 0xa0 03CB 1B SHL 03CC 03 SUB 03CD 83 DUP4 03CE 16 AND 03CF 61 PUSH2 0x0445 03D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C3 stack[0] = 0x00 } // Block ends with conditional jump to 0x0445, if stack[-2] & (0x01 << 0xa0) - 0x01 label_03D3: // Incoming jump from 0x03D2, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @03D5 memory[0x40:0x60] } 03D3 60 PUSH1 0x40 03D5 51 MLOAD 03D6 62 PUSH3 0x461bcd 03DA 60 PUSH1 0xe5 03DC 1B SHL 03DD 81 DUP2 03DE 52 MSTORE 03DF 60 PUSH1 0x20 03E1 60 PUSH1 0x04 03E3 82 DUP3 03E4 01 ADD 03E5 52 MSTORE 03E6 60 PUSH1 0x2b 03E8 60 PUSH1 0x24 03EA 82 DUP3 03EB 01 ADD 03EC 52 MSTORE 03ED 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 040E 60 PUSH1 0x44 0410 82 DUP3 0411 01 ADD 0412 52 MSTORE 0413 7F PUSH32 0x65726f2061646472657373000000000000000000000000000000000000000000 0434 60 PUSH1 0x64 0436 82 DUP3 0437 01 ADD 0438 52 MSTORE 0439 60 PUSH1 0x84 043B 01 ADD // Stack delta = +1 // Outputs[6] // { // @03DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @03E5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @03EC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @0412 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @0438 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373000000000000000000000000000000000000000000 // @043B stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_043C: // Incoming jump from 0x10E6 // Incoming jump from 0x043B // Incoming jump from 0x0C4A // Incoming jump from 0x1D9E // Incoming jump from 0x1D9E // Incoming jump from 0x197A // Incoming jump from 0x1E55 // Incoming jump from 0x0653 // Incoming jump from 0x1918 // Incoming jump from 0x16B3 // Incoming jump from 0x0A26 // Incoming jump from 0x1651 // Incoming jump from 0x0824 // Incoming jump from 0x089D // Incoming jump from 0x05D3 // Incoming jump from 0x0ED7 // Incoming jump from 0x0CCA // Incoming jump from 0x0AB0 // Incoming jump from 0x0B16 // Incoming jump from 0x0D6A // Incoming jump from 0x17A7 // Incoming jump from 0x09BC // Incoming jump from 0x0E4E // Incoming jump from 0x1162 // Inputs[3] // { // @043F memory[0x40:0x60] // @0441 stack[-1] // @0444 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 043C 5B JUMPDEST 043D 60 PUSH1 0x40 043F 51 MLOAD 0440 80 DUP1 0441 91 SWAP2 0442 03 SUB 0443 90 SWAP1 0444 FD *REVERT // Stack delta = -1 // Outputs[1] { @0444 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0445: // Incoming jump from 0x03D2, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0449 stack[-2] // @0455 memory[0x00:0x40] // @045E stack[-3] // @0467 memory[0x00:0x40] // @0468 storage[keccak256(memory[0x00:0x40])] // @0469 stack[-4] // } 0445 5B JUMPDEST 0446 50 POP 0447 60 PUSH1 0x00 0449 90 SWAP1 044A 81 DUP2 044B 52 MSTORE 044C 60 PUSH1 0x20 044E 81 DUP2 044F 81 DUP2 0450 52 MSTORE 0451 60 PUSH1 0x40 0453 80 DUP1 0454 83 DUP4 0455 20 SHA3 0456 60 PUSH1 0x01 0458 60 PUSH1 0x01 045A 60 PUSH1 0xa0 045C 1B SHL 045D 03 SUB 045E 94 SWAP5 045F 90 SWAP1 0460 94 SWAP5 0461 16 AND 0462 83 DUP4 0463 52 MSTORE 0464 92 SWAP3 0465 90 SWAP1 0466 52 MSTORE 0467 20 SHA3 0468 54 SLOAD 0469 90 SWAP1 046A 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @044B memory[0x00:0x20] = stack[-2] // @0450 memory[0x20:0x40] = 0x00 // @0463 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0466 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0469 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_046B: // Incoming jump from 0x01D4 // Inputs[1] { @048F stack[-1] } 046B 5B JUMPDEST 046C 60 PUSH1 0x00 046E 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 048F 82 DUP3 0490 16 AND 0491 7F PUSH32 0xd9b67a2600000000000000000000000000000000000000000000000000000000 04B2 14 EQ 04B3 80 DUP1 04B4 61 PUSH2 0x04fe 04B7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @046C stack[0] = 0x00 // @04B2 stack[1] = 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x04fe, if 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_04B8: // Incoming jump from 0x04B7, if not 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @04DA stack[-3] } 04B8 50 POP 04B9 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 04DA 82 DUP3 04DB 16 AND 04DC 7F PUSH32 0x0e89341c00000000000000000000000000000000000000000000000000000000 04FD 14 EQ 04FE 5B JUMPDEST 04FF 80 DUP1 0500 61 PUSH2 0x054a 0503 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04FD stack[-1] = 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x054a, if 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_0504: // Incoming jump from 0x0503, if not 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0503, if not stack[-1] // Inputs[2] // { // @0547 stack[-3] // @054B stack[-4] // } 0504 50 POP 0505 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 0526 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 0547 83 DUP4 0548 16 AND 0549 14 EQ 054A 5B JUMPDEST 054B 92 SWAP3 054C 91 SWAP2 054D 50 POP 054E 50 POP 054F 56 *JUMP // Stack delta = -3 // Outputs[1] { @054B stack[-4] = stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-4] label_0550: // Incoming jump from 0x01F7 // Inputs[2] // { // @0553 stack[-1] // @0555 storage[0x06] // } 0550 5B JUMPDEST 0551 60 PUSH1 0x06 0553 81 DUP2 0554 81 DUP2 0555 54 SLOAD 0556 81 DUP2 0557 10 LT 0558 61 PUSH2 0x0560 055B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0551 stack[0] = 0x06 // @0553 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0560, if stack[-1] < storage[0x06] label_055C: // Incoming jump from 0x055B, if not stack[-1] < storage[0x06] // Inputs[1] { @055F memory[0x00:0x00] } 055C 60 PUSH1 0x00 055E 80 DUP1 055F FD *REVERT // Stack delta = +0 // Outputs[1] { @055F revert(memory[0x00:0x00]); } // Block terminates label_0560: // Incoming jump from 0x055B, if stack[-1] < storage[0x06] // Inputs[6] // { // @0563 stack[-2] // @0568 stack[-1] // @056A memory[0x00:0x20] // @056C storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0576 stack[-3] // @0578 stack[-4] // } 0560 5B JUMPDEST 0561 60 PUSH1 0x00 0563 91 SWAP2 0564 82 DUP3 0565 52 MSTORE 0566 60 PUSH1 0x20 0568 90 SWAP1 0569 91 SWAP2 056A 20 SHA3 056B 01 ADD 056C 54 SLOAD 056D 60 PUSH1 0x01 056F 60 PUSH1 0x01 0571 60 PUSH1 0xa0 0573 1B SHL 0574 03 SUB 0575 16 AND 0576 90 SWAP1 0577 50 POP 0578 81 DUP2 0579 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0565 memory[0x00:0x20] = stack[-2] // @0576 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-4] label_057A: // Incoming jump from 0x0222 // Inputs[2] // { // @057D storage[0x03] // @0587 msg.sender // } 057A 5B JUMPDEST 057B 60 PUSH1 0x03 057D 54 SLOAD 057E 60 PUSH1 0x01 0580 60 PUSH1 0x01 0582 60 PUSH1 0xa0 0584 1B SHL 0585 03 SUB 0586 16 AND 0587 33 CALLER 0588 14 EQ 0589 61 PUSH2 0x05d4 058C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_058D: // Incoming jump from 0x058C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @058F memory[0x40:0x60] } 058D 60 PUSH1 0x40 058F 51 MLOAD 0590 62 PUSH3 0x461bcd 0594 60 PUSH1 0xe5 0596 1B SHL 0597 81 DUP2 0598 52 MSTORE 0599 60 PUSH1 0x20 059B 60 PUSH1 0x04 059D 82 DUP3 059E 01 ADD 059F 81 DUP2 05A0 90 SWAP1 05A1 52 MSTORE 05A2 60 PUSH1 0x24 05A4 82 DUP3 05A5 01 ADD 05A6 52 MSTORE 05A7 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 05C8 60 PUSH1 0x44 05CA 82 DUP3 05CB 01 ADD 05CC 52 MSTORE 05CD 60 PUSH1 0x64 05CF 01 ADD 05D0 61 PUSH2 0x043c 05D3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0598 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05A1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05A6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @05CC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @05CF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_05D4: // Incoming jump from 0x058C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @05D7 storage[0x04] } 05D4 5B JUMPDEST 05D5 60 PUSH1 0x04 05D7 54 SLOAD 05D8 60 PUSH1 0x01 05DA 60 PUSH1 0xa0 05DC 1B SHL 05DD 90 SWAP1 05DE 04 DIV 05DF 60 PUSH1 0xff 05E1 16 AND 05E2 15 ISZERO 05E3 61 PUSH2 0x0654 05E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0654, if !(0xff & storage[0x04] / (0x01 << 0xa0)) label_05E7: // Incoming jump from 0x05E6, if not !(0xff & storage[0x04] / (0x01 << 0xa0)) // Inputs[1] { @05E9 memory[0x40:0x60] } 05E7 60 PUSH1 0x40 05E9 51 MLOAD 05EA 62 PUSH3 0x461bcd 05EE 60 PUSH1 0xe5 05F0 1B SHL 05F1 81 DUP2 05F2 52 MSTORE 05F3 60 PUSH1 0x20 05F5 60 PUSH1 0x04 05F7 82 DUP3 05F8 01 ADD 05F9 52 MSTORE 05FA 60 PUSH1 0x27 05FC 60 PUSH1 0x24 05FE 82 DUP3 05FF 01 ADD 0600 52 MSTORE 0601 7F PUSH32 0x546869732066756e6374696f6e2063616e206e6f742062652063616c6c656420 0622 60 PUSH1 0x44 0624 82 DUP3 0625 01 ADD 0626 52 MSTORE 0627 7F PUSH32 0x616e796d6f726500000000000000000000000000000000000000000000000000 0648 60 PUSH1 0x64 064A 82 DUP3 064B 01 ADD 064C 52 MSTORE 064D 60 PUSH1 0x84 064F 01 ADD 0650 61 PUSH2 0x043c 0653 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @05F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05F9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0600 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x27 // @0626 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x546869732066756e6374696f6e2063616e206e6f742062652063616c6c656420 // @064C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616e796d6f726500000000000000000000000000000000000000000000000000 // @064F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0654: // Incoming jump from 0x05E6, if !(0xff & storage[0x04] / (0x01 << 0xa0)) // Inputs[1] { @0658 stack[-1] } 0654 5B JUMPDEST 0655 61 PUSH2 0x065d 0658 81 DUP2 0659 61 PUSH2 0x116c 065C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0655 stack[0] = 0x065d // @0658 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x116c label_065D: // Incoming jump from 0x2104, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming return from call to 0x183E at 0x116B // Incoming jump from 0x07DD, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @065F stack[-2] } 065D 5B JUMPDEST 065E 50 POP 065F 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0660: // Incoming call from 0x022C, returns to 0x022D // Inputs[1] { @0664 storage[0x05] } 0660 5B JUMPDEST 0661 60 PUSH1 0x05 0663 80 DUP1 0664 54 SLOAD 0665 61 PUSH2 0x066d 0668 90 SWAP1 0669 61 PUSH2 0x2676 066C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0661 stack[0] = 0x05 // @0668 stack[1] = 0x066d // @0668 stack[2] = storage[0x05] // } // Block ends with call to 0x2676, returns to 0x066D label_066D: // Incoming return from call to 0x2676 at 0x066C // Inputs[4] // { // @066E stack[-1] // @067D memory[0x40:0x60] // @0685 stack[-2] // @0690 storage[stack[-2]] // } 066D 5B JUMPDEST 066E 80 DUP1 066F 60 PUSH1 0x1f 0671 01 ADD 0672 60 PUSH1 0x20 0674 80 DUP1 0675 91 SWAP2 0676 04 DIV 0677 02 MUL 0678 60 PUSH1 0x20 067A 01 ADD 067B 60 PUSH1 0x40 067D 51 MLOAD 067E 90 SWAP1 067F 81 DUP2 0680 01 ADD 0681 60 PUSH1 0x40 0683 52 MSTORE 0684 80 DUP1 0685 92 SWAP3 0686 91 SWAP2 0687 90 SWAP1 0688 81 DUP2 0689 81 DUP2 068A 52 MSTORE 068B 60 PUSH1 0x20 068D 01 ADD 068E 82 DUP3 068F 80 DUP1 0690 54 SLOAD 0691 61 PUSH2 0x0699 0694 90 SWAP1 0695 61 PUSH2 0x2676 0698 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0683 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0685 stack[-2] = memory[0x40:0x60] // @0686 stack[-1] = stack[-2] // @0687 stack[0] = stack[-1] // @068A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @068D stack[1] = 0x20 + memory[0x40:0x60] // @068E stack[2] = stack[-2] // @0694 stack[4] = storage[stack[-2]] // @0694 stack[3] = 0x0699 // } // Block ends with call to 0x2676, returns to 0x0699 label_0699: // Incoming return from call to 0x2676 at 0x0698 // Inputs[1] { @069A stack[-1] } 0699 5B JUMPDEST 069A 80 DUP1 069B 15 ISZERO 069C 61 PUSH2 0x06e6 069F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e6, if !stack[-1] label_06A0: // Incoming jump from 0x069F, if not !stack[-1] // Inputs[1] { @06A0 stack[-1] } 06A0 80 DUP1 06A1 60 PUSH1 0x1f 06A3 10 LT 06A4 61 PUSH2 0x06bb 06A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06bb, if 0x1f < stack[-1] label_06A8: // Incoming jump from 0x06A7, if not 0x1f < stack[-1] // Inputs[4] // { // @06AC stack[-2] // @06AD storage[stack[-2]] // @06B0 stack[-3] // @06B2 stack[-1] // } 06A8 61 PUSH2 0x0100 06AB 80 DUP1 06AC 83 DUP4 06AD 54 SLOAD 06AE 04 DIV 06AF 02 MUL 06B0 83 DUP4 06B1 52 MSTORE 06B2 91 SWAP2 06B3 60 PUSH1 0x20 06B5 01 ADD 06B6 91 SWAP2 06B7 61 PUSH2 0x06e6 06BA 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06B1 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @06B6 stack[-1] = stack[-1] // @06B6 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06e6 label_06BB: // Incoming jump from 0x06A7, if 0x1f < stack[-1] // Inputs[5] // { // @06BC stack[-3] // @06BD stack[-1] // @06BF stack[-2] // @06C7 memory[0x00:0x20] // @06CB storage[keccak256(memory[0x00:0x20])] // } 06BB 5B JUMPDEST 06BC 82 DUP3 06BD 01 ADD 06BE 91 SWAP2 06BF 90 SWAP1 06C0 60 PUSH1 0x00 06C2 52 MSTORE 06C3 60 PUSH1 0x20 06C5 60 PUSH1 0x00 06C7 20 SHA3 06C8 90 SWAP1 06C9 5B JUMPDEST 06CA 81 DUP2 06CB 54 SLOAD 06CC 81 DUP2 06CD 52 MSTORE 06CE 90 SWAP1 06CF 60 PUSH1 0x01 06D1 01 ADD 06D2 90 SWAP1 06D3 60 PUSH1 0x20 06D5 01 ADD 06D6 80 DUP1 06D7 83 DUP4 06D8 11 GT 06D9 61 PUSH2 0x06c9 06DC 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @06BE stack[-3] = stack[-3] + stack[-1] // @06C2 memory[0x00:0x20] = stack[-2] // @06CD memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06D2 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06D5 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06c9, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06DD: // Incoming jump from 0x06DC, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x06DC, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @06DD stack[-3] // @06DE stack[-1] // } 06DD 82 DUP3 06DE 90 SWAP1 06DF 03 SUB 06E0 60 PUSH1 0x1f 06E2 16 AND 06E3 82 DUP3 06E4 01 ADD 06E5 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @06E5 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @06E5 stack[-1] = stack[-3] // } // Block continues label_06E6: // Incoming jump from 0x06E5 // Incoming jump from 0x06BA // Incoming jump from 0x069F, if !stack[-1] // Inputs[1] { @06EC stack[-7] } 06E6 5B JUMPDEST 06E7 50 POP 06E8 50 POP 06E9 50 POP 06EA 50 POP 06EB 50 POP 06EC 81 DUP2 06ED 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_06EE: // Incoming jump from 0x024C // Inputs[1] { @06F4 stack[-1] } 06EE 5B JUMPDEST 06EF 60 PUSH1 0x60 06F1 61 PUSH2 0x06f9 06F4 82 DUP3 06F5 61 PUSH2 0x117f 06F8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06EF stack[0] = 0x60 // @06F1 stack[1] = 0x06f9 // @06F4 stack[2] = stack[-1] // } // Block ends with call to 0x117f, returns to 0x06F9 label_06F9: // Incoming return from call to 0x117F at 0x06F8 // Inputs[1] { @06FD stack[-3] } 06F9 5B JUMPDEST 06FA 61 PUSH2 0x0702 06FD 83 DUP4 06FE 61 PUSH2 0x1213 0701 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06FA stack[0] = 0x0702 // @06FD stack[1] = stack[-3] // } // Block ends with call to 0x1213, returns to 0x0702 label_0702: // Incoming return from call to 0x1213 at 0x0701 // Inputs[3] // { // @0705 memory[0x40:0x60] // @070C stack[-2] // @070D stack[-1] // } 0702 5B JUMPDEST 0703 60 PUSH1 0x40 0705 51 MLOAD 0706 60 PUSH1 0x20 0708 01 ADD 0709 61 PUSH2 0x0713 070C 92 SWAP3 070D 91 SWAP2 070E 90 SWAP1 070F 61 PUSH2 0x26b1 0712 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @070C stack[-2] = 0x0713 // @070D stack[-1] = stack[-2] // @070E stack[1] = 0x20 + memory[0x40:0x60] // @070E stack[0] = stack[-1] // } // Block ends with call to 0x26b1, returns to 0x0713 label_0713: // Incoming return from call to 0x26B1 at 0x0712 // Inputs[5] // { // @0716 memory[0x40:0x60] // @071A stack[-1] // @0723 stack[-2] // @0725 stack[-4] // @0726 stack[-3] // } 0713 5B JUMPDEST 0714 60 PUSH1 0x40 0716 51 MLOAD 0717 60 PUSH1 0x20 0719 81 DUP2 071A 83 DUP4 071B 03 SUB 071C 03 SUB 071D 81 DUP2 071E 52 MSTORE 071F 90 SWAP1 0720 60 PUSH1 0x40 0722 52 MSTORE 0723 90 SWAP1 0724 50 POP 0725 91 SWAP2 0726 90 SWAP1 0727 50 POP 0728 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @071E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0722 memory[0x40:0x60] = stack[-1] // @0725 stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] 0729 5B JUMPDEST 072A 60 PUSH1 0x01 072C 60 PUSH1 0x01 072E 60 PUSH1 0xa0 0730 1B SHL 0731 03 SUB 0732 85 DUP6 0733 16 AND 0734 33 CALLER 0735 14 EQ 0736 80 DUP1 0737 61 PUSH2 0x0745 073A 57 *JUMPI 073B 50 POP 073C 61 PUSH2 0x0745 073F 85 DUP6 0740 33 CALLER 0741 61 PUSH2 0x0348 0744 56 *JUMP 0745 5B JUMPDEST 0746 61 PUSH2 0x07b7 0749 57 *JUMPI 074A 60 PUSH1 0x40 074C 51 MLOAD 074D 62 PUSH3 0x461bcd 0751 60 PUSH1 0xe5 0753 1B SHL 0754 81 DUP2 0755 52 MSTORE 0756 60 PUSH1 0x20 0758 60 PUSH1 0x04 075A 82 DUP3 075B 01 ADD 075C 52 MSTORE 075D 60 PUSH1 0x32 075F 60 PUSH1 0x24 0761 82 DUP3 0762 01 ADD 0763 52 MSTORE 0764 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 0785 60 PUSH1 0x44 0787 82 DUP3 0788 01 ADD 0789 52 MSTORE 078A 7F PUSH32 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 07AB 60 PUSH1 0x64 07AD 82 DUP3 07AE 01 ADD 07AF 52 MSTORE 07B0 60 PUSH1 0x84 07B2 01 ADD 07B3 61 PUSH2 0x043c 07B6 56 *JUMP 07B7 5B JUMPDEST 07B8 61 PUSH2 0x07c4 07BB 85 DUP6 07BC 85 DUP6 07BD 85 DUP6 07BE 85 DUP6 07BF 85 DUP6 07C0 61 PUSH2 0x134d 07C3 56 *JUMP label_07C4: // Incoming return from call to 0x1C51 at 0x1A7E // Inputs[1] { @07CA stack[-6] } 07C4 5B JUMPDEST 07C5 50 POP 07C6 50 POP 07C7 50 POP 07C8 50 POP 07C9 50 POP 07CA 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_07CB: // Incoming jump from 0x0272 // Inputs[2] // { // @07CE storage[0x03] // @07D8 msg.sender // } 07CB 5B JUMPDEST 07CC 60 PUSH1 0x03 07CE 54 SLOAD 07CF 60 PUSH1 0x01 07D1 60 PUSH1 0x01 07D3 60 PUSH1 0xa0 07D5 1B SHL 07D6 03 SUB 07D7 16 AND 07D8 33 CALLER 07D9 14 EQ 07DA 61 PUSH2 0x065d 07DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_07DE: // Incoming jump from 0x07DD, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @07E0 memory[0x40:0x60] } 07DE 60 PUSH1 0x40 07E0 51 MLOAD 07E1 62 PUSH3 0x461bcd 07E5 60 PUSH1 0xe5 07E7 1B SHL 07E8 81 DUP2 07E9 52 MSTORE 07EA 60 PUSH1 0x20 07EC 60 PUSH1 0x04 07EE 82 DUP3 07EF 01 ADD 07F0 81 DUP2 07F1 90 SWAP1 07F2 52 MSTORE 07F3 60 PUSH1 0x24 07F5 82 DUP3 07F6 01 ADD 07F7 52 MSTORE 07F8 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0819 60 PUSH1 0x44 081B 82 DUP3 081C 01 ADD 081D 52 MSTORE 081E 60 PUSH1 0x64 0820 01 ADD 0821 61 PUSH2 0x043c 0824 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @07E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07F2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07F7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @081D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0820 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0825: // Incoming jump from 0x0299 // Inputs[4] // { // @0828 stack[-1] // @0829 memory[stack[-1]:stack[-1] + 0x20] // @082A stack[-2] // @082B memory[stack[-2]:stack[-2] + 0x20] // } 0825 5B JUMPDEST 0826 60 PUSH1 0x60 0828 81 DUP2 0829 51 MLOAD 082A 83 DUP4 082B 51 MLOAD 082C 14 EQ 082D 61 PUSH2 0x089e 0830 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0826 stack[0] = 0x60 } // Block ends with conditional jump to 0x089e, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_0831: // Incoming jump from 0x0830, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @0833 memory[0x40:0x60] } 0831 60 PUSH1 0x40 0833 51 MLOAD 0834 62 PUSH3 0x461bcd 0838 60 PUSH1 0xe5 083A 1B SHL 083B 81 DUP2 083C 52 MSTORE 083D 60 PUSH1 0x20 083F 60 PUSH1 0x04 0841 82 DUP3 0842 01 ADD 0843 52 MSTORE 0844 60 PUSH1 0x29 0846 60 PUSH1 0x24 0848 82 DUP3 0849 01 ADD 084A 52 MSTORE 084B 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 086C 60 PUSH1 0x44 086E 82 DUP3 086F 01 ADD 0870 52 MSTORE 0871 7F PUSH32 0x206d69736d617463680000000000000000000000000000000000000000000000 0892 60 PUSH1 0x64 0894 82 DUP3 0895 01 ADD 0896 52 MSTORE 0897 60 PUSH1 0x84 0899 01 ADD 089A 61 PUSH2 0x043c 089D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @083C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0843 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @084A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0870 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 // @0896 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x206d69736d617463680000000000000000000000000000000000000000000000 // @0899 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_089E: // Incoming jump from 0x0830, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @08A1 stack[-3] // @08A2 memory[stack[-3]:stack[-3] + 0x20] // } 089E 5B JUMPDEST 089F 60 PUSH1 0x00 08A1 83 DUP4 08A2 51 MLOAD 08A3 67 PUSH8 0xffffffffffffffff 08AC 81 DUP2 08AD 11 GT 08AE 15 ISZERO 08AF 61 PUSH2 0x08ba 08B2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @089F stack[0] = 0x00 // @08A2 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x08ba, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_08B3: // Incoming jump from 0x08B2, if not !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) 08B3 61 PUSH2 0x08ba 08B6 61 PUSH2 0x2146 08B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @08B3 stack[0] = 0x08ba } // Block ends with unconditional jump to 0x2146 label_08BA: // Incoming jump from 0x08B2, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @08BD memory[0x40:0x60] // @08BE stack[-1] // } 08BA 5B JUMPDEST 08BB 60 PUSH1 0x40 08BD 51 MLOAD 08BE 90 SWAP1 08BF 80 DUP1 08C0 82 DUP3 08C1 52 MSTORE 08C2 80 DUP1 08C3 60 PUSH1 0x20 08C5 02 MUL 08C6 60 PUSH1 0x20 08C8 01 ADD 08C9 82 DUP3 08CA 01 ADD 08CB 60 PUSH1 0x40 08CD 52 MSTORE 08CE 80 DUP1 08CF 15 ISZERO 08D0 61 PUSH2 0x08e3 08D3 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @08BE stack[-1] = memory[0x40:0x60] // @08BE stack[0] = stack[-1] // @08C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @08CD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x08e3, if !stack[-1] label_08D4: // Incoming jump from 0x08D3, if not !stack[-1] // Inputs[7] // { // @08D4 stack[-2] // @08DA stack[-1] // @08DD msg.data.length // @08DF msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @08E5 stack[-3] // @08EA stack[-6] // @08EB memory[stack[-6]:stack[-6] + 0x20] // } 08D4 81 DUP2 08D5 60 PUSH1 0x20 08D7 01 ADD 08D8 60 PUSH1 0x20 08DA 82 DUP3 08DB 02 MUL 08DC 80 DUP1 08DD 36 CALLDATASIZE 08DE 83 DUP4 08DF 37 CALLDATACOPY 08E0 01 ADD 08E1 90 SWAP1 08E2 50 POP 08E3 5B JUMPDEST 08E4 50 POP 08E5 90 SWAP1 08E6 50 POP 08E7 60 PUSH1 0x00 08E9 5B JUMPDEST 08EA 84 DUP5 08EB 51 MLOAD 08EC 81 DUP2 08ED 10 LT 08EE 15 ISZERO 08EF 61 PUSH2 0x095b 08F2 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @08DF memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @08E5 stack[-3] = stack[-2] // @08E7 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x095b, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_08F3: // Incoming jump from 0x08F2, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x08F2, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x08F2, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @08F6 stack[-5] // @08F7 stack[-1] // @08F9 memory[stack[-5]:stack[-5] + 0x20] // } 08F3 61 PUSH2 0x092e 08F6 85 DUP6 08F7 82 DUP3 08F8 81 DUP2 08F9 51 MLOAD 08FA 81 DUP2 08FB 10 LT 08FC 61 PUSH2 0x0907 08FF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08F3 stack[0] = 0x092e // @08F6 stack[1] = stack[-5] // @08F7 stack[2] = stack[-1] // } // Block ends with conditional call to 0x0907, returns to 0x092E, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_0900: // Incoming jump from 0x08FF, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 0900 61 PUSH2 0x0907 0903 61 PUSH2 0x26e0 0906 56 *JUMP // Stack delta = +1 // Outputs[1] { @0900 stack[0] = 0x0907 } // Block ends with unconditional jump to 0x26e0 label_0907: // Incoming call from 0x08FF, returns to 0x092E, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @090A stack[-1] // @090E stack[-2] // @090F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0910 stack[-7] // @0911 stack[-4] // @0913 memory[stack[-7]:stack[-7] + 0x20] // } 0907 5B JUMPDEST 0908 60 PUSH1 0x20 090A 02 MUL 090B 60 PUSH1 0x20 090D 01 ADD 090E 01 ADD 090F 51 MLOAD 0910 85 DUP6 0911 83 DUP4 0912 81 DUP2 0913 51 MLOAD 0914 81 DUP2 0915 10 LT 0916 61 PUSH2 0x0921 0919 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @090F stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0910 stack[-1] = stack[-7] // @0911 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0921, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_091A: // Incoming jump from 0x0919, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] 091A 61 PUSH2 0x0921 091D 61 PUSH2 0x26e0 0920 56 *JUMP // Stack delta = +1 // Outputs[1] { @091A stack[0] = 0x0921 } // Block ends with unconditional jump to 0x26e0 label_0921: // Incoming jump from 0x0919, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @0924 stack[-1] // @0928 stack[-2] // @0929 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0921 5B JUMPDEST 0922 60 PUSH1 0x20 0924 02 MUL 0925 60 PUSH1 0x20 0927 01 ADD 0928 01 ADD 0929 51 MLOAD 092A 61 PUSH2 0x03c2 092D 56 *JUMP // Stack delta = -1 // Outputs[1] { @0929 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x03c2 label_092E: // Incoming return from call to 0x0907 at 0x08FF // Inputs[3] // { // @092F stack[-3] // @0930 stack[-2] // @0932 memory[stack[-3]:stack[-3] + 0x20] // } 092E 5B JUMPDEST 092F 82 DUP3 0930 82 DUP3 0931 81 DUP2 0932 51 MLOAD 0933 81 DUP2 0934 10 LT 0935 61 PUSH2 0x0940 0938 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @092F stack[0] = stack[-3] // @0930 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0940, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_0939: // Incoming jump from 0x0938, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] 0939 61 PUSH2 0x0940 093C 61 PUSH2 0x26e0 093F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0939 stack[0] = 0x0940 } // Block ends with unconditional jump to 0x26e0 label_0940: // Incoming jump from 0x0938, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0943 stack[-1] // @0946 stack[-2] // @094B stack[-3] // @094F stack[-4] // } 0940 5B JUMPDEST 0941 60 PUSH1 0x20 0943 90 SWAP1 0944 81 DUP2 0945 02 MUL 0946 91 SWAP2 0947 90 SWAP1 0948 91 SWAP2 0949 01 ADD 094A 01 ADD 094B 52 MSTORE 094C 61 PUSH2 0x0954 094F 81 DUP2 0950 61 PUSH2 0x270c 0953 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @094B memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @094C stack[-3] = 0x0954 // @094F stack[-2] = stack[-4] // } // Block ends with call to 0x270c, returns to 0x0954 label_0954: // Incoming return from call to 0x270C at 0x0953 // Inputs[2] // { // @0955 stack[-1] // @0955 stack[-2] // } 0954 5B JUMPDEST 0955 90 SWAP1 0956 50 POP 0957 61 PUSH2 0x08e9 095A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0955 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x08e9 label_095B: // Incoming jump from 0x08F2, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x08F2, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x08F2, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @095D stack[-6] // @095D stack[-2] // @095E stack[-5] // } 095B 5B JUMPDEST 095C 50 POP 095D 93 SWAP4 095E 92 SWAP3 095F 50 POP 0960 50 POP 0961 50 POP 0962 56 *JUMP // Stack delta = -5 // Outputs[1] { @095D stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0963: // Incoming jump from 0x02B9 // Inputs[2] // { // @0966 storage[0x07] // @0970 msg.sender // } 0963 5B JUMPDEST 0964 60 PUSH1 0x07 0966 54 SLOAD 0967 60 PUSH1 0x01 0969 60 PUSH1 0x01 096B 60 PUSH1 0xa0 096D 1B SHL 096E 03 SUB 096F 16 AND 0970 33 CALLER 0971 14 EQ 0972 61 PUSH2 0x09bd 0975 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09bd, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0976: // Incoming jump from 0x0975, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0978 memory[0x40:0x60] } 0976 60 PUSH1 0x40 0978 51 MLOAD 0979 62 PUSH3 0x461bcd 097D 60 PUSH1 0xe5 097F 1B SHL 0980 81 DUP2 0981 52 MSTORE 0982 60 PUSH1 0x20 0984 60 PUSH1 0x04 0986 82 DUP3 0987 01 ADD 0988 52 MSTORE 0989 60 PUSH1 0x15 098B 60 PUSH1 0x24 098D 82 DUP3 098E 01 ADD 098F 52 MSTORE 0990 7F PUSH32 0x43616c6c6572206973206e6f7420616c6c6f7765640000000000000000000000 09B1 60 PUSH1 0x44 09B3 82 DUP3 09B4 01 ADD 09B5 52 MSTORE 09B6 60 PUSH1 0x64 09B8 01 ADD 09B9 61 PUSH2 0x043c 09BC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0981 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0988 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @098F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @09B5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616c6c6572206973206e6f7420616c6c6f7765640000000000000000000000 // @09B8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_09BD: // Incoming jump from 0x0975, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[3] // { // @09C1 stack[-3] // @09C2 stack[-2] // @09C3 stack[-1] // } 09BD 5B JUMPDEST 09BE 61 PUSH2 0x09c8 09C1 83 DUP4 09C2 83 DUP4 09C3 83 DUP4 09C4 61 PUSH2 0x15d6 09C7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09BE stack[0] = 0x09c8 // @09C1 stack[1] = stack[-3] // @09C2 stack[2] = stack[-2] // @09C3 stack[3] = stack[-1] // } // Block ends with call to 0x15d6, returns to 0x09C8 label_09C8: // Incoming return from call to 0x15D6 at 0x09C7 // Inputs[1] { @09CC stack[-4] } 09C8 5B JUMPDEST 09C9 50 POP 09CA 50 POP 09CB 50 POP 09CC 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_09CD: // Incoming call from 0x02D4, returns to 0x0223 // Inputs[2] // { // @09D0 storage[0x03] // @09DA msg.sender // } 09CD 5B JUMPDEST 09CE 60 PUSH1 0x03 09D0 54 SLOAD 09D1 60 PUSH1 0x01 09D3 60 PUSH1 0x01 09D5 60 PUSH1 0xa0 09D7 1B SHL 09D8 03 SUB 09D9 16 AND 09DA 33 CALLER 09DB 14 EQ 09DC 61 PUSH2 0x0a27 09DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a27, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_09E0: // Incoming jump from 0x09DF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @09E2 memory[0x40:0x60] } 09E0 60 PUSH1 0x40 09E2 51 MLOAD 09E3 62 PUSH3 0x461bcd 09E7 60 PUSH1 0xe5 09E9 1B SHL 09EA 81 DUP2 09EB 52 MSTORE 09EC 60 PUSH1 0x20 09EE 60 PUSH1 0x04 09F0 82 DUP3 09F1 01 ADD 09F2 81 DUP2 09F3 90 SWAP1 09F4 52 MSTORE 09F5 60 PUSH1 0x24 09F7 82 DUP3 09F8 01 ADD 09F9 52 MSTORE 09FA 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0A1B 60 PUSH1 0x44 0A1D 82 DUP3 0A1E 01 ADD 0A1F 52 MSTORE 0A20 60 PUSH1 0x64 0A22 01 ADD 0A23 61 PUSH2 0x043c 0A26 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @09EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09F4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09F9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0A1F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0A22 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0A27: // Incoming jump from 0x09DF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[2] // { // @0A2B storage[0x04] // @0A56 stack[-1] // } 0A27 5B JUMPDEST 0A28 60 PUSH1 0x04 0A2A 80 DUP1 0A2B 54 SLOAD 0A2C 7F PUSH32 0xffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff 0A4D 16 AND 0A4E 60 PUSH1 0x01 0A50 60 PUSH1 0xa0 0A52 1B SHL 0A53 17 OR 0A54 90 SWAP1 0A55 55 SSTORE 0A56 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A55 storage[0x04] = (0x01 << 0xa0) | (0xffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff & storage[0x04]) } // Block ends with unconditional jump to stack[-1] label_0A57: // Incoming call from 0x02DC, returns to 0x0223 // Inputs[2] // { // @0A5A storage[0x03] // @0A64 msg.sender // } 0A57 5B JUMPDEST 0A58 60 PUSH1 0x03 0A5A 54 SLOAD 0A5B 60 PUSH1 0x01 0A5D 60 PUSH1 0x01 0A5F 60 PUSH1 0xa0 0A61 1B SHL 0A62 03 SUB 0A63 16 AND 0A64 33 CALLER 0A65 14 EQ 0A66 61 PUSH2 0x0ab1 0A69 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ab1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0A6A: // Incoming jump from 0x0A69, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0A6C memory[0x40:0x60] } 0A6A 60 PUSH1 0x40 0A6C 51 MLOAD 0A6D 62 PUSH3 0x461bcd 0A71 60 PUSH1 0xe5 0A73 1B SHL 0A74 81 DUP2 0A75 52 MSTORE 0A76 60 PUSH1 0x20 0A78 60 PUSH1 0x04 0A7A 82 DUP3 0A7B 01 ADD 0A7C 81 DUP2 0A7D 90 SWAP1 0A7E 52 MSTORE 0A7F 60 PUSH1 0x24 0A81 82 DUP3 0A82 01 ADD 0A83 52 MSTORE 0A84 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0AA5 60 PUSH1 0x44 0AA7 82 DUP3 0AA8 01 ADD 0AA9 52 MSTORE 0AAA 60 PUSH1 0x64 0AAC 01 ADD 0AAD 61 PUSH2 0x043c 0AB0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A75 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A7E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A83 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0AA9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0AAC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0AB1: // Incoming jump from 0x0A69, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] 0AB1 5B JUMPDEST 0AB2 61 PUSH2 0x0abb 0AB5 60 PUSH1 0x00 0AB7 61 PUSH2 0x183e 0ABA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AB2 stack[0] = 0x0abb // @0AB5 stack[1] = 0x00 // } // Block ends with call to 0x183e, returns to 0x0ABB label_0ABB: // Incoming return from call to 0x183E at 0x0ABA // Inputs[1] { @0ABC stack[-1] } 0ABB 5B JUMPDEST 0ABC 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0ABD: // Incoming jump from 0x02EF // Inputs[2] // { // @0AC0 storage[0x03] // @0ACA msg.sender // } 0ABD 5B JUMPDEST 0ABE 60 PUSH1 0x03 0AC0 54 SLOAD 0AC1 60 PUSH1 0x01 0AC3 60 PUSH1 0x01 0AC5 60 PUSH1 0xa0 0AC7 1B SHL 0AC8 03 SUB 0AC9 16 AND 0ACA 33 CALLER 0ACB 14 EQ 0ACC 61 PUSH2 0x0b17 0ACF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b17, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0AD0: // Incoming jump from 0x0ACF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0AD2 memory[0x40:0x60] } 0AD0 60 PUSH1 0x40 0AD2 51 MLOAD 0AD3 62 PUSH3 0x461bcd 0AD7 60 PUSH1 0xe5 0AD9 1B SHL 0ADA 81 DUP2 0ADB 52 MSTORE 0ADC 60 PUSH1 0x20 0ADE 60 PUSH1 0x04 0AE0 82 DUP3 0AE1 01 ADD 0AE2 81 DUP2 0AE3 90 SWAP1 0AE4 52 MSTORE 0AE5 60 PUSH1 0x24 0AE7 82 DUP3 0AE8 01 ADD 0AE9 52 MSTORE 0AEA 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0B0B 60 PUSH1 0x44 0B0D 82 DUP3 0B0E 01 ADD 0B0F 52 MSTORE 0B10 60 PUSH1 0x64 0B12 01 ADD 0B13 61 PUSH2 0x043c 0B16 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0ADB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AE4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AE9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0B0F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0B12 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0B17: // Incoming jump from 0x0ACF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[4] // { // @0B1B storage[0x06] // @0B4B storage[0xf652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f + storage[0x06]] // @0B6B stack[-1] // @0B75 stack[-2] // } 0B17 5B JUMPDEST 0B18 60 PUSH1 0x06 0B1A 80 DUP1 0B1B 54 SLOAD 0B1C 60 PUSH1 0x01 0B1E 81 DUP2 0B1F 01 ADD 0B20 82 DUP3 0B21 55 SSTORE 0B22 60 PUSH1 0x00 0B24 91 SWAP2 0B25 90 SWAP1 0B26 91 SWAP2 0B27 52 MSTORE 0B28 7F PUSH32 0xf652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f 0B49 01 ADD 0B4A 80 DUP1 0B4B 54 SLOAD 0B4C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B61 19 NOT 0B62 16 AND 0B63 60 PUSH1 0x01 0B65 60 PUSH1 0x01 0B67 60 PUSH1 0xa0 0B69 1B SHL 0B6A 03 SUB 0B6B 92 SWAP3 0B6C 90 SWAP1 0B6D 92 SWAP3 0B6E 16 AND 0B6F 91 SWAP2 0B70 90 SWAP1 0B71 91 SWAP2 0B72 17 OR 0B73 90 SWAP1 0B74 55 SSTORE 0B75 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0B21 storage[0x06] = storage[0x06] + 0x01 // @0B27 memory[0x00:0x20] = 0x06 // @0B74 storage[0xf652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f + storage[0x06]] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[0xf652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f + storage[0x06]]) // } // Block ends with unconditional jump to stack[-2] label_0B76: // Incoming jump from 0x0313 // Inputs[1] { @0B7D storage[0x06] } 0B76 5B JUMPDEST 0B77 60 PUSH1 0x00 0B79 80 DUP1 0B7A 5B JUMPDEST 0B7B 60 PUSH1 0x06 0B7D 54 SLOAD 0B7E 81 DUP2 0B7F 10 LT 0B80 15 ISZERO 0B81 61 PUSH2 0x0bd7 0B84 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B77 stack[0] = 0x00 // @0B79 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0bd7, if !(0x00 < storage[0x06]) label_0B85: // Incoming jump from 0x0B84, if not !(stack[-1] < storage[0x06]) // Incoming jump from 0x0B84, if not !(0x00 < storage[0x06]) // Inputs[3] // { // @0B85 msg.sender // @0B91 stack[-1] // @0B93 storage[0x06] // } 0B85 33 CALLER 0B86 60 PUSH1 0x01 0B88 60 PUSH1 0x01 0B8A 60 PUSH1 0xa0 0B8C 1B SHL 0B8D 03 SUB 0B8E 16 AND 0B8F 60 PUSH1 0x06 0B91 82 DUP3 0B92 81 DUP2 0B93 54 SLOAD 0B94 81 DUP2 0B95 10 LT 0B96 61 PUSH2 0x0ba1 0B99 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0B8E stack[0] = (0x01 << 0xa0) - 0x01 & msg.sender // @0B8F stack[1] = 0x06 // @0B91 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0ba1, if stack[-1] < storage[0x06] label_0B9A: // Incoming jump from 0x0B99, if not stack[-1] < storage[0x06] 0B9A 61 PUSH2 0x0ba1 0B9D 61 PUSH2 0x26e0 0BA0 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B9A stack[0] = 0x0ba1 } // Block ends with unconditional jump to 0x26e0 label_0BA1: // Incoming jump from 0x0B99, if stack[-1] < storage[0x06] // Inputs[5] // { // @0BA4 stack[-2] // @0BA9 stack[-1] // @0BAB memory[0x00:0x20] // @0BAD storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0BB7 stack[-3] // } 0BA1 5B JUMPDEST 0BA2 60 PUSH1 0x00 0BA4 91 SWAP2 0BA5 82 DUP3 0BA6 52 MSTORE 0BA7 60 PUSH1 0x20 0BA9 90 SWAP1 0BAA 91 SWAP2 0BAB 20 SHA3 0BAC 01 ADD 0BAD 54 SLOAD 0BAE 60 PUSH1 0x01 0BB0 60 PUSH1 0x01 0BB2 60 PUSH1 0xa0 0BB4 1B SHL 0BB5 03 SUB 0BB6 16 AND 0BB7 14 EQ 0BB8 15 ISZERO 0BB9 61 PUSH2 0x0bc5 0BBC 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0BA6 memory[0x00:0x20] = stack[-2] } // Block ends with conditional jump to 0x0bc5, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3]) label_0BBD: // Incoming jump from 0x0BBC, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3]) // Inputs[1] { @0BBF stack[-2] } 0BBD 60 PUSH1 0x01 0BBF 91 SWAP2 0BC0 50 POP 0BC1 61 PUSH2 0x0bd7 0BC4 56 *JUMP // Stack delta = +0 // Outputs[1] { @0BBF stack[-2] = 0x01 } // Block ends with unconditional jump to 0x0bd7 label_0BC5: // Incoming jump from 0x0BBC, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3]) // Inputs[1] { @0BC6 stack[-1] } 0BC5 5B JUMPDEST 0BC6 80 DUP1 0BC7 61 PUSH2 0x0bcf 0BCA 81 DUP2 0BCB 61 PUSH2 0x270c 0BCE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BC6 stack[0] = stack[-1] // @0BC7 stack[1] = 0x0bcf // @0BCA stack[2] = stack[-1] // } // Block ends with call to 0x270c, returns to 0x0BCF label_0BCF: // Incoming return from call to 0x270C at 0x0BCE // Inputs[2] // { // @0BD0 stack[-3] // @0BD0 stack[-1] // } 0BCF 5B JUMPDEST 0BD0 91 SWAP2 0BD1 50 POP 0BD2 50 POP 0BD3 61 PUSH2 0x0b7a 0BD6 56 *JUMP // Stack delta = -2 // Outputs[1] { @0BD0 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0b7a label_0BD7: // Incoming jump from 0x0BC4 // Incoming jump from 0x0B84, if !(stack[-1] < storage[0x06]) // Incoming jump from 0x0B84, if !(0x00 < storage[0x06]) // Inputs[1] { @0BD9 stack[-2] } 0BD7 5B JUMPDEST 0BD8 50 POP 0BD9 80 DUP1 0BDA 61 PUSH2 0x0c4b 0BDD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c4b, if stack[-2] label_0BDE: // Incoming jump from 0x0BDD, if not stack[-2] // Inputs[1] { @0BE0 memory[0x40:0x60] } 0BDE 60 PUSH1 0x40 0BE0 51 MLOAD 0BE1 62 PUSH3 0x461bcd 0BE5 60 PUSH1 0xe5 0BE7 1B SHL 0BE8 81 DUP2 0BE9 52 MSTORE 0BEA 60 PUSH1 0x20 0BEC 60 PUSH1 0x04 0BEE 82 DUP3 0BEF 01 ADD 0BF0 52 MSTORE 0BF1 60 PUSH1 0x27 0BF3 60 PUSH1 0x24 0BF5 82 DUP3 0BF6 01 ADD 0BF7 52 MSTORE 0BF8 7F PUSH32 0x4d696e7465723a2063616c6c6572206973206e6f7420616e20616c6c6f776564 0C19 60 PUSH1 0x44 0C1B 82 DUP3 0C1C 01 ADD 0C1D 52 MSTORE 0C1E 7F PUSH32 0x206d696e74657200000000000000000000000000000000000000000000000000 0C3F 60 PUSH1 0x64 0C41 82 DUP3 0C42 01 ADD 0C43 52 MSTORE 0C44 60 PUSH1 0x84 0C46 01 ADD 0C47 61 PUSH2 0x043c 0C4A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0BE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BF0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BF7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x27 // @0C1D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d696e7465723a2063616c6c6572206973206e6f7420616e20616c6c6f776564 // @0C43 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x206d696e74657200000000000000000000000000000000000000000000000000 // @0C46 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0C4B: // Incoming jump from 0x0BDD, if stack[-2] // Inputs[1] { @0C4E storage[0x04] } 0C4B 5B JUMPDEST 0C4C 60 PUSH1 0x04 0C4E 54 SLOAD 0C4F 60 PUSH1 0x01 0C51 60 PUSH1 0xa0 0C53 1B SHL 0C54 90 SWAP1 0C55 04 DIV 0C56 60 PUSH1 0xff 0C58 16 AND 0C59 15 ISZERO 0C5A 61 PUSH2 0x0ccb 0C5D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ccb, if !(0xff & storage[0x04] / (0x01 << 0xa0)) label_0C5E: // Incoming jump from 0x0C5D, if not !(0xff & storage[0x04] / (0x01 << 0xa0)) // Inputs[1] { @0C60 memory[0x40:0x60] } 0C5E 60 PUSH1 0x40 0C60 51 MLOAD 0C61 62 PUSH3 0x461bcd 0C65 60 PUSH1 0xe5 0C67 1B SHL 0C68 81 DUP2 0C69 52 MSTORE 0C6A 60 PUSH1 0x20 0C6C 60 PUSH1 0x04 0C6E 82 DUP3 0C6F 01 ADD 0C70 52 MSTORE 0C71 60 PUSH1 0x27 0C73 60 PUSH1 0x24 0C75 82 DUP3 0C76 01 ADD 0C77 52 MSTORE 0C78 7F PUSH32 0x546869732066756e6374696f6e2063616e206e6f742062652063616c6c656420 0C99 60 PUSH1 0x44 0C9B 82 DUP3 0C9C 01 ADD 0C9D 52 MSTORE 0C9E 7F PUSH32 0x616e796d6f726500000000000000000000000000000000000000000000000000 0CBF 60 PUSH1 0x64 0CC1 82 DUP3 0CC2 01 ADD 0CC3 52 MSTORE 0CC4 60 PUSH1 0x84 0CC6 01 ADD 0CC7 61 PUSH2 0x043c 0CCA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C70 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C77 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x27 // @0C9D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x546869732066756e6374696f6e2063616e206e6f742062652063616c6c656420 // @0CC3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616e796d6f726500000000000000000000000000000000000000000000000000 // @0CC6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0CCB: // Incoming jump from 0x0C5D, if !(0xff & storage[0x04] / (0x01 << 0xa0)) // Inputs[4] // { // @0CCF stack[-4] // @0CD0 stack[-3] // @0CD1 stack[-2] // @0CD4 memory[0x40:0x60] // } 0CCB 5B JUMPDEST 0CCC 61 PUSH2 0x0ce6 0CCF 84 DUP5 0CD0 84 DUP5 0CD1 84 DUP5 0CD2 60 PUSH1 0x40 0CD4 51 MLOAD 0CD5 80 DUP1 0CD6 60 PUSH1 0x20 0CD8 01 ADD 0CD9 60 PUSH1 0x40 0CDB 52 MSTORE 0CDC 80 DUP1 0CDD 60 PUSH1 0x00 0CDF 81 DUP2 0CE0 52 MSTORE 0CE1 50 POP 0CE2 61 PUSH2 0x189d 0CE5 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0CCC stack[0] = 0x0ce6 // @0CCF stack[1] = stack[-4] // @0CD0 stack[2] = stack[-3] // @0CD1 stack[3] = stack[-2] // @0CD4 stack[4] = memory[0x40:0x60] // @0CDB memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0CE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x189d, returns to 0x0CE6 label_0CE6: // Incoming jump from 0x2253, if !(stack[-1] > stack[-4]) // Incoming return from call to 0x189D at 0x0CE5 // Inputs[1] { @0CEB stack[-5] } 0CE6 5B JUMPDEST 0CE7 50 POP 0CE8 50 POP 0CE9 50 POP 0CEA 50 POP 0CEB 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0CEC: // Incoming jump from 0x0326 // Inputs[2] // { // @0CED msg.sender // @0CF6 stack[-2] // } 0CEC 5B JUMPDEST 0CED 33 CALLER 0CEE 60 PUSH1 0x01 0CF0 60 PUSH1 0x01 0CF2 60 PUSH1 0xa0 0CF4 1B SHL 0CF5 03 SUB 0CF6 83 DUP4 0CF7 16 AND 0CF8 14 EQ 0CF9 15 ISZERO 0CFA 61 PUSH2 0x0d6b 0CFD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d6b, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) label_0CFE: // Incoming jump from 0x0CFD, if not !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[1] { @0D00 memory[0x40:0x60] } 0CFE 60 PUSH1 0x40 0D00 51 MLOAD 0D01 62 PUSH3 0x461bcd 0D05 60 PUSH1 0xe5 0D07 1B SHL 0D08 81 DUP2 0D09 52 MSTORE 0D0A 60 PUSH1 0x20 0D0C 60 PUSH1 0x04 0D0E 82 DUP3 0D0F 01 ADD 0D10 52 MSTORE 0D11 60 PUSH1 0x29 0D13 60 PUSH1 0x24 0D15 82 DUP3 0D16 01 ADD 0D17 52 MSTORE 0D18 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 0D39 60 PUSH1 0x44 0D3B 82 DUP3 0D3C 01 ADD 0D3D 52 MSTORE 0D3E 7F PUSH32 0x20666f722073656c660000000000000000000000000000000000000000000000 0D5F 60 PUSH1 0x64 0D61 82 DUP3 0D62 01 ADD 0D63 52 MSTORE 0D64 60 PUSH1 0x84 0D66 01 ADD 0D67 61 PUSH2 0x043c 0D6A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0D09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D10 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D17 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0D3D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @0D63 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x20666f722073656c660000000000000000000000000000000000000000000000 // @0D66 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0D6B: // Incoming jump from 0x0CFD, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[10] // { // @0D6C msg.sender // @0D7D memory[0x00:0x40] // @0D86 stack[-2] // @0D91 memory[0x00:0x40] // @0D93 storage[keccak256(memory[0x00:0x40])] // @0DB6 stack[-1] // @0DC0 memory[0x40:0x60] // @0DEC memory[0x40:0x60] // @0DF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0DF4 stack[-3] // } 0D6B 5B JUMPDEST 0D6C 33 CALLER 0D6D 60 PUSH1 0x00 0D6F 81 DUP2 0D70 81 DUP2 0D71 52 MSTORE 0D72 60 PUSH1 0x01 0D74 60 PUSH1 0x20 0D76 90 SWAP1 0D77 81 DUP2 0D78 52 MSTORE 0D79 60 PUSH1 0x40 0D7B 80 DUP1 0D7C 83 DUP4 0D7D 20 SHA3 0D7E 60 PUSH1 0x01 0D80 60 PUSH1 0x01 0D82 60 PUSH1 0xa0 0D84 1B SHL 0D85 03 SUB 0D86 87 DUP8 0D87 16 AND 0D88 80 DUP1 0D89 85 DUP6 0D8A 52 MSTORE 0D8B 90 SWAP1 0D8C 83 DUP4 0D8D 52 MSTORE 0D8E 92 SWAP3 0D8F 81 DUP2 0D90 90 SWAP1 0D91 20 SHA3 0D92 80 DUP1 0D93 54 SLOAD 0D94 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 0DB5 16 AND 0DB6 86 DUP7 0DB7 15 ISZERO 0DB8 15 ISZERO 0DB9 90 SWAP1 0DBA 81 DUP2 0DBB 17 OR 0DBC 90 SWAP1 0DBD 91 SWAP2 0DBE 55 SSTORE 0DBF 90 SWAP1 0DC0 51 MLOAD 0DC1 90 SWAP1 0DC2 81 DUP2 0DC3 52 MSTORE 0DC4 91 SWAP2 0DC5 92 SWAP3 0DC6 91 SWAP2 0DC7 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0DE8 91 SWAP2 0DE9 01 ADD 0DEA 60 PUSH1 0x40 0DEC 51 MLOAD 0DED 80 DUP1 0DEE 91 SWAP2 0DEF 03 SUB 0DF0 90 SWAP1 0DF1 A3 LOG3 0DF2 50 POP 0DF3 50 POP 0DF4 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0D71 memory[0x00:0x20] = msg.sender // @0D78 memory[0x20:0x40] = 0x01 // @0D8A memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0D8D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0DBE storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & storage[keccak256(memory[0x00:0x40])]) // @0DC3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0DF1 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_0DF5: // Incoming jump from 0x0339 // Inputs[2] // { // @0DF8 storage[0x03] // @0E02 msg.sender // } 0DF5 5B JUMPDEST 0DF6 60 PUSH1 0x03 0DF8 54 SLOAD 0DF9 60 PUSH1 0x01 0DFB 60 PUSH1 0x01 0DFD 60 PUSH1 0xa0 0DFF 1B SHL 0E00 03 SUB 0E01 16 AND 0E02 33 CALLER 0E03 14 EQ 0E04 61 PUSH2 0x0e4f 0E07 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e4f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0E08: // Incoming jump from 0x0E07, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0E0A memory[0x40:0x60] } 0E08 60 PUSH1 0x40 0E0A 51 MLOAD 0E0B 62 PUSH3 0x461bcd 0E0F 60 PUSH1 0xe5 0E11 1B SHL 0E12 81 DUP2 0E13 52 MSTORE 0E14 60 PUSH1 0x20 0E16 60 PUSH1 0x04 0E18 82 DUP3 0E19 01 ADD 0E1A 81 DUP2 0E1B 90 SWAP1 0E1C 52 MSTORE 0E1D 60 PUSH1 0x24 0E1F 82 DUP3 0E20 01 ADD 0E21 52 MSTORE 0E22 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0E43 60 PUSH1 0x44 0E45 82 DUP3 0E46 01 ADD 0E47 52 MSTORE 0E48 60 PUSH1 0x64 0E4A 01 ADD 0E4B 61 PUSH2 0x043c 0E4E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E13 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E1C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E21 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E47 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0E4A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0E4F: // Incoming jump from 0x0E07, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @0E53 storage[0x07] // @0E73 stack[-1] // @0E7D stack[-2] // } 0E4F 5B JUMPDEST 0E50 60 PUSH1 0x07 0E52 80 DUP1 0E53 54 SLOAD 0E54 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E69 19 NOT 0E6A 16 AND 0E6B 60 PUSH1 0x01 0E6D 60 PUSH1 0x01 0E6F 60 PUSH1 0xa0 0E71 1B SHL 0E72 03 SUB 0E73 92 SWAP3 0E74 90 SWAP1 0E75 92 SWAP3 0E76 16 AND 0E77 91 SWAP2 0E78 90 SWAP1 0E79 91 SWAP2 0E7A 17 OR 0E7B 90 SWAP1 0E7C 55 SSTORE 0E7D 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E7C storage[0x07] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[0x07]) } // Block ends with unconditional jump to stack[-2] label_0E7E: // Incoming jump from 0x0388 // Inputs[2] // { // @0E81 storage[0x03] // @0E8B msg.sender // } 0E7E 5B JUMPDEST 0E7F 60 PUSH1 0x03 0E81 54 SLOAD 0E82 60 PUSH1 0x01 0E84 60 PUSH1 0x01 0E86 60 PUSH1 0xa0 0E88 1B SHL 0E89 03 SUB 0E8A 16 AND 0E8B 33 CALLER 0E8C 14 EQ 0E8D 61 PUSH2 0x0ed8 0E90 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ed8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0E91: // Incoming jump from 0x0E90, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0E93 memory[0x40:0x60] } 0E91 60 PUSH1 0x40 0E93 51 MLOAD 0E94 62 PUSH3 0x461bcd 0E98 60 PUSH1 0xe5 0E9A 1B SHL 0E9B 81 DUP2 0E9C 52 MSTORE 0E9D 60 PUSH1 0x20 0E9F 60 PUSH1 0x04 0EA1 82 DUP3 0EA2 01 ADD 0EA3 81 DUP2 0EA4 90 SWAP1 0EA5 52 MSTORE 0EA6 60 PUSH1 0x24 0EA8 82 DUP3 0EA9 01 ADD 0EAA 52 MSTORE 0EAB 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0ECC 60 PUSH1 0x44 0ECE 82 DUP3 0ECF 01 ADD 0ED0 52 MSTORE 0ED1 60 PUSH1 0x64 0ED3 01 ADD 0ED4 61 PUSH2 0x043c 0ED7 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EA5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EAA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0ED0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0ED3 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_0ED8: // Incoming jump from 0x0E90, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0EDE storage[0x06] } 0ED8 5B JUMPDEST 0ED9 60 PUSH1 0x00 0EDB 5B JUMPDEST 0EDC 60 PUSH1 0x06 0EDE 54 SLOAD 0EDF 81 DUP2 0EE0 10 LT 0EE1 15 ISZERO 0EE2 61 PUSH2 0x0fee 0EE5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0ED9 stack[0] = 0x00 } // Block ends with conditional jump to 0x0fee, if !(0x00 < storage[0x06]) label_0EE6: // Incoming jump from 0x0EE5, if not !(0x00 < storage[0x06]) // Incoming jump from 0x0EE5, if not !(stack[-1] < storage[0x06]) // Inputs[3] // { // @0EE6 stack[-2] // @0EF2 stack[-1] // @0EF4 storage[0x06] // } 0EE6 81 DUP2 0EE7 60 PUSH1 0x01 0EE9 60 PUSH1 0x01 0EEB 60 PUSH1 0xa0 0EED 1B SHL 0EEE 03 SUB 0EEF 16 AND 0EF0 60 PUSH1 0x06 0EF2 82 DUP3 0EF3 81 DUP2 0EF4 54 SLOAD 0EF5 81 DUP2 0EF6 10 LT 0EF7 61 PUSH2 0x0f02 0EFA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0EEF stack[0] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0EF0 stack[1] = 0x06 // @0EF2 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0f02, if stack[-1] < storage[0x06] label_0EFB: // Incoming jump from 0x0EFA, if not stack[-1] < storage[0x06] 0EFB 61 PUSH2 0x0f02 0EFE 61 PUSH2 0x26e0 0F01 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EFB stack[0] = 0x0f02 } // Block ends with unconditional jump to 0x26e0 label_0F02: // Incoming jump from 0x0EFA, if stack[-1] < storage[0x06] // Inputs[5] // { // @0F05 stack[-2] // @0F0A stack[-1] // @0F0C memory[0x00:0x20] // @0F0E storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0F18 stack[-3] // } 0F02 5B JUMPDEST 0F03 60 PUSH1 0x00 0F05 91 SWAP2 0F06 82 DUP3 0F07 52 MSTORE 0F08 60 PUSH1 0x20 0F0A 90 SWAP1 0F0B 91 SWAP2 0F0C 20 SHA3 0F0D 01 ADD 0F0E 54 SLOAD 0F0F 60 PUSH1 0x01 0F11 60 PUSH1 0x01 0F13 60 PUSH1 0xa0 0F15 1B SHL 0F16 03 SUB 0F17 16 AND 0F18 14 EQ 0F19 61 PUSH2 0x0f21 0F1C 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0F07 memory[0x00:0x20] = stack[-2] } // Block ends with conditional jump to 0x0f21, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3] label_0F1D: // Incoming jump from 0x0F1C, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3] 0F1D 61 PUSH2 0x0fdc 0F20 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fdc label_0F21: // Incoming jump from 0x0F1C, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3] // Inputs[1] { @0F25 storage[0x06] } 0F21 5B JUMPDEST 0F22 60 PUSH1 0x06 0F24 80 DUP1 0F25 54 SLOAD 0F26 61 PUSH2 0x0f31 0F29 90 SWAP1 0F2A 60 PUSH1 0x01 0F2C 90 SWAP1 0F2D 61 PUSH2 0x2727 0F30 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F22 stack[0] = 0x06 // @0F29 stack[1] = 0x0f31 // @0F2C stack[2] = 0x01 // @0F2C stack[3] = storage[0x06] // } // Block ends with call to 0x2727, returns to 0x0F31 label_0F31: // Incoming return from call to 0x2727 at 0x0F30 // Inputs[3] // { // @0F32 stack[-2] // @0F33 storage[stack[-2]] // @0F34 stack[-1] // } 0F31 5B JUMPDEST 0F32 81 DUP2 0F33 54 SLOAD 0F34 81 DUP2 0F35 10 LT 0F36 61 PUSH2 0x0f41 0F39 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f41, if stack[-1] < storage[stack[-2]] label_0F3A: // Incoming jump from 0x0F39, if not stack[-1] < storage[stack[-2]] 0F3A 61 PUSH2 0x0f41 0F3D 61 PUSH2 0x26e0 0F40 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F3A stack[0] = 0x0f41 } // Block ends with unconditional jump to 0x26e0 label_0F41: // Incoming jump from 0x0F39, if stack[-1] < storage[stack[-2]] // Inputs[6] // { // @0F44 stack[-2] // @0F49 stack[-1] // @0F4B memory[0x00:0x20] // @0F4D storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0F51 storage[0x06] // @0F5E stack[-3] // } 0F41 5B JUMPDEST 0F42 60 PUSH1 0x00 0F44 91 SWAP2 0F45 82 DUP3 0F46 52 MSTORE 0F47 60 PUSH1 0x20 0F49 90 SWAP1 0F4A 91 SWAP2 0F4B 20 SHA3 0F4C 01 ADD 0F4D 54 SLOAD 0F4E 60 PUSH1 0x06 0F50 80 DUP1 0F51 54 SLOAD 0F52 60 PUSH1 0x01 0F54 60 PUSH1 0x01 0F56 60 PUSH1 0xa0 0F58 1B SHL 0F59 03 SUB 0F5A 90 SWAP1 0F5B 92 SWAP3 0F5C 16 AND 0F5D 91 SWAP2 0F5E 83 DUP4 0F5F 90 SWAP1 0F60 81 DUP2 0F61 10 LT 0F62 61 PUSH2 0x0f6d 0F65 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0F46 memory[0x00:0x20] = stack[-2] // @0F4E stack[-1] = 0x06 // @0F5D stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] & (0x01 << 0xa0) - 0x01 // @0F5F stack[0] = stack[-3] // } // Block ends with conditional jump to 0x0f6d, if stack[-3] < storage[0x06] label_0F66: // Incoming jump from 0x0F65, if not stack[-3] < storage[0x06] 0F66 61 PUSH2 0x0f6d 0F69 61 PUSH2 0x26e0 0F6C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F66 stack[0] = 0x0f6d } // Block ends with unconditional jump to 0x26e0 label_0F6D: // Incoming jump from 0x0F65, if stack[-3] < storage[0x06] // Inputs[6] // { // @0F6E stack[-1] // @0F6E stack[-2] // @0F76 memory[0x00:0x20] // @0F7F storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0F8D stack[-3] // @0F9F storage[0x06] // } 0F6D 5B JUMPDEST 0F6E 90 SWAP1 0F6F 60 PUSH1 0x00 0F71 52 MSTORE 0F72 60 PUSH1 0x20 0F74 60 PUSH1 0x00 0F76 20 SHA3 0F77 01 ADD 0F78 60 PUSH1 0x00 0F7A 61 PUSH2 0x0100 0F7D 0A EXP 0F7E 81 DUP2 0F7F 54 SLOAD 0F80 81 DUP2 0F81 60 PUSH1 0x01 0F83 60 PUSH1 0x01 0F85 60 PUSH1 0xa0 0F87 1B SHL 0F88 03 SUB 0F89 02 MUL 0F8A 19 NOT 0F8B 16 AND 0F8C 90 SWAP1 0F8D 83 DUP4 0F8E 60 PUSH1 0x01 0F90 60 PUSH1 0x01 0F92 60 PUSH1 0xa0 0F94 1B SHL 0F95 03 SUB 0F96 16 AND 0F97 02 MUL 0F98 17 OR 0F99 90 SWAP1 0F9A 55 SSTORE 0F9B 50 POP 0F9C 60 PUSH1 0x06 0F9E 80 DUP1 0F9F 54 SLOAD 0FA0 80 DUP1 0FA1 61 PUSH2 0x0fac 0FA4 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @0F71 memory[0x00:0x20] = stack[-2] // @0F9A storage[keccak256(memory[0x00:0x20]) + stack[-1]] = ((0x01 << 0xa0) - 0x01 & stack[-3]) * 0x0100 ** 0x00 | (~((0x01 << 0xa0) - 0x01 * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x20]) + stack[-1]]) // @0F9C stack[-3] = 0x06 // @0F9F stack[-2] = storage[0x06] // } // Block ends with conditional jump to 0x0fac, if storage[0x06] label_0FA5: // Incoming jump from 0x0FA4, if not storage[0x06] 0FA5 61 PUSH2 0x0fac 0FA8 61 PUSH2 0x273e 0FAB 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FA5 stack[0] = 0x0fac } // Block ends with unconditional jump to 0x273e label_0FAC: // Incoming jump from 0x0FA4, if storage[0x06] // Inputs[4] // { // @0FAF stack[-2] // @0FB5 memory[0x00:0x20] // @0FB6 stack[-1] // @0FBF storage[~0x00 + stack[-1] + keccak256(memory[0x00:0x20])] // } 0FAC 5B JUMPDEST 0FAD 60 PUSH1 0x00 0FAF 82 DUP3 0FB0 81 DUP2 0FB1 52 MSTORE 0FB2 60 PUSH1 0x20 0FB4 90 SWAP1 0FB5 20 SHA3 0FB6 81 DUP2 0FB7 01 ADD 0FB8 60 PUSH1 0x00 0FBA 19 NOT 0FBB 90 SWAP1 0FBC 81 DUP2 0FBD 01 ADD 0FBE 80 DUP1 0FBF 54 SLOAD 0FC0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FD5 19 NOT 0FD6 16 AND 0FD7 90 SWAP1 0FD8 55 SSTORE 0FD9 01 ADD 0FDA 90 SWAP1 0FDB 55 SSTORE // Stack delta = -2 // Outputs[3] // { // @0FB1 memory[0x00:0x20] = stack[-2] // @0FD8 storage[~0x00 + stack[-1] + keccak256(memory[0x00:0x20])] = ~0xffffffffffffffffffffffffffffffffffffffff & storage[~0x00 + stack[-1] + keccak256(memory[0x00:0x20])] // @0FDB storage[stack[-2]] = ~0x00 + stack[-1] // } // Block continues label_0FDC: // Incoming jump from 0x0F20 // Incoming jump from 0x0FDB // Inputs[1] { @0FDD stack[-1] } 0FDC 5B JUMPDEST 0FDD 80 DUP1 0FDE 61 PUSH2 0x0fe6 0FE1 81 DUP2 0FE2 61 PUSH2 0x270c 0FE5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FDD stack[0] = stack[-1] // @0FDE stack[1] = 0x0fe6 // @0FE1 stack[2] = stack[-1] // } // Block ends with call to 0x270c, returns to 0x0FE6 label_0FE6: // Incoming return from call to 0x270C at 0x0FE5 // Inputs[2] // { // @0FE7 stack[-3] // @0FE7 stack[-1] // } 0FE6 5B JUMPDEST 0FE7 91 SWAP2 0FE8 50 POP 0FE9 50 POP 0FEA 61 PUSH2 0x0edb 0FED 56 *JUMP // Stack delta = -2 // Outputs[1] { @0FE7 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0edb label_0FEE: // Incoming jump from 0x0EE5, if !(0x00 < storage[0x06]) // Incoming jump from 0x0EE5, if !(stack[-1] < storage[0x06]) // Inputs[1] { @0FF1 stack[-3] } 0FEE 5B JUMPDEST 0FEF 50 POP 0FF0 50 POP 0FF1 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] 0FF2 5B JUMPDEST 0FF3 60 PUSH1 0x01 0FF5 60 PUSH1 0x01 0FF7 60 PUSH1 0xa0 0FF9 1B SHL 0FFA 03 SUB 0FFB 85 DUP6 0FFC 16 AND 0FFD 33 CALLER 0FFE 14 EQ 0FFF 80 DUP1 1000 61 PUSH2 0x100e 1003 57 *JUMPI 1004 50 POP 1005 61 PUSH2 0x100e 1008 85 DUP6 1009 33 CALLER 100A 61 PUSH2 0x0348 100D 56 *JUMP 100E 5B JUMPDEST 100F 61 PUSH2 0x1080 1012 57 *JUMPI 1013 60 PUSH1 0x40 1015 51 MLOAD 1016 62 PUSH3 0x461bcd 101A 60 PUSH1 0xe5 101C 1B SHL 101D 81 DUP2 101E 52 MSTORE 101F 60 PUSH1 0x20 1021 60 PUSH1 0x04 1023 82 DUP3 1024 01 ADD 1025 52 MSTORE 1026 60 PUSH1 0x29 1028 60 PUSH1 0x24 102A 82 DUP3 102B 01 ADD 102C 52 MSTORE 102D 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 104E 60 PUSH1 0x44 1050 82 DUP3 1051 01 ADD 1052 52 MSTORE 1053 7F PUSH32 0x20617070726f7665640000000000000000000000000000000000000000000000 1074 60 PUSH1 0x64 1076 82 DUP3 1077 01 ADD 1078 52 MSTORE 1079 60 PUSH1 0x84 107B 01 ADD 107C 61 PUSH2 0x043c 107F 56 *JUMP 1080 5B JUMPDEST 1081 61 PUSH2 0x07c4 1084 85 DUP6 1085 85 DUP6 1086 85 DUP6 1087 85 DUP6 1088 85 DUP6 1089 61 PUSH2 0x1a7f 108C 56 *JUMP label_108D: // Incoming jump from 0x03AE // Inputs[2] // { // @1090 storage[0x03] // @109A msg.sender // } 108D 5B JUMPDEST 108E 60 PUSH1 0x03 1090 54 SLOAD 1091 60 PUSH1 0x01 1093 60 PUSH1 0x01 1095 60 PUSH1 0xa0 1097 1B SHL 1098 03 SUB 1099 16 AND 109A 33 CALLER 109B 14 EQ 109C 61 PUSH2 0x10e7 109F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10e7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_10A0: // Incoming jump from 0x109F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @10A2 memory[0x40:0x60] } 10A0 60 PUSH1 0x40 10A2 51 MLOAD 10A3 62 PUSH3 0x461bcd 10A7 60 PUSH1 0xe5 10A9 1B SHL 10AA 81 DUP2 10AB 52 MSTORE 10AC 60 PUSH1 0x20 10AE 60 PUSH1 0x04 10B0 82 DUP3 10B1 01 ADD 10B2 81 DUP2 10B3 90 SWAP1 10B4 52 MSTORE 10B5 60 PUSH1 0x24 10B7 82 DUP3 10B8 01 ADD 10B9 52 MSTORE 10BA 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 10DB 60 PUSH1 0x44 10DD 82 DUP3 10DE 01 ADD 10DF 52 MSTORE 10E0 60 PUSH1 0x64 10E2 01 ADD 10E3 61 PUSH2 0x043c 10E6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @10AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10B4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10B9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @10DF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @10E2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_10E7: // Incoming jump from 0x109F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @10F0 stack[-1] } 10E7 5B JUMPDEST 10E8 60 PUSH1 0x01 10EA 60 PUSH1 0x01 10EC 60 PUSH1 0xa0 10EE 1B SHL 10EF 03 SUB 10F0 81 DUP2 10F1 16 AND 10F2 61 PUSH2 0x1163 10F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1163, if stack[-1] & (0x01 << 0xa0) - 0x01 label_10F6: // Incoming jump from 0x10F5, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @10F8 memory[0x40:0x60] } 10F6 60 PUSH1 0x40 10F8 51 MLOAD 10F9 62 PUSH3 0x461bcd 10FD 60 PUSH1 0xe5 10FF 1B SHL 1100 81 DUP2 1101 52 MSTORE 1102 60 PUSH1 0x20 1104 60 PUSH1 0x04 1106 82 DUP3 1107 01 ADD 1108 52 MSTORE 1109 60 PUSH1 0x26 110B 60 PUSH1 0x24 110D 82 DUP3 110E 01 ADD 110F 52 MSTORE 1110 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1131 60 PUSH1 0x44 1133 82 DUP3 1134 01 ADD 1135 52 MSTORE 1136 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 1157 60 PUSH1 0x64 1159 82 DUP3 115A 01 ADD 115B 52 MSTORE 115C 60 PUSH1 0x84 115E 01 ADD 115F 61 PUSH2 0x043c 1162 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1101 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1108 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @110F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1135 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @115B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @115E stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_1163: // Incoming jump from 0x10F5, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1167 stack[-1] } 1163 5B JUMPDEST 1164 61 PUSH2 0x065d 1167 81 DUP2 1168 61 PUSH2 0x183e 116B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1164 stack[0] = 0x065d // @1167 stack[1] = stack[-1] // } // Block ends with call to 0x183e, returns to 0x065D label_116C: // Incoming jump from 0x065C // Inputs[2] // { // @116D stack[-1] // @116E memory[stack[-1]:stack[-1] + 0x20] // } 116C 5B JUMPDEST 116D 80 DUP1 116E 51 MLOAD 116F 61 PUSH2 0x0fee 1172 90 SWAP1 1173 60 PUSH1 0x02 1175 90 SWAP1 1176 60 PUSH1 0x20 1178 84 DUP5 1179 01 ADD 117A 90 SWAP1 117B 61 PUSH2 0x1ffc 117E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1172 stack[0] = 0x0fee // @1175 stack[1] = 0x02 // @117A stack[2] = stack[-1] + 0x20 // @117A stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1ffc label_117F: // Incoming call from 0x06F8, returns to 0x06F9 // Inputs[1] { @1185 storage[0x02] } 117F 5B JUMPDEST 1180 60 PUSH1 0x60 1182 60 PUSH1 0x02 1184 80 DUP1 1185 54 SLOAD 1186 61 PUSH2 0x118e 1189 90 SWAP1 118A 61 PUSH2 0x2676 118D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1180 stack[0] = 0x60 // @1182 stack[1] = 0x02 // @1189 stack[2] = 0x118e // @1189 stack[3] = storage[0x02] // } // Block ends with call to 0x2676, returns to 0x118E label_118E: // Incoming return from call to 0x2676 at 0x118D // Inputs[4] // { // @118F stack[-1] // @119E memory[0x40:0x60] // @11A6 stack[-2] // @11B1 storage[stack[-2]] // } 118E 5B JUMPDEST 118F 80 DUP1 1190 60 PUSH1 0x1f 1192 01 ADD 1193 60 PUSH1 0x20 1195 80 DUP1 1196 91 SWAP2 1197 04 DIV 1198 02 MUL 1199 60 PUSH1 0x20 119B 01 ADD 119C 60 PUSH1 0x40 119E 51 MLOAD 119F 90 SWAP1 11A0 81 DUP2 11A1 01 ADD 11A2 60 PUSH1 0x40 11A4 52 MSTORE 11A5 80 DUP1 11A6 92 SWAP3 11A7 91 SWAP2 11A8 90 SWAP1 11A9 81 DUP2 11AA 81 DUP2 11AB 52 MSTORE 11AC 60 PUSH1 0x20 11AE 01 ADD 11AF 82 DUP3 11B0 80 DUP1 11B1 54 SLOAD 11B2 61 PUSH2 0x11ba 11B5 90 SWAP1 11B6 61 PUSH2 0x2676 11B9 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @11A4 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @11A6 stack[-2] = memory[0x40:0x60] // @11A7 stack[-1] = stack[-2] // @11A8 stack[0] = stack[-1] // @11AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @11AE stack[1] = 0x20 + memory[0x40:0x60] // @11AF stack[2] = stack[-2] // @11B5 stack[4] = storage[stack[-2]] // @11B5 stack[3] = 0x11ba // } // Block ends with call to 0x2676, returns to 0x11BA label_11BA: // Incoming return from call to 0x2676 at 0x11B9 // Inputs[1] { @11BB stack[-1] } 11BA 5B JUMPDEST 11BB 80 DUP1 11BC 15 ISZERO 11BD 61 PUSH2 0x1207 11C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1207, if !stack[-1] label_11C1: // Incoming jump from 0x11C0, if not !stack[-1] // Inputs[1] { @11C1 stack[-1] } 11C1 80 DUP1 11C2 60 PUSH1 0x1f 11C4 10 LT 11C5 61 PUSH2 0x11dc 11C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11dc, if 0x1f < stack[-1] label_11C9: // Incoming jump from 0x11C8, if not 0x1f < stack[-1] // Inputs[4] // { // @11CD stack[-2] // @11CE storage[stack[-2]] // @11D1 stack[-3] // @11D3 stack[-1] // } 11C9 61 PUSH2 0x0100 11CC 80 DUP1 11CD 83 DUP4 11CE 54 SLOAD 11CF 04 DIV 11D0 02 MUL 11D1 83 DUP4 11D2 52 MSTORE 11D3 91 SWAP2 11D4 60 PUSH1 0x20 11D6 01 ADD 11D7 91 SWAP2 11D8 61 PUSH2 0x1207 11DB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @11D2 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @11D7 stack[-1] = stack[-1] // @11D7 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1207 label_11DC: // Incoming jump from 0x11C8, if 0x1f < stack[-1] // Inputs[5] // { // @11DD stack[-3] // @11DE stack[-1] // @11E0 stack[-2] // @11E8 memory[0x00:0x20] // @11EC storage[keccak256(memory[0x00:0x20])] // } 11DC 5B JUMPDEST 11DD 82 DUP3 11DE 01 ADD 11DF 91 SWAP2 11E0 90 SWAP1 11E1 60 PUSH1 0x00 11E3 52 MSTORE 11E4 60 PUSH1 0x20 11E6 60 PUSH1 0x00 11E8 20 SHA3 11E9 90 SWAP1 11EA 5B JUMPDEST 11EB 81 DUP2 11EC 54 SLOAD 11ED 81 DUP2 11EE 52 MSTORE 11EF 90 SWAP1 11F0 60 PUSH1 0x01 11F2 01 ADD 11F3 90 SWAP1 11F4 60 PUSH1 0x20 11F6 01 ADD 11F7 80 DUP1 11F8 83 DUP4 11F9 11 GT 11FA 61 PUSH2 0x11ea 11FD 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @11DF stack[-3] = stack[-3] + stack[-1] // @11E3 memory[0x00:0x20] = stack[-2] // @11EE memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @11F3 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @11F6 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x11ea, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_11FE: // Incoming jump from 0x11FD, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x11FD, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @11FE stack[-3] // @11FF stack[-1] // } 11FE 82 DUP3 11FF 90 SWAP1 1200 03 SUB 1201 60 PUSH1 0x1f 1203 16 AND 1204 82 DUP3 1205 01 ADD 1206 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1206 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1206 stack[-1] = stack[-3] // } // Block continues label_1207: // Incoming jump from 0x1206 // Incoming jump from 0x11C0, if !stack[-1] // Incoming jump from 0x11DB // Inputs[4] // { // @120D stack[-7] // @120D stack[-6] // @120F stack[-9] // @1210 stack[-8] // } 1207 5B JUMPDEST 1208 50 POP 1209 50 POP 120A 50 POP 120B 50 POP 120C 50 POP 120D 90 SWAP1 120E 50 POP 120F 91 SWAP2 1210 90 SWAP1 1211 50 POP 1212 56 *JUMP // Stack delta = -8 // Outputs[1] { @120F stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_1213: // Incoming call from 0x0701, returns to 0x0702 // Inputs[1] { @1216 stack[-1] } 1213 5B JUMPDEST 1214 60 PUSH1 0x60 1216 81 DUP2 1217 61 PUSH2 0x1253 121A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1214 stack[0] = 0x60 } // Block ends with conditional jump to 0x1253, if stack[-1] label_121B: // Incoming jump from 0x121A, if not stack[-1] // Inputs[2] // { // @1220 memory[0x40:0x60] // @1251 stack[-3] // } 121B 50 POP 121C 50 POP 121D 60 PUSH1 0x40 121F 80 DUP1 1220 51 MLOAD 1221 80 DUP1 1222 82 DUP3 1223 01 ADD 1224 90 SWAP1 1225 91 SWAP2 1226 52 MSTORE 1227 60 PUSH1 0x01 1229 81 DUP2 122A 52 MSTORE 122B 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 124C 60 PUSH1 0x20 124E 82 DUP3 124F 01 ADD 1250 52 MSTORE 1251 90 SWAP1 1252 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1226 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @122A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1250 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @1251 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1253: // Incoming jump from 0x121A, if stack[-1] // Inputs[1] { @1254 stack[-2] } 1253 5B JUMPDEST 1254 81 DUP2 1255 60 PUSH1 0x00 1257 5B JUMPDEST 1258 81 DUP2 1259 15 ISZERO 125A 61 PUSH2 0x127d 125D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1254 stack[0] = stack[-2] // @1255 stack[1] = 0x00 // } // Block ends with conditional jump to 0x127d, if !stack[-2] label_125E: // Incoming jump from 0x125D, if not !stack[-2] // Incoming jump from 0x125D, if not !stack[-2] // Inputs[1] { @125E stack[-1] } 125E 80 DUP1 125F 61 PUSH2 0x1267 1262 81 DUP2 1263 61 PUSH2 0x270c 1266 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @125E stack[0] = stack[-1] // @125F stack[1] = 0x1267 // @1262 stack[2] = stack[-1] // } // Block ends with call to 0x270c, returns to 0x1267 label_1267: // Incoming return from call to 0x270C at 0x1266 // Inputs[4] // { // @1268 stack[-1] // @1268 stack[-3] // @126D stack[-2] // @1271 stack[-4] // } 1267 5B JUMPDEST 1268 91 SWAP2 1269 50 POP 126A 61 PUSH2 0x1276 126D 90 SWAP1 126E 50 POP 126F 60 PUSH1 0x0a 1271 83 DUP4 1272 61 PUSH2 0x276a 1275 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1268 stack[-3] = stack[-1] // @126D stack[-2] = 0x1276 // @126F stack[-1] = 0x0a // @1271 stack[0] = stack[-4] // } // Block ends with call to 0x276a, returns to 0x1276 label_1276: // Incoming return from call to 0x276A at 0x1275 // Inputs[2] // { // @1277 stack[-1] // @1277 stack[-3] // } 1276 5B JUMPDEST 1277 91 SWAP2 1278 50 POP 1279 61 PUSH2 0x1257 127C 56 *JUMP // Stack delta = -1 // Outputs[1] { @1277 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1257 label_127D: // Incoming jump from 0x125D, if !stack[-2] // Incoming jump from 0x125D, if !stack[-2] // Inputs[1] { @1280 stack[-1] } 127D 5B JUMPDEST 127E 60 PUSH1 0x00 1280 81 DUP2 1281 67 PUSH8 0xffffffffffffffff 128A 81 DUP2 128B 11 GT 128C 15 ISZERO 128D 61 PUSH2 0x1298 1290 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @127E stack[0] = 0x00 // @1280 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1298, if !(stack[-1] > 0xffffffffffffffff) label_1291: // Incoming jump from 0x1290, if not !(stack[-1] > 0xffffffffffffffff) 1291 61 PUSH2 0x1298 1294 61 PUSH2 0x2146 1297 56 *JUMP // Stack delta = +1 // Outputs[1] { @1291 stack[0] = 0x1298 } // Block ends with unconditional jump to 0x2146 label_1298: // Incoming jump from 0x1290, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @129B memory[0x40:0x60] // @129C stack[-1] // } 1298 5B JUMPDEST 1299 60 PUSH1 0x40 129B 51 MLOAD 129C 90 SWAP1 129D 80 DUP1 129E 82 DUP3 129F 52 MSTORE 12A0 80 DUP1 12A1 60 PUSH1 0x1f 12A3 01 ADD 12A4 60 PUSH1 0x1f 12A6 19 NOT 12A7 16 AND 12A8 60 PUSH1 0x20 12AA 01 ADD 12AB 82 DUP3 12AC 01 ADD 12AD 60 PUSH1 0x40 12AF 52 MSTORE 12B0 80 DUP1 12B1 15 ISZERO 12B2 61 PUSH2 0x12c2 12B5 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @129C stack[-1] = memory[0x40:0x60] // @129C stack[0] = stack[-1] // @129F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @12AF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x12c2, if !stack[-1] label_12B6: // Incoming jump from 0x12B5, if not !stack[-1] // Inputs[6] // { // @12B8 stack[-2] // @12BA stack[-1] // @12BC msg.data.length // @12BE msg.data[msg.data.length:msg.data.length + stack[-1]] // @12C4 stack[-3] // @12C7 stack[-7] // } 12B6 60 PUSH1 0x20 12B8 82 DUP3 12B9 01 ADD 12BA 81 DUP2 12BB 80 DUP1 12BC 36 CALLDATASIZE 12BD 83 DUP4 12BE 37 CALLDATACOPY 12BF 01 ADD 12C0 90 SWAP1 12C1 50 POP 12C2 5B JUMPDEST 12C3 50 POP 12C4 90 SWAP1 12C5 50 POP 12C6 5B JUMPDEST 12C7 84 DUP5 12C8 15 ISZERO 12C9 61 PUSH2 0x1345 12CC 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @12BE memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @12C4 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x1345, if !stack[-7] label_12CD: // Incoming jump from 0x12CC, if not !stack[-5] // Incoming jump from 0x12CC, if not !stack[-7] // Incoming jump from 0x12CC, if not !stack[-7] // Inputs[1] { @12D2 stack[-2] } 12CD 61 PUSH2 0x12d7 12D0 60 PUSH1 0x01 12D2 83 DUP4 12D3 61 PUSH2 0x2727 12D6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12CD stack[0] = 0x12d7 // @12D0 stack[1] = 0x01 // @12D2 stack[2] = stack[-2] // } // Block ends with call to 0x2727, returns to 0x12D7 label_12D7: // Incoming return from call to 0x2727 at 0x12D6 // Inputs[3] // { // @12D8 stack[-1] // @12D8 stack[-3] // @12DF stack[-6] // } 12D7 5B JUMPDEST 12D8 91 SWAP2 12D9 50 POP 12DA 61 PUSH2 0x12e4 12DD 60 PUSH1 0x0a 12DF 86 DUP7 12E0 61 PUSH2 0x277e 12E3 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @12D8 stack[-3] = stack[-1] // @12DA stack[-1] = 0x12e4 // @12DD stack[0] = 0x0a // @12DF stack[1] = stack[-6] // } // Block ends with call to 0x277e, returns to 0x12E4 label_12E4: // Incoming return from call to 0x277E at 0x12E3 // Inputs[1] { @12E8 stack[-1] } 12E4 5B JUMPDEST 12E5 61 PUSH2 0x12ef 12E8 90 SWAP1 12E9 60 PUSH1 0x30 12EB 61 PUSH2 0x2792 12EE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12E8 stack[0] = stack[-1] // @12E8 stack[-1] = 0x12ef // @12E9 stack[1] = 0x30 // } // Block ends with call to 0x2792, returns to 0x12EF label_12EF: // Incoming return from call to 0x2792 at 0x12EE // Inputs[4] // { // @12F2 stack[-1] // @12F3 stack[-2] // @12F4 stack[-3] // @12F6 memory[stack[-2]:stack[-2] + 0x20] // } 12EF 5B JUMPDEST 12F0 60 PUSH1 0xf8 12F2 1B SHL 12F3 81 DUP2 12F4 83 DUP4 12F5 81 DUP2 12F6 51 MLOAD 12F7 81 DUP2 12F8 10 LT 12F9 61 PUSH2 0x1304 12FC 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @12F2 stack[-1] = stack[-1] << 0xf8 // @12F3 stack[0] = stack[-2] // @12F4 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1304, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_12FD: // Incoming jump from 0x12FC, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 12FD 61 PUSH2 0x1304 1300 61 PUSH2 0x26e0 1303 56 *JUMP // Stack delta = +1 // Outputs[1] { @12FD stack[0] = 0x1304 } // Block ends with unconditional jump to 0x26e0 label_1304: // Incoming jump from 0x12FC, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1307 stack[-1] // @1308 stack[-2] // @1309 stack[-3] // @1339 stack[-8] // } 1304 5B JUMPDEST 1305 60 PUSH1 0x20 1307 01 ADD 1308 01 ADD 1309 90 SWAP1 130A 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 132A 19 NOT 132B 16 AND 132C 90 SWAP1 132D 81 DUP2 132E 60 PUSH1 0x00 1330 1A BYTE 1331 90 SWAP1 1332 53 MSTORE8 1333 50 POP 1334 61 PUSH2 0x133e 1337 60 PUSH1 0x0a 1339 86 DUP7 133A 61 PUSH2 0x276a 133D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1332 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @1334 stack[-3] = 0x133e // @1337 stack[-2] = 0x0a // @1339 stack[-1] = stack[-8] // } // Block ends with call to 0x276a, returns to 0x133E label_133E: // Incoming return from call to 0x276A at 0x133D // Inputs[2] // { // @133F stack[-6] // @133F stack[-1] // } 133E 5B JUMPDEST 133F 94 SWAP5 1340 50 POP 1341 61 PUSH2 0x12c6 1344 56 *JUMP // Stack delta = -1 // Outputs[1] { @133F stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x12c6 label_1345: // Incoming jump from 0x12CC, if !stack[-5] // Incoming return from call to 0x2189 at 0x222F // Incoming jump from 0x12CC, if !stack[-7] // Incoming jump from 0x12CC, if !stack[-7] // Inputs[3] // { // @1346 stack[-1] // @1346 stack[-6] // @1347 stack[-5] // } 1345 5B JUMPDEST 1346 94 SWAP5 1347 93 SWAP4 1348 50 POP 1349 50 POP 134A 50 POP 134B 50 POP 134C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1346 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 134D 5B JUMPDEST 134E 81 DUP2 134F 51 MLOAD 1350 83 DUP4 1351 51 MLOAD 1352 14 EQ 1353 61 PUSH2 0x13af 1356 57 *JUMPI 1357 60 PUSH1 0x40 1359 51 MLOAD 135A 62 PUSH3 0x461bcd 135E 60 PUSH1 0xe5 1360 1B SHL 1361 81 DUP2 1362 52 MSTORE 1363 60 PUSH1 0x20 1365 60 PUSH1 0x04 1367 82 DUP3 1368 01 ADD 1369 52 MSTORE 136A 60 PUSH1 0x28 136C 60 PUSH1 0x24 136E 82 DUP3 136F 01 ADD 1370 52 MSTORE 1371 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 1392 60 PUSH1 0x44 1394 82 DUP3 1395 01 ADD 1396 52 MSTORE 1397 67 PUSH8 0x0dad2e6dac2e8c6d 13A0 60 PUSH1 0xc3 13A2 1B SHL 13A3 60 PUSH1 0x64 13A5 82 DUP3 13A6 01 ADD 13A7 52 MSTORE 13A8 60 PUSH1 0x84 13AA 01 ADD 13AB 61 PUSH2 0x043c 13AE 56 *JUMP 13AF 5B JUMPDEST 13B0 60 PUSH1 0x01 13B2 60 PUSH1 0x01 13B4 60 PUSH1 0xa0 13B6 1B SHL 13B7 03 SUB 13B8 84 DUP5 13B9 16 AND 13BA 61 PUSH2 0x142b 13BD 57 *JUMPI 13BE 60 PUSH1 0x40 13C0 51 MLOAD 13C1 62 PUSH3 0x461bcd 13C5 60 PUSH1 0xe5 13C7 1B SHL 13C8 81 DUP2 13C9 52 MSTORE 13CA 60 PUSH1 0x20 13CC 60 PUSH1 0x04 13CE 82 DUP3 13CF 01 ADD 13D0 52 MSTORE 13D1 60 PUSH1 0x25 13D3 60 PUSH1 0x24 13D5 82 DUP3 13D6 01 ADD 13D7 52 MSTORE 13D8 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 13F9 60 PUSH1 0x44 13FB 82 DUP3 13FC 01 ADD 13FD 52 MSTORE 13FE 7F PUSH32 0x6472657373000000000000000000000000000000000000000000000000000000 141F 60 PUSH1 0x64 1421 82 DUP3 1422 01 ADD 1423 52 MSTORE 1424 60 PUSH1 0x84 1426 01 ADD 1427 61 PUSH2 0x043c 142A 56 *JUMP 142B 5B JUMPDEST 142C 33 CALLER 142D 60 PUSH1 0x00 142F 5B JUMPDEST 1430 84 DUP5 1431 51 MLOAD 1432 81 DUP2 1433 10 LT 1434 15 ISZERO 1435 61 PUSH2 0x1568 1438 57 *JUMPI 1439 60 PUSH1 0x00 143B 85 DUP6 143C 82 DUP3 143D 81 DUP2 143E 51 MLOAD 143F 81 DUP2 1440 10 LT 1441 61 PUSH2 0x144c 1444 57 *JUMPI 1445 61 PUSH2 0x144c 1448 61 PUSH2 0x26e0 144B 56 *JUMP 144C 5B JUMPDEST 144D 60 PUSH1 0x20 144F 02 MUL 1450 60 PUSH1 0x20 1452 01 ADD 1453 01 ADD 1454 51 MLOAD 1455 90 SWAP1 1456 50 POP 1457 60 PUSH1 0x00 1459 85 DUP6 145A 83 DUP4 145B 81 DUP2 145C 51 MLOAD 145D 81 DUP2 145E 10 LT 145F 61 PUSH2 0x146a 1462 57 *JUMPI 1463 61 PUSH2 0x146a 1466 61 PUSH2 0x26e0 1469 56 *JUMP 146A 5B JUMPDEST 146B 60 PUSH1 0x20 146D 90 SWAP1 146E 81 DUP2 146F 02 MUL 1470 91 SWAP2 1471 90 SWAP1 1472 91 SWAP2 1473 01 ADD 1474 81 DUP2 1475 01 ADD 1476 51 MLOAD 1477 60 PUSH1 0x00 1479 84 DUP5 147A 81 DUP2 147B 52 MSTORE 147C 80 DUP1 147D 83 DUP4 147E 52 MSTORE 147F 60 PUSH1 0x40 1481 80 DUP1 1482 82 DUP3 1483 20 SHA3 1484 60 PUSH1 0x01 1486 60 PUSH1 0x01 1488 60 PUSH1 0xa0 148A 1B SHL 148B 03 SUB 148C 8E DUP15 148D 16 AND 148E 83 DUP4 148F 52 MSTORE 1490 90 SWAP1 1491 93 SWAP4 1492 52 MSTORE 1493 91 SWAP2 1494 90 SWAP1 1495 91 SWAP2 1496 20 SHA3 1497 54 SLOAD 1498 90 SWAP1 1499 91 SWAP2 149A 50 POP 149B 81 DUP2 149C 81 DUP2 149D 10 LT 149E 15 ISZERO 149F 61 PUSH2 0x1510 14A2 57 *JUMPI 14A3 60 PUSH1 0x40 14A5 51 MLOAD 14A6 62 PUSH3 0x461bcd 14AA 60 PUSH1 0xe5 14AC 1B SHL 14AD 81 DUP2 14AE 52 MSTORE 14AF 60 PUSH1 0x20 14B1 60 PUSH1 0x04 14B3 82 DUP3 14B4 01 ADD 14B5 52 MSTORE 14B6 60 PUSH1 0x2a 14B8 60 PUSH1 0x24 14BA 82 DUP3 14BB 01 ADD 14BC 52 MSTORE 14BD 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 14DE 60 PUSH1 0x44 14E0 82 DUP3 14E1 01 ADD 14E2 52 MSTORE 14E3 7F PUSH32 0x72207472616e7366657200000000000000000000000000000000000000000000 1504 60 PUSH1 0x64 1506 82 DUP3 1507 01 ADD 1508 52 MSTORE 1509 60 PUSH1 0x84 150B 01 ADD 150C 61 PUSH2 0x043c 150F 56 *JUMP 1510 5B JUMPDEST 1511 60 PUSH1 0x00 1513 83 DUP4 1514 81 DUP2 1515 52 MSTORE 1516 60 PUSH1 0x20 1518 81 DUP2 1519 81 DUP2 151A 52 MSTORE 151B 60 PUSH1 0x40 151D 80 DUP1 151E 83 DUP4 151F 20 SHA3 1520 60 PUSH1 0x01 1522 60 PUSH1 0x01 1524 60 PUSH1 0xa0 1526 1B SHL 1527 03 SUB 1528 8E DUP15 1529 81 DUP2 152A 16 AND 152B 85 DUP6 152C 52 MSTORE 152D 92 SWAP3 152E 52 MSTORE 152F 80 DUP1 1530 83 DUP4 1531 20 SHA3 1532 85 DUP6 1533 85 DUP6 1534 03 SUB 1535 90 SWAP1 1536 55 SSTORE 1537 90 SWAP1 1538 8B DUP12 1539 16 AND 153A 82 DUP3 153B 52 MSTORE 153C 81 DUP2 153D 20 SHA3 153E 80 DUP1 153F 54 SLOAD 1540 84 DUP5 1541 92 SWAP3 1542 90 SWAP1 1543 61 PUSH2 0x154d 1546 90 SWAP1 1547 84 DUP5 1548 90 SWAP1 1549 61 PUSH2 0x2792 154C 56 *JUMP 154D 5B JUMPDEST 154E 92 SWAP3 154F 50 POP 1550 50 POP 1551 81 DUP2 1552 90 SWAP1 1553 55 SSTORE 1554 50 POP 1555 50 POP 1556 50 POP 1557 50 POP 1558 80 DUP1 1559 61 PUSH2 0x1561 155C 90 SWAP1 155D 61 PUSH2 0x270c 1560 56 *JUMP 1561 5B JUMPDEST 1562 90 SWAP1 1563 50 POP 1564 61 PUSH2 0x142f 1567 56 *JUMP 1568 5B JUMPDEST 1569 50 POP 156A 84 DUP5 156B 60 PUSH1 0x01 156D 60 PUSH1 0x01 156F 60 PUSH1 0xa0 1571 1B SHL 1572 03 SUB 1573 16 AND 1574 86 DUP7 1575 60 PUSH1 0x01 1577 60 PUSH1 0x01 1579 60 PUSH1 0xa0 157B 1B SHL 157C 03 SUB 157D 16 AND 157E 82 DUP3 157F 60 PUSH1 0x01 1581 60 PUSH1 0x01 1583 60 PUSH1 0xa0 1585 1B SHL 1586 03 SUB 1587 16 AND 1588 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 15A9 87 DUP8 15AA 87 DUP8 15AB 60 PUSH1 0x40 15AD 51 MLOAD 15AE 61 PUSH2 0x15b8 15B1 92 SWAP3 15B2 91 SWAP2 15B3 90 SWAP1 15B4 61 PUSH2 0x27aa 15B7 56 *JUMP 15B8 5B JUMPDEST 15B9 60 PUSH1 0x40 15BB 51 MLOAD 15BC 80 DUP1 15BD 91 SWAP2 15BE 03 SUB 15BF 90 SWAP1 15C0 A4 LOG4 15C1 61 PUSH2 0x15ce 15C4 81 DUP2 15C5 87 DUP8 15C6 87 DUP8 15C7 87 DUP8 15C8 87 DUP8 15C9 87 DUP8 15CA 61 PUSH2 0x1c51 15CD 56 *JUMP label_15CE: // Incoming jump from 0x1C61, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @15D5 stack[-7] } 15CE 5B JUMPDEST 15CF 50 POP 15D0 50 POP 15D1 50 POP 15D2 50 POP 15D3 50 POP 15D4 50 POP 15D5 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_15D6: // Incoming call from 0x09C7, returns to 0x09C8 // Inputs[1] { @15DF stack[-3] } 15D6 5B JUMPDEST 15D7 60 PUSH1 0x01 15D9 60 PUSH1 0x01 15DB 60 PUSH1 0xa0 15DD 1B SHL 15DE 03 SUB 15DF 83 DUP4 15E0 16 AND 15E1 61 PUSH2 0x1652 15E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1652, if stack[-3] & (0x01 << 0xa0) - 0x01 label_15E5: // Incoming jump from 0x15E4, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @15E7 memory[0x40:0x60] } 15E5 60 PUSH1 0x40 15E7 51 MLOAD 15E8 62 PUSH3 0x461bcd 15EC 60 PUSH1 0xe5 15EE 1B SHL 15EF 81 DUP2 15F0 52 MSTORE 15F1 60 PUSH1 0x20 15F3 60 PUSH1 0x04 15F5 82 DUP3 15F6 01 ADD 15F7 52 MSTORE 15F8 60 PUSH1 0x23 15FA 60 PUSH1 0x24 15FC 82 DUP3 15FD 01 ADD 15FE 52 MSTORE 15FF 7F PUSH32 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 1620 60 PUSH1 0x44 1622 82 DUP3 1623 01 ADD 1624 52 MSTORE 1625 7F PUSH32 0x6573730000000000000000000000000000000000000000000000000000000000 1646 60 PUSH1 0x64 1648 82 DUP3 1649 01 ADD 164A 52 MSTORE 164B 60 PUSH1 0x84 164D 01 ADD 164E 61 PUSH2 0x043c 1651 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @15F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15F7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15FE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @1624 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 // @164A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6573730000000000000000000000000000000000000000000000000000000000 // @164D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_1652: // Incoming jump from 0x15E4, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1653 stack[-1] // @1654 memory[stack[-1]:stack[-1] + 0x20] // @1655 stack[-2] // @1656 memory[stack[-2]:stack[-2] + 0x20] // } 1652 5B JUMPDEST 1653 80 DUP1 1654 51 MLOAD 1655 82 DUP3 1656 51 MLOAD 1657 14 EQ 1658 61 PUSH2 0x16b4 165B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16b4, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_165C: // Incoming jump from 0x165B, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @165E memory[0x40:0x60] } 165C 60 PUSH1 0x40 165E 51 MLOAD 165F 62 PUSH3 0x461bcd 1663 60 PUSH1 0xe5 1665 1B SHL 1666 81 DUP2 1667 52 MSTORE 1668 60 PUSH1 0x20 166A 60 PUSH1 0x04 166C 82 DUP3 166D 01 ADD 166E 52 MSTORE 166F 60 PUSH1 0x28 1671 60 PUSH1 0x24 1673 82 DUP3 1674 01 ADD 1675 52 MSTORE 1676 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 1697 60 PUSH1 0x44 1699 82 DUP3 169A 01 ADD 169B 52 MSTORE 169C 67 PUSH8 0x0dad2e6dac2e8c6d 16A5 60 PUSH1 0xc3 16A7 1B SHL 16A8 60 PUSH1 0x64 16AA 82 DUP3 16AB 01 ADD 16AC 52 MSTORE 16AD 60 PUSH1 0x84 16AF 01 ADD 16B0 61 PUSH2 0x043c 16B3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1667 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @166E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1675 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @169B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 // @16AC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x0dad2e6dac2e8c6d << 0xc3 // @16AF stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_16B4: // Incoming jump from 0x165B, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[4] // { // @16B8 memory[0x40:0x60] // @16C6 msg.sender // @16C9 stack[-2] // @16CA memory[stack[-2]:stack[-2] + 0x20] // } 16B4 5B JUMPDEST 16B5 60 PUSH1 0x40 16B7 80 DUP1 16B8 51 MLOAD 16B9 60 PUSH1 0x20 16BB 81 DUP2 16BC 01 ADD 16BD 90 SWAP1 16BE 91 SWAP2 16BF 52 MSTORE 16C0 60 PUSH1 0x00 16C2 90 SWAP1 16C3 81 DUP2 16C4 90 SWAP1 16C5 52 MSTORE 16C6 33 CALLER 16C7 90 SWAP1 16C8 5B JUMPDEST 16C9 83 DUP4 16CA 51 MLOAD 16CB 81 DUP2 16CC 10 LT 16CD 15 ISZERO 16CE 61 PUSH2 0x17df 16D1 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @16BF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @16C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @16C7 stack[0] = msg.sender // @16C7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x17df, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_16D2: // Incoming jump from 0x16D1, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x16D1, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @16D4 stack[-4] // @16D5 stack[-1] // @16D7 memory[stack[-4]:stack[-4] + 0x20] // } 16D2 60 PUSH1 0x00 16D4 84 DUP5 16D5 82 DUP3 16D6 81 DUP2 16D7 51 MLOAD 16D8 81 DUP2 16D9 10 LT 16DA 61 PUSH2 0x16e5 16DD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @16D2 stack[0] = 0x00 // @16D4 stack[1] = stack[-4] // @16D5 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x16e5, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_16DE: // Incoming jump from 0x16DD, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 16DE 61 PUSH2 0x16e5 16E1 61 PUSH2 0x26e0 16E4 56 *JUMP // Stack delta = +1 // Outputs[1] { @16DE stack[0] = 0x16e5 } // Block ends with unconditional jump to 0x26e0 label_16E5: // Incoming jump from 0x16DD, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @16E8 stack[-1] // @16EC stack[-2] // @16ED memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @16EE stack[-3] // @16F2 stack[-6] // @16F3 stack[-4] // @16F5 memory[stack[-6]:stack[-6] + 0x20] // } 16E5 5B JUMPDEST 16E6 60 PUSH1 0x20 16E8 02 MUL 16E9 60 PUSH1 0x20 16EB 01 ADD 16EC 01 ADD 16ED 51 MLOAD 16EE 90 SWAP1 16EF 50 POP 16F0 60 PUSH1 0x00 16F2 84 DUP5 16F3 83 DUP4 16F4 81 DUP2 16F5 51 MLOAD 16F6 81 DUP2 16F7 10 LT 16F8 61 PUSH2 0x1703 16FB 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @16EE stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @16F0 stack[-2] = 0x00 // @16F2 stack[-1] = stack[-6] // @16F3 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x1703, if stack[-4] < memory[stack[-6]:stack[-6] + 0x20] label_16FC: // Incoming jump from 0x16FB, if not stack[-4] < memory[stack[-6]:stack[-6] + 0x20] 16FC 61 PUSH2 0x1703 16FF 61 PUSH2 0x26e0 1702 56 *JUMP // Stack delta = +1 // Outputs[1] { @16FC stack[0] = 0x1703 } // Block ends with unconditional jump to 0x26e0 label_1703: // Incoming jump from 0x16FB, if stack[-4] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[9] // { // @1706 stack[-1] // @1709 stack[-2] // @170F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1712 stack[-4] // @171C memory[0x00:0x40] // @1725 stack[-9] // @172F memory[0x00:0x40] // @1730 storage[keccak256(memory[0x00:0x40])] // @1732 stack[-3] // } 1703 5B JUMPDEST 1704 60 PUSH1 0x20 1706 90 SWAP1 1707 81 DUP2 1708 02 MUL 1709 91 SWAP2 170A 90 SWAP1 170B 91 SWAP2 170C 01 ADD 170D 81 DUP2 170E 01 ADD 170F 51 MLOAD 1710 60 PUSH1 0x00 1712 84 DUP5 1713 81 DUP2 1714 52 MSTORE 1715 80 DUP1 1716 83 DUP4 1717 52 MSTORE 1718 60 PUSH1 0x40 171A 80 DUP1 171B 82 DUP3 171C 20 SHA3 171D 60 PUSH1 0x01 171F 60 PUSH1 0x01 1721 60 PUSH1 0xa0 1723 1B SHL 1724 03 SUB 1725 8C DUP13 1726 16 AND 1727 83 DUP4 1728 52 MSTORE 1729 90 SWAP1 172A 93 SWAP4 172B 52 MSTORE 172C 91 SWAP2 172D 90 SWAP1 172E 91 SWAP2 172F 20 SHA3 1730 54 SLOAD 1731 90 SWAP1 1732 91 SWAP2 1733 50 POP 1734 81 DUP2 1735 81 DUP2 1736 10 LT 1737 15 ISZERO 1738 61 PUSH2 0x17a8 173B 57 *JUMPI // Stack delta = -1 // Outputs[6] // { // @1714 memory[0x00:0x20] = stack[-4] // @1717 memory[0x20:0x40] = 0x00 // @1728 memory[0x00:0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @172B memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1731 stack[-2] = storage[keccak256(memory[0x00:0x40])] // @1732 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x17a8, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) label_173C: // Incoming jump from 0x173B, if not !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[1] { @173E memory[0x40:0x60] } 173C 60 PUSH1 0x40 173E 51 MLOAD 173F 62 PUSH3 0x461bcd 1743 60 PUSH1 0xe5 1745 1B SHL 1746 81 DUP2 1747 52 MSTORE 1748 60 PUSH1 0x20 174A 60 PUSH1 0x04 174C 82 DUP3 174D 01 ADD 174E 52 MSTORE 174F 60 PUSH1 0x24 1751 80 DUP1 1752 82 DUP3 1753 01 ADD 1754 52 MSTORE 1755 7F PUSH32 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c 1776 60 PUSH1 0x44 1778 82 DUP3 1779 01 ADD 177A 52 MSTORE 177B 7F PUSH32 0x616e636500000000000000000000000000000000000000000000000000000000 179C 60 PUSH1 0x64 179E 82 DUP3 179F 01 ADD 17A0 52 MSTORE 17A1 60 PUSH1 0x84 17A3 01 ADD 17A4 61 PUSH2 0x043c 17A7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1747 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @174E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1754 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @177A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c // @17A0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616e636500000000000000000000000000000000000000000000000000000000 // @17A3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_17A8: // Incoming jump from 0x173B, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[7] // { // @17AB stack[-3] // @17B7 memory[0x00:0x40] // @17C0 stack[-8] // @17C7 stack[-1] // @17C9 memory[0x00:0x40] // @17CB stack[-2] // @17CE stack[-4] // } 17A8 5B JUMPDEST 17A9 60 PUSH1 0x00 17AB 92 SWAP3 17AC 83 DUP4 17AD 52 MSTORE 17AE 60 PUSH1 0x20 17B0 83 DUP4 17B1 81 DUP2 17B2 52 MSTORE 17B3 60 PUSH1 0x40 17B5 80 DUP1 17B6 85 DUP6 17B7 20 SHA3 17B8 60 PUSH1 0x01 17BA 60 PUSH1 0x01 17BC 60 PUSH1 0xa0 17BE 1B SHL 17BF 03 SUB 17C0 8B DUP12 17C1 16 AND 17C2 86 DUP7 17C3 52 MSTORE 17C4 90 SWAP1 17C5 91 SWAP2 17C6 52 MSTORE 17C7 90 SWAP1 17C8 92 SWAP3 17C9 20 SHA3 17CA 91 SWAP2 17CB 03 SUB 17CC 90 SWAP1 17CD 55 SSTORE 17CE 80 DUP1 17CF 61 PUSH2 0x17d7 17D2 81 DUP2 17D3 61 PUSH2 0x270c 17D6 56 *JUMP // Stack delta = +0 // Outputs[8] // { // @17AD memory[0x00:0x20] = stack[-3] // @17B2 memory[0x20:0x40] = 0x00 // @17C3 memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @17C6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @17CD storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-2] // @17CE stack[-3] = stack[-4] // @17CF stack[-2] = 0x17d7 // @17D2 stack[-1] = stack[-4] // } // Block ends with call to 0x270c, returns to 0x17D7 label_17D7: // Incoming return from call to 0x270C at 0x17D6 // Inputs[2] // { // @17D8 stack[-3] // @17D8 stack[-1] // } 17D7 5B JUMPDEST 17D8 91 SWAP2 17D9 50 POP 17DA 50 POP 17DB 61 PUSH2 0x16c8 17DE 56 *JUMP // Stack delta = -2 // Outputs[1] { @17D8 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x16c8 label_17DF: // Incoming jump from 0x16D1, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x16D1, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @17EC stack[-5] // @17F6 stack[-2] // @1821 stack[-4] // @1822 stack[-3] // @1825 memory[0x40:0x60] // } 17DF 5B JUMPDEST 17E0 50 POP 17E1 60 PUSH1 0x00 17E3 60 PUSH1 0x01 17E5 60 PUSH1 0x01 17E7 60 PUSH1 0xa0 17E9 1B SHL 17EA 03 SUB 17EB 16 AND 17EC 84 DUP5 17ED 60 PUSH1 0x01 17EF 60 PUSH1 0x01 17F1 60 PUSH1 0xa0 17F3 1B SHL 17F4 03 SUB 17F5 16 AND 17F6 82 DUP3 17F7 60 PUSH1 0x01 17F9 60 PUSH1 0x01 17FB 60 PUSH1 0xa0 17FD 1B SHL 17FE 03 SUB 17FF 16 AND 1800 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1821 86 DUP7 1822 86 DUP7 1823 60 PUSH1 0x40 1825 51 MLOAD 1826 61 PUSH2 0x1830 1829 92 SWAP3 182A 91 SWAP2 182B 90 SWAP1 182C 61 PUSH2 0x27aa 182F 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @17EB stack[-1] = (0x01 << 0xa0) - 0x01 & 0x00 // @17F5 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-5] // @17FF stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1800 stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @1829 stack[3] = 0x1830 // @182A stack[4] = stack[-4] // @182B stack[6] = memory[0x40:0x60] // @182B stack[5] = stack[-3] // } // Block ends with call to 0x27aa, returns to 0x1830 label_1830: // Incoming return from call to 0x27AA at 0x182F // Inputs[8] // { // @1833 memory[0x40:0x60] // @1835 stack[-1] // @1838 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1838 stack[-3] // @1838 stack[-5] // @1838 stack[-2] // @1838 stack[-4] // @183D stack[-10] // } 1830 5B JUMPDEST 1831 60 PUSH1 0x40 1833 51 MLOAD 1834 80 DUP1 1835 91 SWAP2 1836 03 SUB 1837 90 SWAP1 1838 A4 LOG4 1839 50 POP 183A 50 POP 183B 50 POP 183C 50 POP 183D 56 *JUMP // Stack delta = -10 // Outputs[1] { @1838 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_183E: // Incoming call from 0x116B, returns to 0x065D // Incoming call from 0x0ABA, returns to 0x0ABB // Inputs[5] // { // @1842 storage[0x03] // @184B stack[-1] // @186D memory[0x40:0x60] // @1899 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @189C stack[-2] // } 183E 5B JUMPDEST 183F 60 PUSH1 0x03 1841 80 DUP1 1842 54 SLOAD 1843 60 PUSH1 0x01 1845 60 PUSH1 0x01 1847 60 PUSH1 0xa0 1849 1B SHL 184A 03 SUB 184B 83 DUP4 184C 81 DUP2 184D 16 AND 184E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1863 19 NOT 1864 83 DUP4 1865 16 AND 1866 81 DUP2 1867 17 OR 1868 90 SWAP1 1869 93 SWAP4 186A 55 SSTORE 186B 60 PUSH1 0x40 186D 51 MLOAD 186E 91 SWAP2 186F 16 AND 1870 91 SWAP2 1871 90 SWAP1 1872 82 DUP3 1873 90 SWAP1 1874 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1895 90 SWAP1 1896 60 PUSH1 0x00 1898 90 SWAP1 1899 A3 LOG3 189A 50 POP 189B 50 POP 189C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @186A storage[0x03] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x03] & ~0xffffffffffffffffffffffffffffffffffffffff) // @1899 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x03] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_189D: // Incoming call from 0x0CE5, returns to 0x0CE6 // Inputs[1] { @18A6 stack[-4] } 189D 5B JUMPDEST 189E 60 PUSH1 0x01 18A0 60 PUSH1 0x01 18A2 60 PUSH1 0xa0 18A4 1B SHL 18A5 03 SUB 18A6 84 DUP5 18A7 16 AND 18A8 61 PUSH2 0x1919 18AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1919, if stack[-4] & (0x01 << 0xa0) - 0x01 label_18AC: // Incoming jump from 0x18AB, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @18AE memory[0x40:0x60] } 18AC 60 PUSH1 0x40 18AE 51 MLOAD 18AF 62 PUSH3 0x461bcd 18B3 60 PUSH1 0xe5 18B5 1B SHL 18B6 81 DUP2 18B7 52 MSTORE 18B8 60 PUSH1 0x20 18BA 60 PUSH1 0x04 18BC 82 DUP3 18BD 01 ADD 18BE 52 MSTORE 18BF 60 PUSH1 0x21 18C1 60 PUSH1 0x24 18C3 82 DUP3 18C4 01 ADD 18C5 52 MSTORE 18C6 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 18E7 60 PUSH1 0x44 18E9 82 DUP3 18EA 01 ADD 18EB 52 MSTORE 18EC 7F PUSH32 0x7300000000000000000000000000000000000000000000000000000000000000 190D 60 PUSH1 0x64 190F 82 DUP3 1910 01 ADD 1911 52 MSTORE 1912 60 PUSH1 0x84 1914 01 ADD 1915 61 PUSH2 0x043c 1918 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @18B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18BE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18C5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @18EB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @1911 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7300000000000000000000000000000000000000000000000000000000000000 // @1914 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_1919: // Incoming jump from 0x18AB, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @191A stack[-2] // @191B memory[stack[-2]:stack[-2] + 0x20] // @191C stack[-3] // @191D memory[stack[-3]:stack[-3] + 0x20] // } 1919 5B JUMPDEST 191A 81 DUP2 191B 51 MLOAD 191C 83 DUP4 191D 51 MLOAD 191E 14 EQ 191F 61 PUSH2 0x197b 1922 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x197b, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] label_1923: // Incoming jump from 0x1922, if not memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @1925 memory[0x40:0x60] } 1923 60 PUSH1 0x40 1925 51 MLOAD 1926 62 PUSH3 0x461bcd 192A 60 PUSH1 0xe5 192C 1B SHL 192D 81 DUP2 192E 52 MSTORE 192F 60 PUSH1 0x20 1931 60 PUSH1 0x04 1933 82 DUP3 1934 01 ADD 1935 52 MSTORE 1936 60 PUSH1 0x28 1938 60 PUSH1 0x24 193A 82 DUP3 193B 01 ADD 193C 52 MSTORE 193D 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 195E 60 PUSH1 0x44 1960 82 DUP3 1961 01 ADD 1962 52 MSTORE 1963 67 PUSH8 0x0dad2e6dac2e8c6d 196C 60 PUSH1 0xc3 196E 1B SHL 196F 60 PUSH1 0x64 1971 82 DUP3 1972 01 ADD 1973 52 MSTORE 1974 60 PUSH1 0x84 1976 01 ADD 1977 61 PUSH2 0x043c 197A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @192E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1935 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @193C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @1962 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 // @1973 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x0dad2e6dac2e8c6d << 0xc3 // @1976 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_197B: // Incoming jump from 0x1922, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @197C msg.sender // @1980 stack[-3] // @1981 memory[stack[-3]:stack[-3] + 0x20] // } 197B 5B JUMPDEST 197C 33 CALLER 197D 60 PUSH1 0x00 197F 5B JUMPDEST 1980 84 DUP5 1981 51 MLOAD 1982 81 DUP2 1983 10 LT 1984 15 ISZERO 1985 61 PUSH2 0x1a17 1988 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @197C stack[0] = msg.sender // @197D stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a17, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_1989: // Incoming jump from 0x1988, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1988, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @1989 stack[-4] // @198A stack[-1] // @198C memory[stack[-4]:stack[-4] + 0x20] // } 1989 83 DUP4 198A 81 DUP2 198B 81 DUP2 198C 51 MLOAD 198D 81 DUP2 198E 10 LT 198F 61 PUSH2 0x199a 1992 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1989 stack[0] = stack[-4] // @198A stack[1] = stack[-1] // } // Block ends with conditional jump to 0x199a, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_1993: // Incoming jump from 0x1992, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 1993 61 PUSH2 0x199a 1996 61 PUSH2 0x26e0 1999 56 *JUMP // Stack delta = +1 // Outputs[1] { @1993 stack[0] = 0x199a } // Block ends with unconditional jump to 0x26e0 label_199A: // Incoming jump from 0x1992, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[6] // { // @199D stack[-1] // @19A1 stack[-2] // @19A2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @19A6 stack[-7] // @19A7 stack[-3] // @19A9 memory[stack[-7]:stack[-7] + 0x20] // } 199A 5B JUMPDEST 199B 60 PUSH1 0x20 199D 02 MUL 199E 60 PUSH1 0x20 19A0 01 ADD 19A1 01 ADD 19A2 51 MLOAD 19A3 60 PUSH1 0x00 19A5 80 DUP1 19A6 87 DUP8 19A7 84 DUP5 19A8 81 DUP2 19A9 51 MLOAD 19AA 81 DUP2 19AB 10 LT 19AC 61 PUSH2 0x19b7 19AF 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @19A2 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @19A3 stack[-1] = 0x00 // @19A5 stack[0] = 0x00 // @19A6 stack[1] = stack[-7] // @19A7 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x19b7, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] label_19B0: // Incoming jump from 0x19AF, if not stack[-3] < memory[stack[-7]:stack[-7] + 0x20] 19B0 61 PUSH2 0x19b7 19B3 61 PUSH2 0x26e0 19B6 56 *JUMP // Stack delta = +1 // Outputs[1] { @19B0 stack[0] = 0x19b7 } // Block ends with unconditional jump to 0x26e0 label_19B7: // Incoming jump from 0x19AF, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[10] // { // @19BA stack[-1] // @19BE stack[-2] // @19BF memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @19C0 stack[-3] // @19C5 stack[-4] // @19CD memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @19D0 stack[-11] // @19F0 memory[0x00:0x40] // @19F3 stack[-5] // @19F5 storage[keccak256(memory[0x00:0x40])] // } 19B7 5B JUMPDEST 19B8 60 PUSH1 0x20 19BA 02 MUL 19BB 60 PUSH1 0x20 19BD 01 ADD 19BE 01 ADD 19BF 51 MLOAD 19C0 81 DUP2 19C1 52 MSTORE 19C2 60 PUSH1 0x20 19C4 01 ADD 19C5 90 SWAP1 19C6 81 DUP2 19C7 52 MSTORE 19C8 60 PUSH1 0x20 19CA 01 ADD 19CB 60 PUSH1 0x00 19CD 20 SHA3 19CE 60 PUSH1 0x00 19D0 88 DUP9 19D1 60 PUSH1 0x01 19D3 60 PUSH1 0x01 19D5 60 PUSH1 0xa0 19D7 1B SHL 19D8 03 SUB 19D9 16 AND 19DA 60 PUSH1 0x01 19DC 60 PUSH1 0x01 19DE 60 PUSH1 0xa0 19E0 1B SHL 19E1 03 SUB 19E2 16 AND 19E3 81 DUP2 19E4 52 MSTORE 19E5 60 PUSH1 0x20 19E7 01 ADD 19E8 90 SWAP1 19E9 81 DUP2 19EA 52 MSTORE 19EB 60 PUSH1 0x20 19ED 01 ADD 19EE 60 PUSH1 0x00 19F0 20 SHA3 19F1 60 PUSH1 0x00 19F3 82 DUP3 19F4 82 DUP3 19F5 54 SLOAD 19F6 61 PUSH2 0x19ff 19F9 91 SWAP2 19FA 90 SWAP1 19FB 61 PUSH2 0x2792 19FE 56 *JUMP // Stack delta = +1 // Outputs[9] // { // @19C1 memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @19C7 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @19E4 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-11] // @19EA memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) // @19F0 stack[-4] = keccak256(memory[0x00:0x40]) // @19F1 stack[-3] = 0x00 // @19F9 stack[-2] = 0x19ff // @19FA stack[-1] = stack[-5] // @19FA stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2792, returns to 0x19FF label_19FF: // Incoming return from call to 0x2792 at 0x19FE // Inputs[5] // { // @1A00 stack[-1] // @1A00 stack[-2] // @1A01 stack[-3] // @1A04 stack[-5] // @1A05 stack[-4] // } 19FF 5B JUMPDEST 1A00 90 SWAP1 1A01 91 SWAP2 1A02 55 SSTORE 1A03 50 POP 1A04 81 DUP2 1A05 90 SWAP1 1A06 50 POP 1A07 61 PUSH2 0x1a0f 1A0A 81 DUP2 1A0B 61 PUSH2 0x270c 1A0E 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1A02 storage[stack[-3]] = stack[-1] // @1A05 stack[-4] = stack[-5] // @1A07 stack[-3] = 0x1a0f // @1A0A stack[-2] = stack[-5] // } // Block ends with call to 0x270c, returns to 0x1A0F label_1A0F: // Incoming return from call to 0x270C at 0x1A0E // Inputs[2] // { // @1A10 stack[-1] // @1A10 stack[-3] // } 1A0F 5B JUMPDEST 1A10 91 SWAP2 1A11 50 POP 1A12 50 POP 1A13 61 PUSH2 0x197f 1A16 56 *JUMP // Stack delta = -2 // Outputs[1] { @1A10 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x197f label_1A17: // Incoming jump from 0x1988, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1988, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[5] // { // @1A19 stack[-6] // @1A2E stack[-2] // @1A59 stack[-5] // @1A5A stack[-4] // @1A5D memory[0x40:0x60] // } 1A17 5B JUMPDEST 1A18 50 POP 1A19 84 DUP5 1A1A 60 PUSH1 0x01 1A1C 60 PUSH1 0x01 1A1E 60 PUSH1 0xa0 1A20 1B SHL 1A21 03 SUB 1A22 16 AND 1A23 60 PUSH1 0x00 1A25 60 PUSH1 0x01 1A27 60 PUSH1 0x01 1A29 60 PUSH1 0xa0 1A2B 1B SHL 1A2C 03 SUB 1A2D 16 AND 1A2E 82 DUP3 1A2F 60 PUSH1 0x01 1A31 60 PUSH1 0x01 1A33 60 PUSH1 0xa0 1A35 1B SHL 1A36 03 SUB 1A37 16 AND 1A38 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1A59 87 DUP8 1A5A 87 DUP8 1A5B 60 PUSH1 0x40 1A5D 51 MLOAD 1A5E 61 PUSH2 0x1a68 1A61 92 SWAP3 1A62 91 SWAP2 1A63 90 SWAP1 1A64 61 PUSH2 0x27aa 1A67 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @1A22 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1A2D stack[0] = (0x01 << 0xa0) - 0x01 & 0x00 // @1A37 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1A38 stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @1A61 stack[3] = 0x1a68 // @1A62 stack[4] = stack[-5] // @1A63 stack[6] = memory[0x40:0x60] // @1A63 stack[5] = stack[-4] // } // Block ends with call to 0x27aa, returns to 0x1A68 label_1A68: // Incoming return from call to 0x27AA at 0x1A67 // Inputs[12] // { // @1A6B memory[0x40:0x60] // @1A6D stack[-1] // @1A70 stack[-3] // @1A70 stack[-2] // @1A70 stack[-4] // @1A70 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1A70 stack[-5] // @1A74 stack[-6] // @1A77 stack[-10] // @1A78 stack[-9] // @1A79 stack[-8] // @1A7A stack[-7] // } 1A68 5B JUMPDEST 1A69 60 PUSH1 0x40 1A6B 51 MLOAD 1A6C 80 DUP1 1A6D 91 SWAP2 1A6E 03 SUB 1A6F 90 SWAP1 1A70 A4 LOG4 1A71 61 PUSH2 0x07c4 1A74 81 DUP2 1A75 60 PUSH1 0x00 1A77 87 DUP8 1A78 87 DUP8 1A79 87 DUP8 1A7A 87 DUP8 1A7B 61 PUSH2 0x1c51 1A7E 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1A70 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); // @1A71 stack[-5] = 0x07c4 // @1A74 stack[-4] = stack[-6] // @1A75 stack[-3] = 0x00 // @1A77 stack[-2] = stack[-10] // @1A78 stack[-1] = stack[-9] // @1A79 stack[0] = stack[-8] // @1A7A stack[1] = stack[-7] // } // Block ends with call to 0x1c51, returns to 0x07C4 1A7F 5B JUMPDEST 1A80 60 PUSH1 0x01 1A82 60 PUSH1 0x01 1A84 60 PUSH1 0xa0 1A86 1B SHL 1A87 03 SUB 1A88 84 DUP5 1A89 16 AND 1A8A 61 PUSH2 0x1afb 1A8D 57 *JUMPI 1A8E 60 PUSH1 0x40 1A90 51 MLOAD 1A91 62 PUSH3 0x461bcd 1A95 60 PUSH1 0xe5 1A97 1B SHL 1A98 81 DUP2 1A99 52 MSTORE 1A9A 60 PUSH1 0x20 1A9C 60 PUSH1 0x04 1A9E 82 DUP3 1A9F 01 ADD 1AA0 52 MSTORE 1AA1 60 PUSH1 0x25 1AA3 60 PUSH1 0x24 1AA5 82 DUP3 1AA6 01 ADD 1AA7 52 MSTORE 1AA8 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 1AC9 60 PUSH1 0x44 1ACB 82 DUP3 1ACC 01 ADD 1ACD 52 MSTORE 1ACE 7F PUSH32 0x6472657373000000000000000000000000000000000000000000000000000000 1AEF 60 PUSH1 0x64 1AF1 82 DUP3 1AF2 01 ADD 1AF3 52 MSTORE 1AF4 60 PUSH1 0x84 1AF6 01 ADD 1AF7 61 PUSH2 0x043c 1AFA 56 *JUMP 1AFB 5B JUMPDEST 1AFC 33 CALLER 1AFD 61 PUSH2 0x1b14 1B00 81 DUP2 1B01 87 DUP8 1B02 87 DUP8 1B03 61 PUSH2 0x1b0b 1B06 88 DUP9 1B07 61 PUSH2 0x1e56 1B0A 56 *JUMP 1B0B 5B JUMPDEST 1B0C 61 PUSH2 0x07c4 1B0F 88 DUP9 1B10 61 PUSH2 0x1e56 1B13 56 *JUMP 1B14 5B JUMPDEST 1B15 60 PUSH1 0x00 1B17 84 DUP5 1B18 81 DUP2 1B19 52 MSTORE 1B1A 60 PUSH1 0x20 1B1C 81 DUP2 1B1D 81 DUP2 1B1E 52 MSTORE 1B1F 60 PUSH1 0x40 1B21 80 DUP1 1B22 83 DUP4 1B23 20 SHA3 1B24 60 PUSH1 0x01 1B26 60 PUSH1 0x01 1B28 60 PUSH1 0xa0 1B2A 1B SHL 1B2B 03 SUB 1B2C 8A DUP11 1B2D 16 AND 1B2E 84 DUP5 1B2F 52 MSTORE 1B30 90 SWAP1 1B31 91 SWAP2 1B32 52 MSTORE 1B33 90 SWAP1 1B34 20 SHA3 1B35 54 SLOAD 1B36 83 DUP4 1B37 81 DUP2 1B38 10 LT 1B39 15 ISZERO 1B3A 61 PUSH2 0x1bab 1B3D 57 *JUMPI 1B3E 60 PUSH1 0x40 1B40 51 MLOAD 1B41 62 PUSH3 0x461bcd 1B45 60 PUSH1 0xe5 1B47 1B SHL 1B48 81 DUP2 1B49 52 MSTORE 1B4A 60 PUSH1 0x20 1B4C 60 PUSH1 0x04 1B4E 82 DUP3 1B4F 01 ADD 1B50 52 MSTORE 1B51 60 PUSH1 0x2a 1B53 60 PUSH1 0x24 1B55 82 DUP3 1B56 01 ADD 1B57 52 MSTORE 1B58 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 1B79 60 PUSH1 0x44 1B7B 82 DUP3 1B7C 01 ADD 1B7D 52 MSTORE 1B7E 7F PUSH32 0x72207472616e7366657200000000000000000000000000000000000000000000 1B9F 60 PUSH1 0x64 1BA1 82 DUP3 1BA2 01 ADD 1BA3 52 MSTORE 1BA4 60 PUSH1 0x84 1BA6 01 ADD 1BA7 61 PUSH2 0x043c 1BAA 56 *JUMP 1BAB 5B JUMPDEST 1BAC 60 PUSH1 0x00 1BAE 85 DUP6 1BAF 81 DUP2 1BB0 52 MSTORE 1BB1 60 PUSH1 0x20 1BB3 81 DUP2 1BB4 81 DUP2 1BB5 52 MSTORE 1BB6 60 PUSH1 0x40 1BB8 80 DUP1 1BB9 83 DUP4 1BBA 20 SHA3 1BBB 60 PUSH1 0x01 1BBD 60 PUSH1 0x01 1BBF 60 PUSH1 0xa0 1BC1 1B SHL 1BC2 03 SUB 1BC3 8B DUP12 1BC4 81 DUP2 1BC5 16 AND 1BC6 85 DUP6 1BC7 52 MSTORE 1BC8 92 SWAP3 1BC9 52 MSTORE 1BCA 80 DUP1 1BCB 83 DUP4 1BCC 20 SHA3 1BCD 87 DUP8 1BCE 85 DUP6 1BCF 03 SUB 1BD0 90 SWAP1 1BD1 55 SSTORE 1BD2 90 SWAP1 1BD3 88 DUP9 1BD4 16 AND 1BD5 82 DUP3 1BD6 52 MSTORE 1BD7 81 DUP2 1BD8 20 SHA3 1BD9 80 DUP1 1BDA 54 SLOAD 1BDB 86 DUP7 1BDC 92 SWAP3 1BDD 90 SWAP1 1BDE 61 PUSH2 0x1be8 1BE1 90 SWAP1 1BE2 84 DUP5 1BE3 90 SWAP1 1BE4 61 PUSH2 0x2792 1BE7 56 *JUMP 1BE8 5B JUMPDEST 1BE9 90 SWAP1 1BEA 91 SWAP2 1BEB 55 SSTORE 1BEC 50 POP 1BED 50 POP 1BEE 60 PUSH1 0x40 1BF0 80 DUP1 1BF1 51 MLOAD 1BF2 86 DUP7 1BF3 81 DUP2 1BF4 52 MSTORE 1BF5 60 PUSH1 0x20 1BF7 81 DUP2 1BF8 01 ADD 1BF9 86 DUP7 1BFA 90 SWAP1 1BFB 52 MSTORE 1BFC 60 PUSH1 0x01 1BFE 60 PUSH1 0x01 1C00 60 PUSH1 0xa0 1C02 1B SHL 1C03 03 SUB 1C04 80 DUP1 1C05 89 DUP10 1C06 16 AND 1C07 92 SWAP3 1C08 8A DUP11 1C09 82 DUP3 1C0A 16 AND 1C0B 92 SWAP3 1C0C 91 SWAP2 1C0D 86 DUP7 1C0E 16 AND 1C0F 91 SWAP2 1C10 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1C31 91 SWAP2 1C32 01 ADD 1C33 60 PUSH1 0x40 1C35 51 MLOAD 1C36 80 DUP1 1C37 91 SWAP2 1C38 03 SUB 1C39 90 SWAP1 1C3A A4 LOG4 1C3B 61 PUSH2 0x1c48 1C3E 82 DUP3 1C3F 88 DUP9 1C40 88 DUP9 1C41 88 DUP9 1C42 88 DUP9 1C43 88 DUP9 1C44 61 PUSH2 0x1ea1 1C47 56 *JUMP label_1C48: // Incoming jump from 0x1DE8, if 0xbc197c8100000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1C50 stack[-8] } 1C48 5B JUMPDEST 1C49 50 POP 1C4A 50 POP 1C4B 50 POP 1C4C 50 POP 1C4D 50 POP 1C4E 50 POP 1C4F 50 POP 1C50 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_1C51: // Incoming call from 0x1A7E, returns to 0x07C4 // Inputs[2] // { // @1C5A stack[-4] // @1C5C address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 1C51 5B JUMPDEST 1C52 60 PUSH1 0x01 1C54 60 PUSH1 0x01 1C56 60 PUSH1 0xa0 1C58 1B SHL 1C59 03 SUB 1C5A 84 DUP5 1C5B 16 AND 1C5C 3B EXTCODESIZE 1C5D 15 ISZERO 1C5E 61 PUSH2 0x15ce 1C61 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15ce, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_1C62: // Incoming jump from 0x1C61, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[7] // { // @1C64 memory[0x40:0x60] // @1C90 stack[-4] // @1C9D stack[-6] // @1C9F stack[-5] // @1CA1 stack[-3] // @1CA3 stack[-2] // @1CA5 stack[-1] // } 1C62 60 PUSH1 0x40 1C64 51 MLOAD 1C65 7F PUSH32 0xbc197c8100000000000000000000000000000000000000000000000000000000 1C86 81 DUP2 1C87 52 MSTORE 1C88 60 PUSH1 0x01 1C8A 60 PUSH1 0x01 1C8C 60 PUSH1 0xa0 1C8E 1B SHL 1C8F 03 SUB 1C90 85 DUP6 1C91 16 AND 1C92 90 SWAP1 1C93 63 PUSH4 0xbc197c81 1C98 90 SWAP1 1C99 61 PUSH2 0x1cae 1C9C 90 SWAP1 1C9D 89 DUP10 1C9E 90 SWAP1 1C9F 89 DUP10 1CA0 90 SWAP1 1CA1 88 DUP9 1CA2 90 SWAP1 1CA3 88 DUP9 1CA4 90 SWAP1 1CA5 88 DUP9 1CA6 90 SWAP1 1CA7 60 PUSH1 0x04 1CA9 01 ADD 1CAA 61 PUSH2 0x27d8 1CAD 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1C87 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xbc197c8100000000000000000000000000000000000000000000000000000000 // @1C92 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1C98 stack[1] = 0xbc197c81 // @1C9C stack[2] = 0x1cae // @1C9E stack[3] = stack[-6] // @1CA0 stack[4] = stack[-5] // @1CA2 stack[5] = stack[-3] // @1CA4 stack[6] = stack[-2] // @1CA6 stack[7] = stack[-1] // @1CA9 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x27d8, returns to 0x1CAE label_1CAE: // Incoming return from call to 0x27D8 at 0x1CAD // Inputs[6] // { // @1CB3 memory[0x40:0x60] // @1CB5 stack[-1] // @1CBA stack[-3] // @1CBB msg.gas // @1CBC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1CBC address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } 1CAE 5B JUMPDEST 1CAF 60 PUSH1 0x20 1CB1 60 PUSH1 0x40 1CB3 51 MLOAD 1CB4 80 DUP1 1CB5 83 DUP4 1CB6 03 SUB 1CB7 81 DUP2 1CB8 60 PUSH1 0x00 1CBA 87 DUP8 1CBB 5A GAS 1CBC F1 CALL 1CBD 92 SWAP3 1CBE 50 POP 1CBF 50 POP 1CC0 50 POP 1CC1 80 DUP1 1CC2 15 ISZERO 1CC3 61 PUSH2 0x1ce9 1CC6 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1CBC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1CBD stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1ce9, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1CC7: // Incoming jump from 0x1CC6, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @1CCB memory[0x40:0x60] // @1CCE returndata.length // } 1CC7 50 POP 1CC8 60 PUSH1 0x40 1CCA 80 DUP1 1CCB 51 MLOAD 1CCC 60 PUSH1 0x1f 1CCE 3D RETURNDATASIZE 1CCF 90 SWAP1 1CD0 81 DUP2 1CD1 01 ADD 1CD2 60 PUSH1 0x1f 1CD4 19 NOT 1CD5 16 AND 1CD6 82 DUP3 1CD7 01 ADD 1CD8 90 SWAP1 1CD9 92 SWAP3 1CDA 52 MSTORE 1CDB 61 PUSH2 0x1ce6 1CDE 91 SWAP2 1CDF 81 DUP2 1CE0 01 ADD 1CE1 90 SWAP1 1CE2 61 PUSH2 0x2836 1CE5 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1CDA memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1CDE stack[-1] = 0x1ce6 // @1CE1 stack[1] = memory[0x40:0x60] // @1CE1 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2836 1CE6 5B JUMPDEST 1CE7 60 PUSH1 0x01 label_1CE9: // Incoming jump from 0x1CC6, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @1CED stack[-1] } 1CE9 5B JUMPDEST 1CEA 61 PUSH2 0x1d9f 1CED 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d9f, if stack[-1] label_1CEE: // Incoming jump from 0x1CED, if not stack[-1] 1CEE 61 PUSH2 0x1cf5 1CF1 61 PUSH2 0x2853 1CF4 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CEE stack[0] = 0x1cf5 } // Block ends with call to 0x2853, returns to 0x1CF5 label_1CF5: // Incoming return from call to 0x2853 at 0x1CF4 // Inputs[1] { @1CF6 stack[-1] } 1CF5 5B JUMPDEST 1CF6 80 DUP1 1CF7 63 PUSH4 0x08c379a0 1CFC 14 EQ 1CFD 15 ISZERO 1CFE 61 PUSH2 0x1d2f 1D01 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d2f, if !(0x08c379a0 == stack[-1]) label_1D02: // Incoming jump from 0x1D01, if not !(0x08c379a0 == stack[-1]) 1D02 50 POP 1D03 61 PUSH2 0x1d0a 1D06 61 PUSH2 0x286f 1D09 56 *JUMP // Stack delta = +0 // Outputs[1] { @1D03 stack[-1] = 0x1d0a } // Block ends with call to 0x286f, returns to 0x1D0A label_1D0A: // Incoming return from call to 0x286F at 0x1D09 // Incoming return from call to 0x286F at 0x1D09 // Inputs[1] { @1D0B stack[-1] } 1D0A 5B JUMPDEST 1D0B 80 DUP1 1D0C 61 PUSH2 0x1d15 1D0F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d15, if stack[-1] label_1D10: // Incoming jump from 0x1D0F, if not stack[-1] 1D10 50 POP 1D11 61 PUSH2 0x1d31 1D14 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1d31 label_1D15: // Incoming jump from 0x1D0F, if stack[-1] // Inputs[2] // { // @1D16 stack[-1] // @1D19 memory[0x40:0x60] // } 1D15 5B JUMPDEST 1D16 80 DUP1 1D17 60 PUSH1 0x40 1D19 51 MLOAD 1D1A 62 PUSH3 0x461bcd 1D1E 60 PUSH1 0xe5 1D20 1B SHL 1D21 81 DUP2 1D22 52 MSTORE 1D23 60 PUSH1 0x04 1D25 01 ADD 1D26 61 PUSH2 0x043c 1D29 91 SWAP2 1D2A 90 SWAP1 1D2B 61 PUSH2 0x2288 1D2E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1D22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D29 stack[0] = 0x043c // @1D2A stack[1] = stack[-1] // @1D2A stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2288 label_1D2F: // Incoming jump from 0x1D01, if !(0x08c379a0 == stack[-1]) // Inputs[1] { @1D34 memory[0x40:0x60] } 1D2F 5B JUMPDEST 1D30 50 POP 1D31 5B JUMPDEST 1D32 60 PUSH1 0x40 1D34 51 MLOAD 1D35 62 PUSH3 0x461bcd 1D39 60 PUSH1 0xe5 1D3B 1B SHL 1D3C 81 DUP2 1D3D 52 MSTORE 1D3E 60 PUSH1 0x20 1D40 60 PUSH1 0x04 1D42 82 DUP3 1D43 01 ADD 1D44 52 MSTORE 1D45 60 PUSH1 0x34 1D47 60 PUSH1 0x24 1D49 82 DUP3 1D4A 01 ADD 1D4B 52 MSTORE 1D4C 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 1D6D 60 PUSH1 0x44 1D6F 82 DUP3 1D70 01 ADD 1D71 52 MSTORE 1D72 7F PUSH32 0x526563656976657220696d706c656d656e746572000000000000000000000000 1D93 60 PUSH1 0x64 1D95 82 DUP3 1D96 01 ADD 1D97 52 MSTORE 1D98 60 PUSH1 0x84 1D9A 01 ADD 1D9B 61 PUSH2 0x043c 1D9E 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @1D3D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D44 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D4B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x34 // @1D71 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 // @1D97 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x526563656976657220696d706c656d656e746572000000000000000000000000 // @1D9A stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c label_1D9F: // Incoming jump from 0x1CED, if stack[-1] // Inputs[1] { @1DC1 stack[-1] } 1D9F 5B JUMPDEST 1DA0 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1DC1 81 DUP2 1DC2 16 AND 1DC3 7F PUSH32 0xbc197c8100000000000000000000000000000000000000000000000000000000 1DE4 14 EQ 1DE5 61 PUSH2 0x1c48 1DE8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c48, if 0xbc197c8100000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_1DE9: // Incoming jump from 0x1DE8, if not 0xbc197c8100000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1DEB memory[0x40:0x60] } 1DE9 60 PUSH1 0x40 1DEB 51 MLOAD 1DEC 62 PUSH3 0x461bcd 1DF0 60 PUSH1 0xe5 1DF2 1B SHL 1DF3 81 DUP2 1DF4 52 MSTORE 1DF5 60 PUSH1 0x20 1DF7 60 PUSH1 0x04 1DF9 82 DUP3 1DFA 01 ADD 1DFB 52 MSTORE 1DFC 60 PUSH1 0x28 1DFE 60 PUSH1 0x24 1E00 82 DUP3 1E01 01 ADD 1E02 52 MSTORE 1E03 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 1E24 60 PUSH1 0x44 1E26 82 DUP3 1E27 01 ADD 1E28 52 MSTORE 1E29 7F PUSH32 0x6420746f6b656e73000000000000000000000000000000000000000000000000 1E4A 60 PUSH1 0x64 1E4C 82 DUP3 1E4D 01 ADD 1E4E 52 MSTORE 1E4F 60 PUSH1 0x84 1E51 01 ADD 1E52 61 PUSH2 0x043c 1E55 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1DF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DFB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E02 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @1E28 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @1E4E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6420746f6b656e73000000000000000000000000000000000000000000000000 // @1E51 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x043c 1E56 5B JUMPDEST 1E57 60 PUSH1 0x40 1E59 80 DUP1 1E5A 51 MLOAD 1E5B 60 PUSH1 0x01 1E5D 80 DUP1 1E5E 82 DUP3 1E5F 52 MSTORE 1E60 81 DUP2 1E61 83 DUP4 1E62 01 ADD 1E63 90 SWAP1 1E64 92 SWAP3 1E65 52 MSTORE 1E66 60 PUSH1 0x60 1E68 91 SWAP2 1E69 60 PUSH1 0x00 1E6B 91 SWAP2 1E6C 90 SWAP1 1E6D 60 PUSH1 0x20 1E6F 80 DUP1 1E70 83 DUP4 1E71 01 ADD 1E72 90 SWAP1 1E73 80 DUP1 1E74 36 CALLDATASIZE 1E75 83 DUP4 1E76 37 CALLDATACOPY 1E77 01 ADD 1E78 90 SWAP1 1E79 50 POP 1E7A 50 POP 1E7B 90 SWAP1 1E7C 50 POP 1E7D 82 DUP3 1E7E 81 DUP2 1E7F 60 PUSH1 0x00 1E81 81 DUP2 1E82 51 MLOAD 1E83 81 DUP2 1E84 10 LT 1E85 61 PUSH2 0x1e90 1E88 57 *JUMPI 1E89 61 PUSH2 0x1e90 1E8C 61 PUSH2 0x26e0 1E8F 56 *JUMP 1E90 5B JUMPDEST 1E91 60 PUSH1 0x20 1E93 90 SWAP1 1E94 81 DUP2 1E95 02 MUL 1E96 91 SWAP2 1E97 90 SWAP1 1E98 91 SWAP2 1E99 01 ADD 1E9A 01 ADD 1E9B 52 MSTORE 1E9C 92 SWAP3 1E9D 91 SWAP2 1E9E 50 POP 1E9F 50 POP 1EA0 56 *JUMP 1EA1 5B JUMPDEST 1EA2 60 PUSH1 0x01 1EA4 60 PUSH1 0x01 1EA6 60 PUSH1 0xa0 1EA8 1B SHL 1EA9 03 SUB 1EAA 84 DUP5 1EAB 16 AND 1EAC 3B EXTCODESIZE 1EAD 15 ISZERO 1EAE 61 PUSH2 0x15ce 1EB1 57 *JUMPI 1EB2 60 PUSH1 0x40 1EB4 51 MLOAD 1EB5 7F PUSH32 0xf23a6e6100000000000000000000000000000000000000000000000000000000 1ED6 81 DUP2 1ED7 52 MSTORE 1ED8 60 PUSH1 0x01 1EDA 60 PUSH1 0x01 1EDC 60 PUSH1 0xa0 1EDE 1B SHL 1EDF 03 SUB 1EE0 85 DUP6 1EE1 16 AND 1EE2 90 SWAP1 1EE3 63 PUSH4 0xf23a6e61 1EE8 90 SWAP1 1EE9 61 PUSH2 0x1efe 1EEC 90 SWAP1 1EED 89 DUP10 1EEE 90 SWAP1 1EEF 89 DUP10 1EF0 90 SWAP1 1EF1 88 DUP9 1EF2 90 SWAP1 1EF3 88 DUP9 1EF4 90 SWAP1 1EF5 88 DUP9 1EF6 90 SWAP1 1EF7 60 PUSH1 0x04 1EF9 01 ADD 1EFA 61 PUSH2 0x2917 1EFD 56 *JUMP 1EFE 5B JUMPDEST 1EFF 60 PUSH1 0x20 1F01 60 PUSH1 0x40 1F03 51 MLOAD 1F04 80 DUP1 1F05 83 DUP4 1F06 03 SUB 1F07 81 DUP2 1F08 60 PUSH1 0x00 1F0A 87 DUP8 1F0B 5A GAS 1F0C F1 CALL 1F0D 92 SWAP3 1F0E 50 POP 1F0F 50 POP 1F10 50 POP 1F11 80 DUP1 1F12 15 ISZERO 1F13 61 PUSH2 0x1f39 1F16 57 *JUMPI 1F17 50 POP 1F18 60 PUSH1 0x40 1F1A 80 DUP1 1F1B 51 MLOAD 1F1C 60 PUSH1 0x1f 1F1E 3D RETURNDATASIZE 1F1F 90 SWAP1 1F20 81 DUP2 1F21 01 ADD 1F22 60 PUSH1 0x1f 1F24 19 NOT 1F25 16 AND 1F26 82 DUP3 1F27 01 ADD 1F28 90 SWAP1 1F29 92 SWAP3 1F2A 52 MSTORE 1F2B 61 PUSH2 0x1f36 1F2E 91 SWAP2 1F2F 81 DUP2 1F30 01 ADD 1F31 90 SWAP1 1F32 61 PUSH2 0x2836 1F35 56 *JUMP 1F36 5B JUMPDEST 1F37 60 PUSH1 0x01 1F39 5B JUMPDEST 1F3A 61 PUSH2 0x1f45 1F3D 57 *JUMPI 1F3E 61 PUSH2 0x1cf5 1F41 61 PUSH2 0x2853 1F44 56 *JUMP 1F45 5B JUMPDEST 1F46 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1F67 81 DUP2 1F68 16 AND 1F69 7F PUSH32 0xf23a6e6100000000000000000000000000000000000000000000000000000000 1F8A 14 EQ 1F8B 61 PUSH2 0x1c48 1F8E 57 *JUMPI 1F8F 60 PUSH1 0x40 1F91 51 MLOAD 1F92 62 PUSH3 0x461bcd 1F96 60 PUSH1 0xe5 1F98 1B SHL 1F99 81 DUP2 1F9A 52 MSTORE 1F9B 60 PUSH1 0x20 1F9D 60 PUSH1 0x04 1F9F 82 DUP3 1FA0 01 ADD 1FA1 52 MSTORE 1FA2 60 PUSH1 0x28 1FA4 60 PUSH1 0x24 1FA6 82 DUP3 1FA7 01 ADD 1FA8 52 MSTORE 1FA9 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 1FCA 60 PUSH1 0x44 1FCC 82 DUP3 1FCD 01 ADD 1FCE 52 MSTORE 1FCF 7F PUSH32 0x6420746f6b656e73000000000000000000000000000000000000000000000000 1FF0 60 PUSH1 0x64 1FF2 82 DUP3 1FF3 01 ADD 1FF4 52 MSTORE 1FF5 60 PUSH1 0x84 1FF7 01 ADD 1FF8 61 PUSH2 0x043c 1FFB 56 *JUMP label_1FFC: // Incoming jump from 0x117E // Inputs[2] // { // @1FFD stack[-3] // @1FFF storage[stack[-3]] // } 1FFC 5B JUMPDEST 1FFD 82 DUP3 1FFE 80 DUP1 1FFF 54 SLOAD 2000 61 PUSH2 0x2008 2003 90 SWAP1 2004 61 PUSH2 0x2676 2007 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FFD stack[0] = stack[-3] // @2003 stack[1] = 0x2008 // @2003 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2676, returns to 0x2008 label_2008: // Incoming return from call to 0x2676 at 0x2007 // Inputs[5] // { // @2009 stack[-1] // @2009 stack[-2] // @2011 memory[0x00:0x20] // @201C stack[-4] // @201D stack[-3] // } 2008 5B JUMPDEST 2009 90 SWAP1 200A 60 PUSH1 0x00 200C 52 MSTORE 200D 60 PUSH1 0x20 200F 60 PUSH1 0x00 2011 20 SHA3 2012 90 SWAP1 2013 60 PUSH1 0x1f 2015 01 ADD 2016 60 PUSH1 0x20 2018 90 SWAP1 2019 04 DIV 201A 81 DUP2 201B 01 ADD 201C 92 SWAP3 201D 82 DUP3 201E 61 PUSH2 0x202a 2021 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @200C memory[0x00:0x20] = stack[-2] // @2012 stack[-2] = keccak256(memory[0x00:0x20]) // @201C stack[-1] = stack[-4] // @201C stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x202a, if stack[-3] label_2022: // Incoming jump from 0x2021, if not stack[-3] // Inputs[1] { @2024 stack[-5] } 2022 60 PUSH1 0x00 2024 85 DUP6 2025 55 SSTORE 2026 61 PUSH2 0x2070 2029 56 *JUMP // Stack delta = +0 // Outputs[1] { @2025 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x2070 label_202A: // Incoming jump from 0x2021, if stack[-3] // Inputs[1] { @202B stack[-3] } 202A 5B JUMPDEST 202B 82 DUP3 202C 60 PUSH1 0x1f 202E 10 LT 202F 61 PUSH2 0x2043 2032 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2043, if 0x1f < stack[-3] label_2033: // Incoming jump from 0x2032, if not 0x1f < stack[-3] // Inputs[4] // { // @2033 stack[-1] // @2034 memory[stack[-1]:stack[-1] + 0x20] // @2039 stack[-3] // @203D stack[-5] // } 2033 80 DUP1 2034 51 MLOAD 2035 60 PUSH1 0xff 2037 19 NOT 2038 16 AND 2039 83 DUP4 203A 80 DUP1 203B 01 ADD 203C 17 OR 203D 85 DUP6 203E 55 SSTORE 203F 61 PUSH2 0x2070 2042 56 *JUMP // Stack delta = +0 // Outputs[1] { @203E storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x2070 label_2043: // Incoming jump from 0x2032, if 0x1f < stack[-3] // Inputs[2] // { // @2044 stack[-3] // @204A stack[-5] // } 2043 5B JUMPDEST 2044 82 DUP3 2045 80 DUP1 2046 01 ADD 2047 60 PUSH1 0x01 2049 01 ADD 204A 85 DUP6 204B 55 SSTORE 204C 82 DUP3 204D 15 ISZERO 204E 61 PUSH2 0x2070 2051 57 *JUMPI // Stack delta = +0 // Outputs[1] { @204B storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2070, if !stack[-3] label_2052: // Incoming jump from 0x2051, if not !stack[-3] // Inputs[2] // { // @2052 stack[-1] // @2052 stack[-3] // } 2052 91 SWAP2 2053 82 DUP3 2054 01 ADD 2055 5B JUMPDEST 2056 82 DUP3 2057 81 DUP2 2058 11 GT 2059 15 ISZERO 205A 61 PUSH2 0x2070 205D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2052 stack[-3] = stack[-1] // @2054 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2070, if !(stack[-1] + stack[-3] > stack[-1]) label_205E: // Incoming jump from 0x205D, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x205D, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @205E stack[-3] // @205F memory[stack[-3]:stack[-3] + 0x20] // @2060 stack[-2] // @2062 stack[-1] // } 205E 82 DUP3 205F 51 MLOAD 2060 82 DUP3 2061 55 SSTORE 2062 91 SWAP2 2063 60 PUSH1 0x20 2065 01 ADD 2066 91 SWAP2 2067 90 SWAP1 2068 60 PUSH1 0x01 206A 01 ADD 206B 90 SWAP1 206C 61 PUSH2 0x2055 206F 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2061 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @2066 stack[-3] = 0x20 + stack[-3] // @206B stack[-2] = 0x01 + stack[-2] // @206B stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x2055 label_2070: // Incoming jump from 0x2042 // Incoming jump from 0x2051, if !stack[-3] // Incoming jump from 0x205D, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2029 // Incoming jump from 0x205D, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @2075 stack[-4] // @2076 stack[-3] // } 2070 5B JUMPDEST 2071 50 POP 2072 61 PUSH2 0x207c 2075 92 SWAP3 2076 91 SWAP2 2077 50 POP 2078 61 PUSH2 0x2080 207B 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2075 stack[-4] = 0x207c // @2076 stack[-3] = stack[-4] // } // Block ends with call to 0x2080, returns to 0x207C label_207C: // Incoming jump from 0x2089, if !(stack[-2] > stack[-1]) // Incoming jump from 0x2089, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2080 at 0x207B // Inputs[2] // { // @207E stack[-3] // @207E stack[-2] // } 207C 5B JUMPDEST 207D 50 POP 207E 90 SWAP1 207F 56 *JUMP // Stack delta = -2 // Outputs[1] { @207E stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2080: // Incoming call from 0x207B, returns to 0x207C // Inputs[2] // { // @2082 stack[-1] // @2083 stack[-2] // } 2080 5B JUMPDEST 2081 5B JUMPDEST 2082 80 DUP1 2083 82 DUP3 2084 11 GT 2085 15 ISZERO 2086 61 PUSH2 0x207c 2089 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x207c, if !(stack[-2] > stack[-1]) label_208A: // Incoming jump from 0x2089, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x2089, if not !(stack[-2] > stack[-1]) // Inputs[1] { @208C stack[-1] } 208A 60 PUSH1 0x00 208C 81 DUP2 208D 55 SSTORE 208E 60 PUSH1 0x01 2090 01 ADD 2091 61 PUSH2 0x2081 2094 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @208D storage[stack[-1]] = 0x00 // @2090 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2081 label_2095: // Incoming call from 0x2607, returns to 0x2608 // Incoming call from 0x237E, returns to 0x237F // Incoming call from 0x25A1, returns to 0x2126 // Incoming call from 0x2488, returns to 0x2489 // Incoming call from 0x25F9, returns to 0x25FA // Incoming call from 0x263F, returns to 0x2640 // Incoming call from 0x2370, returns to 0x2371 // Incoming call from 0x2530, returns to 0x2531 // Incoming call from 0x25BD, returns to 0x25BE // Incoming call from 0x2631, returns to 0x2632 // Incoming call from 0x20CC, returns to 0x20CD // Inputs[2] // { // @2096 stack[-1] // @2097 msg.data[stack[-1]:stack[-1] + 0x20] // } 2095 5B JUMPDEST 2096 80 DUP1 2097 35 CALLDATALOAD 2098 60 PUSH1 0x01 209A 60 PUSH1 0x01 209C 60 PUSH1 0xa0 209E 1B SHL 209F 03 SUB 20A0 81 DUP2 20A1 16 AND 20A2 81 DUP2 20A3 14 EQ 20A4 61 PUSH2 0x20ac 20A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2097 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x20ac, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_20A8: // Incoming jump from 0x20A7, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @20AB memory[0x00:0x00] } 20A8 60 PUSH1 0x00 20AA 80 DUP1 20AB FD *REVERT // Stack delta = +0 // Outputs[1] { @20AB revert(memory[0x00:0x00]); } // Block terminates label_20AC: // Incoming jump from 0x20A7, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @20AD stack[-1] // @20AD stack[-3] // @20AE stack[-2] // } 20AC 5B JUMPDEST 20AD 91 SWAP2 20AE 90 SWAP1 20AF 50 POP 20B0 56 *JUMP // Stack delta = -2 // Outputs[1] { @20AD stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_20B1: // Incoming call from 0x01A9, returns to 0x01AA // Inputs[2] // { // @20B7 stack[-1] // @20B8 stack[-2] // } 20B1 5B JUMPDEST 20B2 60 PUSH1 0x00 20B4 80 DUP1 20B5 60 PUSH1 0x40 20B7 83 DUP4 20B8 85 DUP6 20B9 03 SUB 20BA 12 SLT 20BB 15 ISZERO 20BC 61 PUSH2 0x20c4 20BF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20B2 stack[0] = 0x00 // @20B4 stack[1] = 0x00 // } // Block ends with conditional jump to 0x20c4, if !(stack[-2] - stack[-1] i< 0x40) label_20C0: // Incoming jump from 0x20BF, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20C3 memory[0x00:0x00] } 20C0 60 PUSH1 0x00 20C2 80 DUP1 20C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @20C3 revert(memory[0x00:0x00]); } // Block terminates label_20C4: // Incoming jump from 0x20BF, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20C8 stack[-3] } 20C4 5B JUMPDEST 20C5 61 PUSH2 0x20cd 20C8 83 DUP4 20C9 61 PUSH2 0x2095 20CC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20C5 stack[0] = 0x20cd // @20C8 stack[1] = stack[-3] // } // Block ends with call to 0x2095, returns to 0x20CD label_20CD: // Incoming return from call to 0x2095 at 0x20CC // Inputs[5] // { // @20CE stack[-6] // @20CE stack[-1] // @20D1 stack[-4] // @20D5 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @20D6 stack[-5] // } 20CD 5B JUMPDEST 20CE 94 SWAP5 20CF 60 PUSH1 0x20 20D1 93 SWAP4 20D2 90 SWAP1 20D3 93 SWAP4 20D4 01 ADD 20D5 35 CALLDATALOAD 20D6 93 SWAP4 20D7 50 POP 20D8 50 POP 20D9 50 POP 20DA 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @20CE stack[-6] = stack[-1] // @20D6 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_20DB: // Incoming call from 0x2852, returns to 0x2126 // Incoming call from 0x2125, returns to 0x2126 // Inputs[1] { @20FD stack[-1] } 20DB 5B JUMPDEST 20DC 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 20FD 81 DUP2 20FE 16 AND 20FF 81 DUP2 2100 14 EQ 2101 61 PUSH2 0x065d 2104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065d, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_2105: // Incoming jump from 0x2104, if not stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @2108 memory[0x00:0x00] } 2105 60 PUSH1 0x00 2107 80 DUP1 2108 FD *REVERT // Stack delta = +0 // Outputs[1] { @2108 revert(memory[0x00:0x00]); } // Block terminates label_2109: // Incoming call from 0x01CF, returns to 0x01D0 // Inputs[2] // { // @210E stack[-1] // @210F stack[-2] // } 2109 5B JUMPDEST 210A 60 PUSH1 0x00 210C 60 PUSH1 0x20 210E 82 DUP3 210F 84 DUP5 2110 03 SUB 2111 12 SLT 2112 15 ISZERO 2113 61 PUSH2 0x211b 2116 57 *JUMPI // Stack delta = +1 // Outputs[1] { @210A stack[0] = 0x00 } // Block ends with conditional jump to 0x211b, if !(stack[-2] - stack[-1] i< 0x20) label_2117: // Incoming jump from 0x2116, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @211A memory[0x00:0x00] } 2117 60 PUSH1 0x00 2119 80 DUP1 211A FD *REVERT // Stack delta = +0 // Outputs[1] { @211A revert(memory[0x00:0x00]); } // Block terminates label_211B: // Incoming jump from 0x2116, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @211C stack[-2] // @211D msg.data[stack[-2]:stack[-2] + 0x20] // } 211B 5B JUMPDEST 211C 81 DUP2 211D 35 CALLDATALOAD 211E 61 PUSH2 0x2126 2121 81 DUP2 2122 61 PUSH2 0x20db 2125 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @211D stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @211E stack[1] = 0x2126 // @2121 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x20db, returns to 0x2126 label_2126: // Incoming return from call to 0x20DB at 0x2125 // Incoming return from call to 0x225C at 0x229A // Incoming return from call to 0x24C5 at 0x2512 // Incoming return from call to 0x2189 at 0x234F // Incoming return from call to 0x20DB at 0x2852 // Incoming return from call to 0x2095 at 0x25A1 // Inputs[3] // { // @2127 stack[-5] // @2127 stack[-1] // @2128 stack[-4] // } 2126 5B JUMPDEST 2127 93 SWAP4 2128 92 SWAP3 2129 50 POP 212A 50 POP 212B 50 POP 212C 56 *JUMP // Stack delta = -4 // Outputs[1] { @2127 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_212D: // Incoming call from 0x01F2, returns to 0x01F3 // Incoming call from 0x0247, returns to 0x0248 // Inputs[2] // { // @2132 stack[-1] // @2133 stack[-2] // } 212D 5B JUMPDEST 212E 60 PUSH1 0x00 2130 60 PUSH1 0x20 2132 82 DUP3 2133 84 DUP5 2134 03 SUB 2135 12 SLT 2136 15 ISZERO 2137 61 PUSH2 0x213f 213A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @212E stack[0] = 0x00 } // Block ends with conditional jump to 0x213f, if !(stack[-2] - stack[-1] i< 0x20) label_213B: // Incoming jump from 0x213A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @213E memory[0x00:0x00] } 213B 60 PUSH1 0x00 213D 80 DUP1 213E FD *REVERT // Stack delta = +0 // Outputs[1] { @213E revert(memory[0x00:0x00]); } // Block terminates label_213F: // Incoming jump from 0x213A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @2141 stack[-2] // @2141 msg.data[stack[-2]:stack[-2] + 0x20] // @2142 stack[-4] // @2143 stack[-3] // } 213F 5B JUMPDEST 2140 50 POP 2141 35 CALLDATALOAD 2142 91 SWAP2 2143 90 SWAP1 2144 50 POP 2145 56 *JUMP // Stack delta = -3 // Outputs[1] { @2142 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2146: // Incoming jump from 0x08B9 // Incoming jump from 0x1297 // Incoming jump from 0x22B4 // Incoming jump from 0x2181 // Incoming jump from 0x21A2 // Inputs[1] { @215B memory[0x00:0x24] } 2146 5B JUMPDEST 2147 63 PUSH4 0x4e487b71 214C 60 PUSH1 0xe0 214E 1B SHL 214F 60 PUSH1 0x00 2151 52 MSTORE 2152 60 PUSH1 0x41 2154 60 PUSH1 0x04 2156 52 MSTORE 2157 60 PUSH1 0x24 2159 60 PUSH1 0x00 215B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2151 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2156 memory[0x04:0x24] = 0x41 // @215B revert(memory[0x00:0x24]); // } // Block terminates label_215C: // Incoming call from 0x290B, returns to 0x290C // Incoming call from 0x21B9, returns to 0x21BA // Incoming call from 0x2452, returns to 0x2453 // Incoming call from 0x22E9, returns to 0x22EA // Inputs[2] // { // @2162 stack[-2] // @2165 stack[-1] // } 215C 5B JUMPDEST 215D 60 PUSH1 0x1f 215F 19 NOT 2160 60 PUSH1 0x1f 2162 83 DUP4 2163 01 ADD 2164 16 AND 2165 81 DUP2 2166 01 ADD 2167 81 DUP2 2168 81 DUP2 2169 10 LT 216A 67 PUSH8 0xffffffffffffffff 2173 82 DUP3 2174 11 GT 2175 17 OR 2176 15 ISZERO 2177 61 PUSH2 0x2182 217A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2166 stack[0] = stack[-1] + (stack[-2] + 0x1f & ~0x1f) } // Block ends with conditional jump to 0x2182, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) label_217B: // Incoming jump from 0x217A, if not !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) 217B 61 PUSH2 0x2182 217E 61 PUSH2 0x2146 2181 56 *JUMP // Stack delta = +1 // Outputs[1] { @217B stack[0] = 0x2182 } // Block ends with unconditional jump to 0x2146 label_2182: // Incoming jump from 0x217A, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) // Inputs[2] // { // @2185 stack[-1] // @2188 stack[-4] // } 2182 5B JUMPDEST 2183 60 PUSH1 0x40 2185 52 MSTORE 2186 50 POP 2187 50 POP 2188 56 *JUMP // Stack delta = -4 // Outputs[1] { @2185 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2189: // Incoming call from 0x234F, returns to 0x2126 // Incoming call from 0x222F, returns to 0x1345 // Inputs[1] { @2195 stack[-2] } 2189 5B JUMPDEST 218A 60 PUSH1 0x00 218C 67 PUSH8 0xffffffffffffffff 2195 83 DUP4 2196 11 GT 2197 15 ISZERO 2198 61 PUSH2 0x21a3 219B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @218A stack[0] = 0x00 } // Block ends with conditional jump to 0x21a3, if !(stack[-2] > 0xffffffffffffffff) label_219C: // Incoming jump from 0x219B, if not !(stack[-2] > 0xffffffffffffffff) 219C 61 PUSH2 0x21a3 219F 61 PUSH2 0x2146 21A2 56 *JUMP // Stack delta = +1 // Outputs[1] { @219C stack[0] = 0x21a3 } // Block ends with unconditional jump to 0x2146 label_21A3: // Incoming jump from 0x219B, if !(stack[-2] > 0xffffffffffffffff) // Inputs[2] // { // @21A6 memory[0x40:0x60] // @21B1 stack[-3] // } 21A3 5B JUMPDEST 21A4 60 PUSH1 0x40 21A6 51 MLOAD 21A7 61 PUSH2 0x21ba 21AA 60 PUSH1 0x20 21AC 60 PUSH1 0x1f 21AE 19 NOT 21AF 60 PUSH1 0x1f 21B1 87 DUP8 21B2 01 ADD 21B3 16 AND 21B4 01 ADD 21B5 82 DUP3 21B6 61 PUSH2 0x215c 21B9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @21A6 stack[0] = memory[0x40:0x60] // @21A7 stack[1] = 0x21ba // @21B4 stack[2] = (stack[-3] + 0x1f & ~0x1f) + 0x20 // @21B5 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x215c, returns to 0x21BA label_21BA: // Incoming return from call to 0x215C at 0x21B9 // Inputs[5] // { // @21BB stack[-1] // @21BC stack[-2] // @21BE stack[-4] // @21C1 stack[-5] // @21C3 stack[-3] // } 21BA 5B JUMPDEST 21BB 80 DUP1 21BC 91 SWAP2 21BD 50 POP 21BE 83 DUP4 21BF 81 DUP2 21C0 52 MSTORE 21C1 84 DUP5 21C2 84 DUP5 21C3 84 DUP5 21C4 01 ADD 21C5 11 GT 21C6 15 ISZERO 21C7 61 PUSH2 0x21cf 21CA 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @21BC stack[-2] = stack[-1] // @21C0 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x21cf, if !(stack[-3] + stack[-4] > stack[-5]) label_21CB: // Incoming jump from 0x21CA, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @21CE memory[0x00:0x00] } 21CB 60 PUSH1 0x00 21CD 80 DUP1 21CE FD *REVERT // Stack delta = +0 // Outputs[1] { @21CE revert(memory[0x00:0x00]); } // Block terminates label_21CF: // Incoming jump from 0x21CA, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[7] // { // @21D0 stack[-4] // @21D1 stack[-3] // @21D4 stack[-1] // @21D6 msg.data[stack[-3]:stack[-3] + stack[-4]] // @21E1 stack[-2] // @21E1 stack[-6] // @21E2 stack[-5] // } 21CF 5B JUMPDEST 21D0 83 DUP4 21D1 83 DUP4 21D2 60 PUSH1 0x20 21D4 83 DUP4 21D5 01 ADD 21D6 37 CALLDATACOPY 21D7 60 PUSH1 0x00 21D9 60 PUSH1 0x20 21DB 85 DUP6 21DC 83 DUP4 21DD 01 ADD 21DE 01 ADD 21DF 52 MSTORE 21E0 50 POP 21E1 93 SWAP4 21E2 92 SWAP3 21E3 50 POP 21E4 50 POP 21E5 50 POP 21E6 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @21D6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-4]] = msg.data[stack[-3]:stack[-3] + stack[-4]] // @21DF memory[stack[-1] + stack[-4] + 0x20:stack[-1] + stack[-4] + 0x20 + 0x20] = 0x00 // @21E1 stack[-6] = stack[-2] // } // Block ends with unconditional jump to stack[-6] label_21E7: // Incoming call from 0x021D, returns to 0x021E // Incoming call from 0x026D, returns to 0x026E // Inputs[2] // { // @21EC stack[-1] // @21ED stack[-2] // } 21E7 5B JUMPDEST 21E8 60 PUSH1 0x00 21EA 60 PUSH1 0x20 21EC 82 DUP3 21ED 84 DUP5 21EE 03 SUB 21EF 12 SLT 21F0 15 ISZERO 21F1 61 PUSH2 0x21f9 21F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21E8 stack[0] = 0x00 } // Block ends with conditional jump to 0x21f9, if !(stack[-2] - stack[-1] i< 0x20) label_21F5: // Incoming jump from 0x21F4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @21F8 memory[0x00:0x00] } 21F5 60 PUSH1 0x00 21F7 80 DUP1 21F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @21F8 revert(memory[0x00:0x00]); } // Block terminates label_21F9: // Incoming jump from 0x21F4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @21FA stack[-2] // @21FB msg.data[stack[-2]:stack[-2] + 0x20] // } 21F9 5B JUMPDEST 21FA 81 DUP2 21FB 35 CALLDATALOAD 21FC 67 PUSH8 0xffffffffffffffff 2205 81 DUP2 2206 11 GT 2207 15 ISZERO 2208 61 PUSH2 0x2210 220B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21FB stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2210, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_220C: // Incoming jump from 0x220B, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @220F memory[0x00:0x00] } 220C 60 PUSH1 0x00 220E 80 DUP1 220F FD *REVERT // Stack delta = +0 // Outputs[1] { @220F revert(memory[0x00:0x00]); } // Block terminates label_2210: // Incoming jump from 0x220B, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2211 stack[-3] // @2212 stack[-1] // @2217 stack[-4] // } 2210 5B JUMPDEST 2211 82 DUP3 2212 01 ADD 2213 60 PUSH1 0x1f 2215 81 DUP2 2216 01 ADD 2217 84 DUP5 2218 13 SGT 2219 61 PUSH2 0x2221 221C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2212 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x2221, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_221D: // Incoming jump from 0x221C, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @2220 memory[0x00:0x00] } 221D 60 PUSH1 0x00 221F 80 DUP1 2220 FD *REVERT // Stack delta = +0 // Outputs[1] { @2220 revert(memory[0x00:0x00]); } // Block terminates label_2221: // Incoming jump from 0x221C, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2225 stack[-4] // @2226 stack[-1] // @2227 msg.data[stack[-1]:stack[-1] + 0x20] // } 2221 5B JUMPDEST 2222 61 PUSH2 0x1345 2225 84 DUP5 2226 82 DUP3 2227 35 CALLDATALOAD 2228 60 PUSH1 0x20 222A 84 DUP5 222B 01 ADD 222C 61 PUSH2 0x2189 222F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2222 stack[0] = 0x1345 // @2225 stack[1] = stack[-4] // @2227 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @222B stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2189, returns to 0x1345 label_2230: // Incoming call from 0x26D6, returns to 0x26D7 // Incoming call from 0x26C2, returns to 0x26C3 // Incoming call from 0x2273, returns to 0x2274 // Inputs[1] { @2234 stack[-3] } 2230 5B JUMPDEST 2231 60 PUSH1 0x00 2233 5B JUMPDEST 2234 83 DUP4 2235 81 DUP2 2236 10 LT 2237 15 ISZERO 2238 61 PUSH2 0x224b 223B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2231 stack[0] = 0x00 } // Block ends with conditional jump to 0x224b, if !(0x00 < stack[-3]) label_223C: // Incoming jump from 0x223B, if not !(0x00 < stack[-3]) // Incoming jump from 0x223B, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @223C stack[-2] // @223D stack[-1] // @223F memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2240 stack[-3] // } 223C 81 DUP2 223D 81 DUP2 223E 01 ADD 223F 51 MLOAD 2240 83 DUP4 2241 82 DUP3 2242 01 ADD 2243 52 MSTORE 2244 60 PUSH1 0x20 2246 01 ADD 2247 61 PUSH2 0x2233 224A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2243 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2246 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2233 label_224B: // Incoming jump from 0x223B, if !(0x00 < stack[-3]) // Incoming jump from 0x223B, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @224C stack[-4] // @224D stack[-1] // } 224B 5B JUMPDEST 224C 83 DUP4 224D 81 DUP2 224E 11 GT 224F 15 ISZERO 2250 61 PUSH2 0x0ce6 2253 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ce6, if !(stack[-1] > stack[-4]) label_2254: // Incoming jump from 0x2253, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2258 stack[-4] // @2259 stack[-3] // @225B stack[-5] // } 2254 50 POP 2255 50 POP 2256 60 PUSH1 0x00 2258 91 SWAP2 2259 01 ADD 225A 52 MSTORE 225B 56 *JUMP // Stack delta = -5 // Outputs[1] { @225A memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_225C: // Incoming call from 0x229A, returns to 0x2126 // Incoming call from 0x2829, returns to 0x282A // Inputs[3] // { // @225F stack[-1] // @2260 memory[stack[-1]:stack[-1] + 0x20] // @2262 stack[-2] // } 225C 5B JUMPDEST 225D 60 PUSH1 0x00 225F 81 DUP2 2260 51 MLOAD 2261 80 DUP1 2262 84 DUP5 2263 52 MSTORE 2264 61 PUSH2 0x2274 2267 81 DUP2 2268 60 PUSH1 0x20 226A 86 DUP7 226B 01 ADD 226C 60 PUSH1 0x20 226E 86 DUP7 226F 01 ADD 2270 61 PUSH2 0x2230 2273 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @225D stack[0] = 0x00 // @2260 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2263 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2264 stack[2] = 0x2274 // @2267 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @226B stack[4] = stack[-2] + 0x20 // @226F stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2230, returns to 0x2274 label_2274: // Incoming return from call to 0x2230 at 0x2273 // Inputs[4] // { // @2277 stack[-1] // @227C stack[-4] // @227D stack[-2] // @2283 stack[-5] // } 2274 5B JUMPDEST 2275 60 PUSH1 0x1f 2277 01 ADD 2278 60 PUSH1 0x1f 227A 19 NOT 227B 16 AND 227C 92 SWAP3 227D 90 SWAP1 227E 92 SWAP3 227F 01 ADD 2280 60 PUSH1 0x20 2282 01 ADD 2283 92 SWAP3 2284 91 SWAP2 2285 50 POP 2286 50 POP 2287 56 *JUMP // Stack delta = -4 // Outputs[1] { @2283 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2288: // Incoming jump from 0x1D2E // Incoming jump from 0x0239 // Inputs[2] // { // @228B stack[-1] // @2296 stack[-2] // } 2288 5B JUMPDEST 2289 60 PUSH1 0x20 228B 81 DUP2 228C 52 MSTORE 228D 60 PUSH1 0x00 228F 61 PUSH2 0x2126 2292 60 PUSH1 0x20 2294 83 DUP4 2295 01 ADD 2296 84 DUP5 2297 61 PUSH2 0x225c 229A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @228C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @228D stack[0] = 0x00 // @228F stack[1] = 0x2126 // @2295 stack[2] = stack[-1] + 0x20 // @2296 stack[3] = stack[-2] // } // Block ends with call to 0x225c, returns to 0x2126 label_229B: // Incoming call from 0x2445, returns to 0x2446 // Incoming call from 0x22DC, returns to 0x22DD // Inputs[1] { @22A7 stack[-1] } 229B 5B JUMPDEST 229C 60 PUSH1 0x00 229E 67 PUSH8 0xffffffffffffffff 22A7 82 DUP3 22A8 11 GT 22A9 15 ISZERO 22AA 61 PUSH2 0x22b5 22AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @229C stack[0] = 0x00 } // Block ends with conditional jump to 0x22b5, if !(stack[-1] > 0xffffffffffffffff) label_22AE: // Incoming jump from 0x22AD, if not !(stack[-1] > 0xffffffffffffffff) 22AE 61 PUSH2 0x22b5 22B1 61 PUSH2 0x2146 22B4 56 *JUMP // Stack delta = +1 // Outputs[1] { @22AE stack[0] = 0x22b5 } // Block ends with unconditional jump to 0x2146 label_22B5: // Incoming jump from 0x22AD, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @22B9 stack[-2] // @22BD stack[-3] // } 22B5 5B JUMPDEST 22B6 50 POP 22B7 60 PUSH1 0x05 22B9 1B SHL 22BA 60 PUSH1 0x20 22BC 01 ADD 22BD 90 SWAP1 22BE 56 *JUMP // Stack delta = -2 // Outputs[1] { @22BD stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_22BF: // Incoming call from 0x2559, returns to 0x255A // Incoming call from 0x23A7, returns to 0x23A8 // Incoming call from 0x24BA, returns to 0x24BB // Incoming call from 0x257C, returns to 0x257D // Incoming call from 0x23C9, returns to 0x23CA // Inputs[2] // { // @22C2 stack[-2] // @22C5 stack[-1] // } 22BF 5B JUMPDEST 22C0 60 PUSH1 0x00 22C2 82 DUP3 22C3 60 PUSH1 0x1f 22C5 83 DUP4 22C6 01 ADD 22C7 12 SLT 22C8 61 PUSH2 0x22d0 22CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22C0 stack[0] = 0x00 } // Block ends with conditional jump to 0x22d0, if stack[-1] + 0x1f i< stack[-2] label_22CC: // Incoming jump from 0x22CB, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @22CF memory[0x00:0x00] } 22CC 60 PUSH1 0x00 22CE 80 DUP1 22CF FD *REVERT // Stack delta = +0 // Outputs[1] { @22CF revert(memory[0x00:0x00]); } // Block terminates label_22D0: // Incoming jump from 0x22CB, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @22D1 stack[-2] // @22D2 msg.data[stack[-2]:stack[-2] + 0x20] // } 22D0 5B JUMPDEST 22D1 81 DUP2 22D2 35 CALLDATALOAD 22D3 60 PUSH1 0x20 22D5 61 PUSH2 0x22dd 22D8 82 DUP3 22D9 61 PUSH2 0x229b 22DC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22D2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @22D3 stack[1] = 0x20 // @22D5 stack[2] = 0x22dd // @22D8 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x229b, returns to 0x22DD label_22DD: // Incoming return from call to 0x229B at 0x22DC // Inputs[2] // { // @22E0 memory[0x40:0x60] // @22E4 stack[-1] // } 22DD 5B JUMPDEST 22DE 60 PUSH1 0x40 22E0 51 MLOAD 22E1 61 PUSH2 0x22ea 22E4 82 DUP3 22E5 82 DUP3 22E6 61 PUSH2 0x215c 22E9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22E0 stack[0] = memory[0x40:0x60] // @22E1 stack[1] = 0x22ea // @22E4 stack[2] = stack[-1] // @22E5 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x215c, returns to 0x22EA label_22EA: // Incoming return from call to 0x215C at 0x22E9 // Inputs[6] // { // @22EB stack[-4] // @22EC stack[-1] // @22F4 stack[-6] // @22F6 stack[-3] // @22FC stack[-2] // @22FE stack[-7] // } 22EA 5B JUMPDEST 22EB 83 DUP4 22EC 81 DUP2 22ED 52 MSTORE 22EE 60 PUSH1 0x05 22F0 93 SWAP4 22F1 90 SWAP1 22F2 93 SWAP4 22F3 1B SHL 22F4 85 DUP6 22F5 01 ADD 22F6 82 DUP3 22F7 01 ADD 22F8 92 SWAP3 22F9 82 DUP3 22FA 81 DUP2 22FB 01 ADD 22FC 91 SWAP2 22FD 50 POP 22FE 86 DUP7 22FF 84 DUP5 2300 11 GT 2301 15 ISZERO 2302 61 PUSH2 0x230a 2305 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @22ED memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @22F8 stack[-1] = stack[-1] // @22F8 stack[-4] = stack[-3] + stack[-6] + (stack[-4] << 0x05) // @22FC stack[-2] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x230a, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) label_2306: // Incoming jump from 0x2305, if not !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[1] { @2309 memory[0x00:0x00] } 2306 60 PUSH1 0x00 2308 80 DUP1 2309 FD *REVERT // Stack delta = +0 // Outputs[1] { @2309 revert(memory[0x00:0x00]); } // Block terminates label_230A: // Incoming jump from 0x2305, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[3] // { // @230B stack[-3] // @230C stack[-6] // @230F stack[-4] // } 230A 5B JUMPDEST 230B 82 DUP3 230C 86 DUP7 230D 01 ADD 230E 5B JUMPDEST 230F 84 DUP5 2310 81 DUP2 2311 10 LT 2312 15 ISZERO 2313 61 PUSH2 0x2325 2316 57 *JUMPI // Stack delta = +1 // Outputs[1] { @230D stack[0] = stack[-6] + stack[-3] } // Block ends with conditional jump to 0x2325, if !(stack[-6] + stack[-3] < stack[-4]) label_2317: // Incoming jump from 0x2316, if not !(stack[-1] < stack[-5]) // Incoming jump from 0x2316, if not !(stack[-6] + stack[-3] < stack[-4]) // Inputs[4] // { // @2317 stack[-1] // @2318 msg.data[stack[-1]:stack[-1] + 0x20] // @2319 stack[-3] // @231C stack[-4] // } 2317 80 DUP1 2318 35 CALLDATALOAD 2319 83 DUP4 231A 52 MSTORE 231B 91 SWAP2 231C 83 DUP4 231D 01 ADD 231E 91 SWAP2 231F 83 DUP4 2320 01 ADD 2321 61 PUSH2 0x230e 2324 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @231A memory[stack[-3]:stack[-3] + 0x20] = msg.data[stack[-1]:stack[-1] + 0x20] // @231E stack[-3] = stack[-4] + stack[-3] // @2320 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x230e label_2325: // Incoming jump from 0x2316, if !(stack[-1] < stack[-5]) // Incoming jump from 0x2316, if !(stack[-6] + stack[-3] < stack[-4]) // Inputs[3] // { // @2327 stack[-9] // @2327 stack[-2] // @2328 stack[-8] // } 2325 5B JUMPDEST 2326 50 POP 2327 96 SWAP7 2328 95 SWAP6 2329 50 POP 232A 50 POP 232B 50 POP 232C 50 POP 232D 50 POP 232E 50 POP 232F 56 *JUMP // Stack delta = -8 // Outputs[1] { @2327 stack[-9] = stack[-2] } // Block ends with unconditional jump to stack[-9] label_2330: // Incoming jump from 0x2675 // Incoming jump from 0x23EC // Inputs[2] // { // @2333 stack[-2] // @2336 stack[-1] // } 2330 5B JUMPDEST 2331 60 PUSH1 0x00 2333 82 DUP3 2334 60 PUSH1 0x1f 2336 83 DUP4 2337 01 ADD 2338 12 SLT 2339 61 PUSH2 0x2341 233C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2331 stack[0] = 0x00 } // Block ends with conditional jump to 0x2341, if stack[-1] + 0x1f i< stack[-2] label_233D: // Incoming jump from 0x233C, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2340 memory[0x00:0x00] } 233D 60 PUSH1 0x00 233F 80 DUP1 2340 FD *REVERT // Stack delta = +0 // Outputs[1] { @2340 revert(memory[0x00:0x00]); } // Block terminates label_2341: // Incoming jump from 0x233C, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @2345 stack[-3] // @2346 stack[-2] // @2347 msg.data[stack[-2]:stack[-2] + 0x20] // } 2341 5B JUMPDEST 2342 61 PUSH2 0x2126 2345 83 DUP4 2346 83 DUP4 2347 35 CALLDATALOAD 2348 60 PUSH1 0x20 234A 85 DUP6 234B 01 ADD 234C 61 PUSH2 0x2189 234F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2342 stack[0] = 0x2126 // @2345 stack[1] = stack[-3] // @2347 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @234B stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x2189, returns to 0x2126 label_2350: // Incoming jump from 0x025A // Inputs[2] // { // @235B stack[-1] // @235C stack[-2] // } 2350 5B JUMPDEST 2351 60 PUSH1 0x00 2353 80 DUP1 2354 60 PUSH1 0x00 2356 80 DUP1 2357 60 PUSH1 0x00 2359 60 PUSH1 0xa0 235B 86 DUP7 235C 88 DUP9 235D 03 SUB 235E 12 SLT 235F 15 ISZERO 2360 61 PUSH2 0x2368 2363 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2351 stack[0] = 0x00 // @2353 stack[1] = 0x00 // @2354 stack[2] = 0x00 // @2356 stack[3] = 0x00 // @2357 stack[4] = 0x00 // } // Block ends with conditional jump to 0x2368, if !(stack[-2] - stack[-1] i< 0xa0) label_2364: // Incoming jump from 0x2363, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @2367 memory[0x00:0x00] } 2364 60 PUSH1 0x00 2366 80 DUP1 2367 FD *REVERT // Stack delta = +0 // Outputs[1] { @2367 revert(memory[0x00:0x00]); } // Block terminates label_2368: // Incoming jump from 0x2363, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @236C stack[-6] } 2368 5B JUMPDEST 2369 61 PUSH2 0x2371 236C 86 DUP7 236D 61 PUSH2 0x2095 2370 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2369 stack[0] = 0x2371 // @236C stack[1] = stack[-6] // } // Block ends with call to 0x2095, returns to 0x2371 label_2371: // Incoming return from call to 0x2095 at 0x2370 // Inputs[3] // { // @2372 stack[-1] // @2372 stack[-6] // @2379 stack[-7] // } 2371 5B JUMPDEST 2372 94 SWAP5 2373 50 POP 2374 61 PUSH2 0x237f 2377 60 PUSH1 0x20 2379 87 DUP8 237A 01 ADD 237B 61 PUSH2 0x2095 237E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2372 stack[-6] = stack[-1] // @2374 stack[-1] = 0x237f // @237A stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x2095, returns to 0x237F label_237F: // Incoming return from call to 0x2095 at 0x237E // Inputs[4] // { // @2380 stack[-1] // @2380 stack[-5] // @2384 stack[-7] // @2386 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 237F 5B JUMPDEST 2380 93 SWAP4 2381 50 POP 2382 60 PUSH1 0x40 2384 86 DUP7 2385 01 ADD 2386 35 CALLDATALOAD 2387 67 PUSH8 0xffffffffffffffff 2390 80 DUP1 2391 82 DUP3 2392 11 GT 2393 15 ISZERO 2394 61 PUSH2 0x239c 2397 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2380 stack[-5] = stack[-1] // @2386 stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2387 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x239c, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) label_2398: // Incoming jump from 0x2397, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @239B memory[0x00:0x00] } 2398 60 PUSH1 0x00 239A 80 DUP1 239B FD *REVERT // Stack delta = +0 // Outputs[1] { @239B revert(memory[0x00:0x00]); } // Block terminates label_239C: // Incoming jump from 0x2397, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @23A0 stack[-9] // @23A1 stack[-2] // @23A2 stack[-8] // } 239C 5B JUMPDEST 239D 61 PUSH2 0x23a8 23A0 89 DUP10 23A1 83 DUP4 23A2 8A DUP11 23A3 01 ADD 23A4 61 PUSH2 0x22bf 23A7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @239D stack[0] = 0x23a8 // @23A0 stack[1] = stack[-9] // @23A3 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x22bf, returns to 0x23A8 label_23A8: // Incoming return from call to 0x22BF at 0x23A7 // Inputs[6] // { // @23A9 stack[-6] // @23A9 stack[-1] // @23AD stack[-9] // @23AF msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @23B0 stack[-3] // @23B2 stack[-2] // } 23A8 5B JUMPDEST 23A9 94 SWAP5 23AA 50 POP 23AB 60 PUSH1 0x60 23AD 88 DUP9 23AE 01 ADD 23AF 35 CALLDATALOAD 23B0 91 SWAP2 23B1 50 POP 23B2 80 DUP1 23B3 82 DUP3 23B4 11 GT 23B5 15 ISZERO 23B6 61 PUSH2 0x23be 23B9 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @23A9 stack[-6] = stack[-1] // @23B0 stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x23be, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_23BA: // Incoming jump from 0x23B9, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[1] { @23BD memory[0x00:0x00] } 23BA 60 PUSH1 0x00 23BC 80 DUP1 23BD FD *REVERT // Stack delta = +0 // Outputs[1] { @23BD revert(memory[0x00:0x00]); } // Block terminates label_23BE: // Incoming jump from 0x23B9, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @23C2 stack[-9] // @23C3 stack[-2] // @23C4 stack[-8] // } 23BE 5B JUMPDEST 23BF 61 PUSH2 0x23ca 23C2 89 DUP10 23C3 83 DUP4 23C4 8A DUP11 23C5 01 ADD 23C6 61 PUSH2 0x22bf 23C9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23BF stack[0] = 0x23ca // @23C2 stack[1] = stack[-9] // @23C5 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x22bf, returns to 0x23CA label_23CA: // Incoming return from call to 0x22BF at 0x23C9 // Inputs[6] // { // @23CB stack[-1] // @23CB stack[-5] // @23CF stack[-9] // @23D1 msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @23D2 stack[-3] // @23D4 stack[-2] // } 23CA 5B JUMPDEST 23CB 93 SWAP4 23CC 50 POP 23CD 60 PUSH1 0x80 23CF 88 DUP9 23D0 01 ADD 23D1 35 CALLDATALOAD 23D2 91 SWAP2 23D3 50 POP 23D4 80 DUP1 23D5 82 DUP3 23D6 11 GT 23D7 15 ISZERO 23D8 61 PUSH2 0x23e0 23DB 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @23CB stack[-5] = stack[-1] // @23D2 stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x23e0, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_23DC: // Incoming jump from 0x23DB, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[1] { @23DF memory[0x00:0x00] } 23DC 60 PUSH1 0x00 23DE 80 DUP1 23DF FD *REVERT // Stack delta = +0 // Outputs[1] { @23DF revert(memory[0x00:0x00]); } // Block terminates label_23E0: // Incoming jump from 0x23DB, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @23E5 stack[-9] // @23E6 stack[-2] // @23E7 stack[-8] // } 23E0 5B JUMPDEST 23E1 50 POP 23E2 61 PUSH2 0x23ed 23E5 88 DUP9 23E6 82 DUP3 23E7 89 DUP10 23E8 01 ADD 23E9 61 PUSH2 0x2330 23EC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @23E2 stack[-1] = 0x23ed // @23E5 stack[0] = stack[-9] // @23E8 stack[1] = stack[-8] + stack[-2] // } // Block ends with unconditional jump to 0x2330 23ED 5B JUMPDEST 23EE 91 SWAP2 23EF 50 POP 23F0 50 POP 23F1 92 SWAP3 23F2 95 SWAP6 23F3 50 POP 23F4 92 SWAP3 23F5 95 SWAP6 23F6 90 SWAP1 23F7 93 SWAP4 23F8 50 POP 23F9 56 *JUMP label_23FA: // Incoming call from 0x0294, returns to 0x0295 // Inputs[2] // { // @2400 stack[-1] // @2401 stack[-2] // } 23FA 5B JUMPDEST 23FB 60 PUSH1 0x00 23FD 80 DUP1 23FE 60 PUSH1 0x40 2400 83 DUP4 2401 85 DUP6 2402 03 SUB 2403 12 SLT 2404 15 ISZERO 2405 61 PUSH2 0x240d 2408 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23FB stack[0] = 0x00 // @23FD stack[1] = 0x00 // } // Block ends with conditional jump to 0x240d, if !(stack[-2] - stack[-1] i< 0x40) label_2409: // Incoming jump from 0x2408, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @240C memory[0x00:0x00] } 2409 60 PUSH1 0x00 240B 80 DUP1 240C FD *REVERT // Stack delta = +0 // Outputs[1] { @240C revert(memory[0x00:0x00]); } // Block terminates label_240D: // Incoming jump from 0x2408, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @240E stack[-3] // @240F msg.data[stack[-3]:stack[-3] + 0x20] // } 240D 5B JUMPDEST 240E 82 DUP3 240F 35 CALLDATALOAD 2410 67 PUSH8 0xffffffffffffffff 2419 80 DUP1 241A 82 DUP3 241B 11 GT 241C 15 ISZERO 241D 61 PUSH2 0x2425 2420 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @240F stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2410 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2425, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2421: // Incoming jump from 0x2420, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2424 memory[0x00:0x00] } 2421 60 PUSH1 0x00 2423 80 DUP1 2424 FD *REVERT // Stack delta = +0 // Outputs[1] { @2424 revert(memory[0x00:0x00]); } // Block terminates label_2425: // Incoming jump from 0x2420, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2426 stack[-2] // @2427 stack[-5] // @242B stack[-6] // } 2425 5B JUMPDEST 2426 81 DUP2 2427 85 DUP6 2428 01 ADD 2429 91 SWAP2 242A 50 POP 242B 85 DUP6 242C 60 PUSH1 0x1f 242E 83 DUP4 242F 01 ADD 2430 12 SLT 2431 61 PUSH2 0x2439 2434 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2429 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x2439, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_2435: // Incoming jump from 0x2434, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @2438 memory[0x00:0x00] } 2435 60 PUSH1 0x00 2437 80 DUP1 2438 FD *REVERT // Stack delta = +0 // Outputs[1] { @2438 revert(memory[0x00:0x00]); } // Block terminates label_2439: // Incoming jump from 0x2434, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @243A stack[-2] // @243B msg.data[stack[-2]:stack[-2] + 0x20] // } 2439 5B JUMPDEST 243A 81 DUP2 243B 35 CALLDATALOAD 243C 60 PUSH1 0x20 243E 61 PUSH2 0x2446 2441 82 DUP3 2442 61 PUSH2 0x229b 2445 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @243B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @243C stack[1] = 0x20 // @243E stack[2] = 0x2446 // @2441 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x229b, returns to 0x2446 label_2446: // Incoming return from call to 0x229B at 0x2445 // Inputs[2] // { // @2449 memory[0x40:0x60] // @244D stack[-1] // } 2446 5B JUMPDEST 2447 60 PUSH1 0x40 2449 51 MLOAD 244A 61 PUSH2 0x2453 244D 82 DUP3 244E 82 DUP3 244F 61 PUSH2 0x215c 2452 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2449 stack[0] = memory[0x40:0x60] // @244A stack[1] = 0x2453 // @244D stack[2] = stack[-1] // @244E stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x215c, returns to 0x2453 label_2453: // Incoming return from call to 0x215C at 0x2452 // Inputs[6] // { // @2454 stack[-4] // @2455 stack[-1] // @245D stack[-6] // @245F stack[-3] // @2465 stack[-2] // @2467 stack[-10] // } 2453 5B JUMPDEST 2454 83 DUP4 2455 81 DUP2 2456 52 MSTORE 2457 60 PUSH1 0x05 2459 93 SWAP4 245A 90 SWAP1 245B 93 SWAP4 245C 1B SHL 245D 85 DUP6 245E 01 ADD 245F 82 DUP3 2460 01 ADD 2461 92 SWAP3 2462 82 DUP3 2463 81 DUP2 2464 01 ADD 2465 91 SWAP2 2466 50 POP 2467 89 DUP10 2468 84 DUP5 2469 11 GT 246A 15 ISZERO 246B 61 PUSH2 0x2473 246E 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2456 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @2461 stack[-1] = stack[-1] // @2461 stack[-4] = stack[-3] + stack[-6] + (stack[-4] << 0x05) // @2465 stack[-2] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2473, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-10]) label_246F: // Incoming jump from 0x246E, if not !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-10]) // Inputs[1] { @2472 memory[0x00:0x00] } 246F 60 PUSH1 0x00 2471 80 DUP1 2472 FD *REVERT // Stack delta = +0 // Outputs[1] { @2472 revert(memory[0x00:0x00]); } // Block terminates label_2473: // Incoming jump from 0x246E, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-10]) // Inputs[4] // { // @2474 stack[-1] // @2474 stack[-6] // @2475 stack[-3] // @2479 stack[-4] // } 2473 5B JUMPDEST 2474 94 SWAP5 2475 82 DUP3 2476 01 ADD 2477 94 SWAP5 2478 5B JUMPDEST 2479 83 DUP4 247A 86 DUP7 247B 10 LT 247C 15 ISZERO 247D 61 PUSH2 0x2498 2480 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2477 stack[-1] = stack[-1] // @2477 stack[-6] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x2498, if !(stack[-3] + stack[-6] < stack[-4]) label_2481: // Incoming jump from 0x2480, if not !(stack[-3] + stack[-6] < stack[-4]) // Incoming jump from 0x2480, if not !(stack[-6] < stack[-4]) // Inputs[1] { @2484 stack[-6] } 2481 61 PUSH2 0x2489 2484 86 DUP7 2485 61 PUSH2 0x2095 2488 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2481 stack[0] = 0x2489 // @2484 stack[1] = stack[-6] // } // Block ends with call to 0x2095, returns to 0x2489 label_2489: // Incoming return from call to 0x2095 at 0x2488 // Inputs[5] // { // @248A stack[-3] // @248B stack[-1] // @248C stack[-2] // @248C stack[-7] // @248D stack[-4] // } 2489 5B JUMPDEST 248A 82 DUP3 248B 52 MSTORE 248C 94 SWAP5 248D 82 DUP3 248E 01 ADD 248F 94 SWAP5 2490 90 SWAP1 2491 82 DUP3 2492 01 ADD 2493 90 SWAP1 2494 61 PUSH2 0x2478 2497 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @248B memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @248F stack[-7] = stack[-4] + stack[-7] // @2493 stack[-2] = stack[-2] // @2493 stack[-3] = stack[-4] + stack[-3] // } // Block ends with unconditional jump to 0x2478 label_2498: // Incoming jump from 0x2480, if !(stack[-3] + stack[-6] < stack[-4]) // Incoming jump from 0x2480, if !(stack[-6] < stack[-4]) // Inputs[7] // { // @2499 stack[-8] // @2499 stack[-1] // @249C stack[-9] // @249D stack[-3] // @249E msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] // @249F stack[-6] // @24A2 stack[-5] // } 2498 5B JUMPDEST 2499 96 SWAP7 249A 50 POP 249B 50 POP 249C 86 DUP7 249D 01 ADD 249E 35 CALLDATALOAD 249F 92 SWAP3 24A0 50 POP 24A1 50 POP 24A2 80 DUP1 24A3 82 DUP3 24A4 11 GT 24A5 15 ISZERO 24A6 61 PUSH2 0x24ae 24A9 57 *JUMPI // Stack delta = -4 // Outputs[2] // { // @2499 stack[-8] = stack[-1] // @249F stack[-6] = msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x24ae, if !(msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] > stack[-5]) label_24AA: // Incoming jump from 0x24A9, if not !(msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] > stack[-5]) // Inputs[1] { @24AD memory[0x00:0x00] } 24AA 60 PUSH1 0x00 24AC 80 DUP1 24AD FD *REVERT // Stack delta = +0 // Outputs[1] { @24AD revert(memory[0x00:0x00]); } // Block terminates label_24AE: // Incoming jump from 0x24A9, if !(msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] > stack[-5]) // Inputs[3] // { // @24B3 stack[-6] // @24B4 stack[-2] // @24B5 stack[-5] // } 24AE 5B JUMPDEST 24AF 50 POP 24B0 61 PUSH2 0x24bb 24B3 85 DUP6 24B4 82 DUP3 24B5 86 DUP7 24B6 01 ADD 24B7 61 PUSH2 0x22bf 24BA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @24B0 stack[-1] = 0x24bb // @24B3 stack[0] = stack[-6] // @24B6 stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x22bf, returns to 0x24BB label_24BB: // Incoming return from call to 0x22BF at 0x24BA // Inputs[6] // { // @24BC stack[-3] // @24BC stack[-1] // @24BF stack[-6] // @24C1 stack[-7] // @24C1 stack[-4] // @24C2 stack[-5] // } 24BB 5B JUMPDEST 24BC 91 SWAP2 24BD 50 POP 24BE 50 POP 24BF 92 SWAP3 24C0 50 POP 24C1 92 SWAP3 24C2 90 SWAP1 24C3 50 POP 24C4 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @24BF stack[-6] = stack[-1] // @24C1 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_24C5: // Incoming call from 0x2803, returns to 0x2804 // Incoming call from 0x2512, returns to 0x2126 // Incoming call from 0x27BC, returns to 0x27BD // Incoming call from 0x27CE, returns to 0x27CF // Incoming call from 0x2815, returns to 0x2816 // Inputs[3] // { // @24C8 stack[-1] // @24C9 memory[stack[-1]:stack[-1] + 0x20] // @24CB stack[-2] // } 24C5 5B JUMPDEST 24C6 60 PUSH1 0x00 24C8 81 DUP2 24C9 51 MLOAD 24CA 80 DUP1 24CB 84 DUP5 24CC 52 MSTORE 24CD 60 PUSH1 0x20 24CF 80 DUP1 24D0 85 DUP6 24D1 01 ADD 24D2 94 SWAP5 24D3 50 POP 24D4 80 DUP1 24D5 84 DUP5 24D6 01 ADD 24D7 60 PUSH1 0x00 24D9 5B JUMPDEST 24DA 83 DUP4 24DB 81 DUP2 24DC 10 LT 24DD 15 ISZERO 24DE 61 PUSH2 0x24f5 24E1 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @24C6 stack[0] = 0x00 // @24C9 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @24CC memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @24CD stack[2] = 0x20 // @24D2 stack[-2] = stack[-2] + 0x20 // @24D6 stack[3] = stack[-1] + 0x20 // @24D7 stack[4] = 0x00 // } // Block ends with conditional jump to 0x24f5, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_24E2: // Incoming jump from 0x24E1, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x24E1, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @24E2 stack[-2] // @24E3 memory[stack[-2]:stack[-2] + 0x20] // @24E4 stack[-7] // @24E6 stack[-1] // @24E7 stack[-3] // } 24E2 81 DUP2 24E3 51 MLOAD 24E4 87 DUP8 24E5 52 MSTORE 24E6 95 SWAP6 24E7 82 DUP3 24E8 01 ADD 24E9 95 SWAP6 24EA 90 SWAP1 24EB 82 DUP3 24EC 01 ADD 24ED 90 SWAP1 24EE 60 PUSH1 0x01 24F0 01 ADD 24F1 61 PUSH2 0x24d9 24F4 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @24E5 memory[stack[-7]:stack[-7] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @24E9 stack[-7] = stack[-3] + stack[-7] // @24ED stack[-2] = stack[-3] + stack[-2] // @24F0 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x24d9 label_24F5: // Incoming jump from 0x24E1, if !(stack[-1] < stack[-4]) // Incoming jump from 0x24E1, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @24F7 stack[-7] // @24F7 stack[-2] // @24F8 stack[-8] // } 24F5 5B JUMPDEST 24F6 50 POP 24F7 94 SWAP5 24F8 95 SWAP6 24F9 94 SWAP5 24FA 50 POP 24FB 50 POP 24FC 50 POP 24FD 50 POP 24FE 50 POP 24FF 56 *JUMP // Stack delta = -7 // Outputs[1] { @24F8 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_2500: // Incoming jump from 0x02A6 // Inputs[2] // { // @2503 stack[-1] // @250E stack[-2] // } 2500 5B JUMPDEST 2501 60 PUSH1 0x20 2503 81 DUP2 2504 52 MSTORE 2505 60 PUSH1 0x00 2507 61 PUSH2 0x2126 250A 60 PUSH1 0x20 250C 83 DUP4 250D 01 ADD 250E 84 DUP5 250F 61 PUSH2 0x24c5 2512 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2504 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2505 stack[0] = 0x00 // @2507 stack[1] = 0x2126 // @250D stack[2] = stack[-1] + 0x20 // @250E stack[3] = stack[-2] // } // Block ends with call to 0x24c5, returns to 0x2126 label_2513: // Incoming call from 0x030E, returns to 0x030F // Incoming call from 0x02B4, returns to 0x02B5 // Inputs[2] // { // @251B stack[-1] // @251C stack[-2] // } 2513 5B JUMPDEST 2514 60 PUSH1 0x00 2516 80 DUP1 2517 60 PUSH1 0x00 2519 60 PUSH1 0x60 251B 84 DUP5 251C 86 DUP7 251D 03 SUB 251E 12 SLT 251F 15 ISZERO 2520 61 PUSH2 0x2528 2523 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2514 stack[0] = 0x00 // @2516 stack[1] = 0x00 // @2517 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2528, if !(stack[-2] - stack[-1] i< 0x60) label_2524: // Incoming jump from 0x2523, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2527 memory[0x00:0x00] } 2524 60 PUSH1 0x00 2526 80 DUP1 2527 FD *REVERT // Stack delta = +0 // Outputs[1] { @2527 revert(memory[0x00:0x00]); } // Block terminates label_2528: // Incoming jump from 0x2523, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @252C stack[-4] } 2528 5B JUMPDEST 2529 61 PUSH2 0x2531 252C 84 DUP5 252D 61 PUSH2 0x2095 2530 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2529 stack[0] = 0x2531 // @252C stack[1] = stack[-4] // } // Block ends with call to 0x2095, returns to 0x2531 label_2531: // Incoming return from call to 0x2095 at 0x2530 // Inputs[4] // { // @2532 stack[-1] // @2532 stack[-4] // @2536 stack[-5] // @2538 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 2531 5B JUMPDEST 2532 92 SWAP3 2533 50 POP 2534 60 PUSH1 0x20 2536 84 DUP5 2537 01 ADD 2538 35 CALLDATALOAD 2539 67 PUSH8 0xffffffffffffffff 2542 80 DUP1 2543 82 DUP3 2544 11 GT 2545 15 ISZERO 2546 61 PUSH2 0x254e 2549 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2532 stack[-4] = stack[-1] // @2538 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2539 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x254e, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_254A: // Incoming jump from 0x2549, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @254D memory[0x00:0x00] } 254A 60 PUSH1 0x00 254C 80 DUP1 254D FD *REVERT // Stack delta = +0 // Outputs[1] { @254D revert(memory[0x00:0x00]); } // Block terminates label_254E: // Incoming jump from 0x2549, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2552 stack[-7] // @2553 stack[-2] // @2554 stack[-6] // } 254E 5B JUMPDEST 254F 61 PUSH2 0x255a 2552 87 DUP8 2553 83 DUP4 2554 88 DUP9 2555 01 ADD 2556 61 PUSH2 0x22bf 2559 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @254F stack[0] = 0x255a // @2552 stack[1] = stack[-7] // @2555 stack[2] = stack[-6] + stack[-2] // } // Block ends with call to 0x22bf, returns to 0x255A label_255A: // Incoming return from call to 0x22BF at 0x2559 // Inputs[6] // { // @255B stack[-5] // @255B stack[-1] // @255F stack[-7] // @2561 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2562 stack[-3] // @2564 stack[-2] // } 255A 5B JUMPDEST 255B 93 SWAP4 255C 50 POP 255D 60 PUSH1 0x40 255F 86 DUP7 2560 01 ADD 2561 35 CALLDATALOAD 2562 91 SWAP2 2563 50 POP 2564 80 DUP1 2565 82 DUP3 2566 11 GT 2567 15 ISZERO 2568 61 PUSH2 0x2570 256B 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @255B stack[-5] = stack[-1] // @2562 stack[-3] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x2570, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) label_256C: // Incoming jump from 0x256B, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) // Inputs[1] { @256F memory[0x00:0x00] } 256C 60 PUSH1 0x00 256E 80 DUP1 256F FD *REVERT // Stack delta = +0 // Outputs[1] { @256F revert(memory[0x00:0x00]); } // Block terminates label_2570: // Incoming jump from 0x256B, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) // Inputs[3] // { // @2575 stack[-7] // @2576 stack[-2] // @2577 stack[-6] // } 2570 5B JUMPDEST 2571 50 POP 2572 61 PUSH2 0x257d 2575 86 DUP7 2576 82 DUP3 2577 87 DUP8 2578 01 ADD 2579 61 PUSH2 0x22bf 257C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2572 stack[-1] = 0x257d // @2575 stack[0] = stack[-7] // @2578 stack[1] = stack[-6] + stack[-2] // } // Block ends with call to 0x22bf, returns to 0x257D label_257D: // Incoming return from call to 0x22BF at 0x257C // Inputs[7] // { // @257E stack[-1] // @257E stack[-3] // @2581 stack[-6] // @2583 stack[-7] // @2583 stack[-4] // @2585 stack[-5] // @2585 stack[-8] // } 257D 5B JUMPDEST 257E 91 SWAP2 257F 50 POP 2580 50 POP 2581 92 SWAP3 2582 50 POP 2583 92 SWAP3 2584 50 POP 2585 92 SWAP3 2586 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @2581 stack[-6] = stack[-1] // @2583 stack[-7] = stack[-4] // @2585 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_2587: // Incoming call from 0x0334, returns to 0x0335 // Incoming call from 0x03A9, returns to 0x03AA // Incoming call from 0x02EA, returns to 0x02EB // Incoming call from 0x0383, returns to 0x0384 // Inputs[2] // { // @258C stack[-1] // @258D stack[-2] // } 2587 5B JUMPDEST 2588 60 PUSH1 0x00 258A 60 PUSH1 0x20 258C 82 DUP3 258D 84 DUP5 258E 03 SUB 258F 12 SLT 2590 15 ISZERO 2591 61 PUSH2 0x2599 2594 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2588 stack[0] = 0x00 } // Block ends with conditional jump to 0x2599, if !(stack[-2] - stack[-1] i< 0x20) label_2595: // Incoming jump from 0x2594, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2598 memory[0x00:0x00] } 2595 60 PUSH1 0x00 2597 80 DUP1 2598 FD *REVERT // Stack delta = +0 // Outputs[1] { @2598 revert(memory[0x00:0x00]); } // Block terminates label_2599: // Incoming jump from 0x2594, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @259D stack[-2] } 2599 5B JUMPDEST 259A 61 PUSH2 0x2126 259D 82 DUP3 259E 61 PUSH2 0x2095 25A1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @259A stack[0] = 0x2126 // @259D stack[1] = stack[-2] // } // Block ends with call to 0x2095, returns to 0x2126 label_25A2: // Incoming call from 0x0321, returns to 0x0322 // Inputs[2] // { // @25A8 stack[-1] // @25A9 stack[-2] // } 25A2 5B JUMPDEST 25A3 60 PUSH1 0x00 25A5 80 DUP1 25A6 60 PUSH1 0x40 25A8 83 DUP4 25A9 85 DUP6 25AA 03 SUB 25AB 12 SLT 25AC 15 ISZERO 25AD 61 PUSH2 0x25b5 25B0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25A3 stack[0] = 0x00 // @25A5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x25b5, if !(stack[-2] - stack[-1] i< 0x40) label_25B1: // Incoming jump from 0x25B0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25B4 memory[0x00:0x00] } 25B1 60 PUSH1 0x00 25B3 80 DUP1 25B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @25B4 revert(memory[0x00:0x00]); } // Block terminates label_25B5: // Incoming jump from 0x25B0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25B9 stack[-3] } 25B5 5B JUMPDEST 25B6 61 PUSH2 0x25be 25B9 83 DUP4 25BA 61 PUSH2 0x2095 25BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @25B6 stack[0] = 0x25be // @25B9 stack[1] = stack[-3] // } // Block ends with call to 0x2095, returns to 0x25BE label_25BE: // Incoming return from call to 0x2095 at 0x25BD // Inputs[4] // { // @25BF stack[-1] // @25BF stack[-3] // @25C3 stack[-4] // @25C5 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 25BE 5B JUMPDEST 25BF 91 SWAP2 25C0 50 POP 25C1 60 PUSH1 0x20 25C3 83 DUP4 25C4 01 ADD 25C5 35 CALLDATALOAD 25C6 80 DUP1 25C7 15 ISZERO 25C8 15 ISZERO 25C9 81 DUP2 25CA 14 EQ 25CB 61 PUSH2 0x25d3 25CE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @25BF stack[-3] = stack[-1] // @25C5 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x25d3, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_25CF: // Incoming jump from 0x25CE, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @25D2 memory[0x00:0x00] } 25CF 60 PUSH1 0x00 25D1 80 DUP1 25D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @25D2 revert(memory[0x00:0x00]); } // Block terminates label_25D3: // Incoming jump from 0x25CE, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @25D4 stack[-1] // @25D5 stack[-2] // @25D8 stack[-5] // @25DA stack[-3] // @25DA stack[-6] // @25DB stack[-4] // } 25D3 5B JUMPDEST 25D4 80 DUP1 25D5 91 SWAP2 25D6 50 POP 25D7 50 POP 25D8 92 SWAP3 25D9 50 POP 25DA 92 SWAP3 25DB 90 SWAP1 25DC 50 POP 25DD 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @25D8 stack[-5] = stack[-1] // @25DA stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_25DE: // Incoming call from 0x0347, returns to 0x0348 // Inputs[2] // { // @25E4 stack[-1] // @25E5 stack[-2] // } 25DE 5B JUMPDEST 25DF 60 PUSH1 0x00 25E1 80 DUP1 25E2 60 PUSH1 0x40 25E4 83 DUP4 25E5 85 DUP6 25E6 03 SUB 25E7 12 SLT 25E8 15 ISZERO 25E9 61 PUSH2 0x25f1 25EC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25DF stack[0] = 0x00 // @25E1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x25f1, if !(stack[-2] - stack[-1] i< 0x40) label_25ED: // Incoming jump from 0x25EC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25F0 memory[0x00:0x00] } 25ED 60 PUSH1 0x00 25EF 80 DUP1 25F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @25F0 revert(memory[0x00:0x00]); } // Block terminates label_25F1: // Incoming jump from 0x25EC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25F5 stack[-3] } 25F1 5B JUMPDEST 25F2 61 PUSH2 0x25fa 25F5 83 DUP4 25F6 61 PUSH2 0x2095 25F9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @25F2 stack[0] = 0x25fa // @25F5 stack[1] = stack[-3] // } // Block ends with call to 0x2095, returns to 0x25FA label_25FA: // Incoming return from call to 0x2095 at 0x25F9 // Inputs[3] // { // @25FB stack[-3] // @25FB stack[-1] // @2602 stack[-4] // } 25FA 5B JUMPDEST 25FB 91 SWAP2 25FC 50 POP 25FD 61 PUSH2 0x2608 2600 60 PUSH1 0x20 2602 84 DUP5 2603 01 ADD 2604 61 PUSH2 0x2095 2607 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @25FB stack[-3] = stack[-1] // @25FD stack[-1] = 0x2608 // @2603 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x2095, returns to 0x2608 label_2608: // Incoming return from call to 0x2095 at 0x2607 // Inputs[6] // { // @2609 stack[-1] // @2609 stack[-2] // @260B stack[-5] // @260D stack[-3] // @260D stack[-6] // @260E stack[-4] // } 2608 5B JUMPDEST 2609 90 SWAP1 260A 50 POP 260B 92 SWAP3 260C 50 POP 260D 92 SWAP3 260E 90 SWAP1 260F 50 POP 2610 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @260B stack[-5] = stack[-1] // @260D stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2611: // Incoming jump from 0x0396 // Inputs[2] // { // @261C stack[-1] // @261D stack[-2] // } 2611 5B JUMPDEST 2612 60 PUSH1 0x00 2614 80 DUP1 2615 60 PUSH1 0x00 2617 80 DUP1 2618 60 PUSH1 0x00 261A 60 PUSH1 0xa0 261C 86 DUP7 261D 88 DUP9 261E 03 SUB 261F 12 SLT 2620 15 ISZERO 2621 61 PUSH2 0x2629 2624 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2612 stack[0] = 0x00 // @2614 stack[1] = 0x00 // @2615 stack[2] = 0x00 // @2617 stack[3] = 0x00 // @2618 stack[4] = 0x00 // } // Block ends with conditional jump to 0x2629, if !(stack[-2] - stack[-1] i< 0xa0) label_2625: // Incoming jump from 0x2624, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @2628 memory[0x00:0x00] } 2625 60 PUSH1 0x00 2627 80 DUP1 2628 FD *REVERT // Stack delta = +0 // Outputs[1] { @2628 revert(memory[0x00:0x00]); } // Block terminates label_2629: // Incoming jump from 0x2624, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @262D stack[-6] } 2629 5B JUMPDEST 262A 61 PUSH2 0x2632 262D 86 DUP7 262E 61 PUSH2 0x2095 2631 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @262A stack[0] = 0x2632 // @262D stack[1] = stack[-6] // } // Block ends with call to 0x2095, returns to 0x2632 label_2632: // Incoming return from call to 0x2095 at 0x2631 // Inputs[3] // { // @2633 stack[-1] // @2633 stack[-6] // @263A stack[-7] // } 2632 5B JUMPDEST 2633 94 SWAP5 2634 50 POP 2635 61 PUSH2 0x2640 2638 60 PUSH1 0x20 263A 87 DUP8 263B 01 ADD 263C 61 PUSH2 0x2095 263F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2633 stack[-6] = stack[-1] // @2635 stack[-1] = 0x2640 // @263B stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x2095, returns to 0x2640 label_2640: // Incoming return from call to 0x2095 at 0x263F // Inputs[8] // { // @2641 stack[-5] // @2641 stack[-1] // @2645 stack[-7] // @2647 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2648 stack[-4] // @264E msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @264F stack[-3] // @2655 msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 2640 5B JUMPDEST 2641 93 SWAP4 2642 50 POP 2643 60 PUSH1 0x40 2645 86 DUP7 2646 01 ADD 2647 35 CALLDATALOAD 2648 92 SWAP3 2649 50 POP 264A 60 PUSH1 0x60 264C 86 DUP7 264D 01 ADD 264E 35 CALLDATALOAD 264F 91 SWAP2 2650 50 POP 2651 60 PUSH1 0x80 2653 86 DUP7 2654 01 ADD 2655 35 CALLDATALOAD 2656 67 PUSH8 0xffffffffffffffff 265F 81 DUP2 2660 11 GT 2661 15 ISZERO 2662 61 PUSH2 0x266a 2665 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2641 stack[-5] = stack[-1] // @2648 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @264F stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @2655 stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x266a, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) label_2666: // Incoming jump from 0x2665, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2669 memory[0x00:0x00] } 2666 60 PUSH1 0x00 2668 80 DUP1 2669 FD *REVERT // Stack delta = +0 // Outputs[1] { @2669 revert(memory[0x00:0x00]); } // Block terminates label_266A: // Incoming jump from 0x2665, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @266E stack[-8] // @266F stack[-1] // @2670 stack[-7] // } 266A 5B JUMPDEST 266B 61 PUSH2 0x23ed 266E 88 DUP9 266F 82 DUP3 2670 89 DUP10 2671 01 ADD 2672 61 PUSH2 0x2330 2675 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @266B stack[0] = 0x23ed // @266E stack[1] = stack[-8] // @2671 stack[2] = stack[-7] + stack[-1] // } // Block ends with unconditional jump to 0x2330 label_2676: // Incoming call from 0x066C, returns to 0x066D // Incoming call from 0x0698, returns to 0x0699 // Incoming call from 0x11B9, returns to 0x11BA // Incoming call from 0x118D, returns to 0x118E // Incoming call from 0x2007, returns to 0x2008 // Inputs[1] { @2679 stack[-1] } 2676 5B JUMPDEST 2677 60 PUSH1 0x01 2679 81 DUP2 267A 81 DUP2 267B 1C SHR 267C 90 SWAP1 267D 82 DUP3 267E 16 AND 267F 80 DUP1 2680 61 PUSH2 0x268a 2683 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @267C stack[0] = stack[-1] >> 0x01 // @267E stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x268a, if stack[-1] & 0x01 label_2684: // Incoming jump from 0x2683, if not stack[-1] & 0x01 // Inputs[2] // { // @2686 stack[-2] // @268F stack[-1] // } 2684 60 PUSH1 0x7f 2686 82 DUP3 2687 16 AND 2688 91 SWAP2 2689 50 POP 268A 5B JUMPDEST 268B 60 PUSH1 0x20 268D 82 DUP3 268E 10 LT 268F 81 DUP2 2690 14 EQ 2691 15 ISZERO 2692 61 PUSH2 0x26ab 2695 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2688 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x26ab, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2696: // Incoming jump from 0x2695, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2695, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @26AA memory[0x00:0x24] } 2696 63 PUSH4 0x4e487b71 269B 60 PUSH1 0xe0 269D 1B SHL 269E 60 PUSH1 0x00 26A0 52 MSTORE 26A1 60 PUSH1 0x22 26A3 60 PUSH1 0x04 26A5 52 MSTORE 26A6 60 PUSH1 0x24 26A8 60 PUSH1 0x00 26AA FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26A0 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @26A5 memory[0x04:0x24] = 0x22 // @26AA revert(memory[0x00:0x24]); // } // Block terminates label_26AB: // Incoming jump from 0x2695, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2695, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @26AD stack[-4] // @26AD stack[-2] // @26AE stack[-3] // } 26AB 5B JUMPDEST 26AC 50 POP 26AD 91 SWAP2 26AE 90 SWAP1 26AF 50 POP 26B0 56 *JUMP // Stack delta = -3 // Outputs[1] { @26AD stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_26B1: // Incoming call from 0x0712, returns to 0x0713 // Inputs[3] // { // @26B4 stack[-3] // @26B5 memory[stack[-3]:stack[-3] + 0x20] // @26BA stack[-1] // } 26B1 5B JUMPDEST 26B2 60 PUSH1 0x00 26B4 83 DUP4 26B5 51 MLOAD 26B6 61 PUSH2 0x26c3 26B9 81 DUP2 26BA 84 DUP5 26BB 60 PUSH1 0x20 26BD 88 DUP9 26BE 01 ADD 26BF 61 PUSH2 0x2230 26C2 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @26B2 stack[0] = 0x00 // @26B5 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @26B6 stack[2] = 0x26c3 // @26B9 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @26BA stack[4] = stack[-1] // @26BE stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x2230, returns to 0x26C3 label_26C3: // Incoming return from call to 0x2230 at 0x26C2 // Inputs[4] // { // @26C4 stack[-4] // @26C5 memory[stack[-4]:stack[-4] + 0x20] // @26C6 stack[-1] // @26C7 stack[-3] // } 26C3 5B JUMPDEST 26C4 83 DUP4 26C5 51 MLOAD 26C6 90 SWAP1 26C7 83 DUP4 26C8 01 ADD 26C9 90 SWAP1 26CA 61 PUSH2 0x26d7 26CD 81 DUP2 26CE 83 DUP4 26CF 60 PUSH1 0x20 26D1 88 DUP9 26D2 01 ADD 26D3 61 PUSH2 0x2230 26D6 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @26C9 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @26C9 stack[-1] = stack[-3] + stack[-1] // @26CA stack[1] = 0x26d7 // @26CD stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @26CE stack[3] = stack[-3] + stack[-1] // @26D2 stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x2230, returns to 0x26D7 label_26D7: // Incoming return from call to 0x2230 at 0x26D6 // Inputs[4] // { // @26D8 stack[-2] // @26D8 stack[-1] // @26D9 stack[-7] // @26DA stack[-6] // } 26D7 5B JUMPDEST 26D8 01 ADD 26D9 94 SWAP5 26DA 93 SWAP4 26DB 50 POP 26DC 50 POP 26DD 50 POP 26DE 50 POP 26DF 56 *JUMP // Stack delta = -6 // Outputs[1] { @26D9 stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] label_26E0: // Incoming jump from 0x093F // Incoming jump from 0x16E4 // Incoming jump from 0x0906 // Incoming jump from 0x0BA0 // Incoming jump from 0x0F40 // Incoming jump from 0x0920 // Incoming jump from 0x1702 // Incoming jump from 0x19B6 // Incoming jump from 0x1999 // Incoming jump from 0x0F01 // Incoming jump from 0x0F6C // Incoming jump from 0x1303 // Inputs[1] { @26F5 memory[0x00:0x24] } 26E0 5B JUMPDEST 26E1 63 PUSH4 0x4e487b71 26E6 60 PUSH1 0xe0 26E8 1B SHL 26E9 60 PUSH1 0x00 26EB 52 MSTORE 26EC 60 PUSH1 0x32 26EE 60 PUSH1 0x04 26F0 52 MSTORE 26F1 60 PUSH1 0x24 26F3 60 PUSH1 0x00 26F5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26EB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @26F0 memory[0x04:0x24] = 0x32 // @26F5 revert(memory[0x00:0x24]); // } // Block terminates label_26F6: // Incoming jump from 0x27A4 // Incoming jump from 0x2738 // Incoming jump from 0x271F // Inputs[1] { @270B memory[0x00:0x24] } 26F6 5B JUMPDEST 26F7 63 PUSH4 0x4e487b71 26FC 60 PUSH1 0xe0 26FE 1B SHL 26FF 60 PUSH1 0x00 2701 52 MSTORE 2702 60 PUSH1 0x11 2704 60 PUSH1 0x04 2706 52 MSTORE 2707 60 PUSH1 0x24 2709 60 PUSH1 0x00 270B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2701 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2706 memory[0x04:0x24] = 0x11 // @270B revert(memory[0x00:0x24]); // } // Block terminates label_270C: // Incoming call from 0x0FE5, returns to 0x0FE6 // Incoming call from 0x1A0E, returns to 0x1A0F // Incoming call from 0x1266, returns to 0x1267 // Incoming call from 0x0953, returns to 0x0954 // Incoming call from 0x0BCE, returns to 0x0BCF // Incoming call from 0x17D6, returns to 0x17D7 // Inputs[1] { @2712 stack[-1] } 270C 5B JUMPDEST 270D 60 PUSH1 0x00 270F 60 PUSH1 0x00 2711 19 NOT 2712 82 DUP3 2713 14 EQ 2714 15 ISZERO 2715 61 PUSH2 0x2720 2718 57 *JUMPI // Stack delta = +1 // Outputs[1] { @270D stack[0] = 0x00 } // Block ends with conditional jump to 0x2720, if !(stack[-1] == ~0x00) label_2719: // Incoming jump from 0x2718, if not !(stack[-1] == ~0x00) 2719 61 PUSH2 0x2720 271C 61 PUSH2 0x26f6 271F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2719 stack[0] = 0x2720 } // Block ends with unconditional jump to 0x26f6 label_2720: // Incoming jump from 0x2718, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2724 stack[-2] // @2725 stack[-3] // } 2720 5B JUMPDEST 2721 50 POP 2722 60 PUSH1 0x01 2724 01 ADD 2725 90 SWAP1 2726 56 *JUMP // Stack delta = -2 // Outputs[1] { @2725 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2727: // Incoming call from 0x12D6, returns to 0x12D7 // Incoming call from 0x0F30, returns to 0x0F31 // Inputs[2] // { // @272A stack[-2] // @272B stack[-1] // } 2727 5B JUMPDEST 2728 60 PUSH1 0x00 272A 82 DUP3 272B 82 DUP3 272C 10 LT 272D 15 ISZERO 272E 61 PUSH2 0x2739 2731 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2728 stack[0] = 0x00 } // Block ends with conditional jump to 0x2739, if !(stack[-1] < stack[-2]) label_2732: // Incoming jump from 0x2731, if not !(stack[-1] < stack[-2]) 2732 61 PUSH2 0x2739 2735 61 PUSH2 0x26f6 2738 56 *JUMP // Stack delta = +1 // Outputs[1] { @2732 stack[0] = 0x2739 } // Block ends with unconditional jump to 0x26f6 label_2739: // Incoming jump from 0x2731, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @273B stack[-3] // @273B stack[-2] // @273C stack[-4] // } 2739 5B JUMPDEST 273A 50 POP 273B 03 SUB 273C 90 SWAP1 273D 56 *JUMP // Stack delta = -3 // Outputs[1] { @273C stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_273E: // Incoming jump from 0x0FAB // Inputs[1] { @2753 memory[0x00:0x24] } 273E 5B JUMPDEST 273F 63 PUSH4 0x4e487b71 2744 60 PUSH1 0xe0 2746 1B SHL 2747 60 PUSH1 0x00 2749 52 MSTORE 274A 60 PUSH1 0x31 274C 60 PUSH1 0x04 274E 52 MSTORE 274F 60 PUSH1 0x24 2751 60 PUSH1 0x00 2753 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2749 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @274E memory[0x04:0x24] = 0x31 // @2753 revert(memory[0x00:0x24]); // } // Block terminates label_2754: // Incoming jump from 0x2778 // Incoming jump from 0x278C // Inputs[1] { @2769 memory[0x00:0x24] } 2754 5B JUMPDEST 2755 63 PUSH4 0x4e487b71 275A 60 PUSH1 0xe0 275C 1B SHL 275D 60 PUSH1 0x00 275F 52 MSTORE 2760 60 PUSH1 0x12 2762 60 PUSH1 0x04 2764 52 MSTORE 2765 60 PUSH1 0x24 2767 60 PUSH1 0x00 2769 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @275F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2764 memory[0x04:0x24] = 0x12 // @2769 revert(memory[0x00:0x24]); // } // Block terminates label_276A: // Incoming call from 0x1275, returns to 0x1276 // Incoming call from 0x133D, returns to 0x133E // Inputs[1] { @276D stack[-2] } 276A 5B JUMPDEST 276B 60 PUSH1 0x00 276D 82 DUP3 276E 61 PUSH2 0x2779 2771 57 *JUMPI // Stack delta = +1 // Outputs[1] { @276B stack[0] = 0x00 } // Block ends with conditional jump to 0x2779, if stack[-2] label_2772: // Incoming jump from 0x2771, if not stack[-2] 2772 61 PUSH2 0x2779 2775 61 PUSH2 0x2754 2778 56 *JUMP // Stack delta = +1 // Outputs[1] { @2772 stack[0] = 0x2779 } // Block ends with unconditional jump to 0x2754 label_2779: // Incoming jump from 0x2771, if stack[-2] // Inputs[3] // { // @277B stack[-3] // @277B stack[-2] // @277C stack[-4] // } 2779 5B JUMPDEST 277A 50 POP 277B 04 DIV 277C 90 SWAP1 277D 56 *JUMP // Stack delta = -3 // Outputs[1] { @277C stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_277E: // Incoming call from 0x12E3, returns to 0x12E4 // Inputs[1] { @2781 stack[-2] } 277E 5B JUMPDEST 277F 60 PUSH1 0x00 2781 82 DUP3 2782 61 PUSH2 0x278d 2785 57 *JUMPI // Stack delta = +1 // Outputs[1] { @277F stack[0] = 0x00 } // Block ends with conditional jump to 0x278d, if stack[-2] label_2786: // Incoming jump from 0x2785, if not stack[-2] 2786 61 PUSH2 0x278d 2789 61 PUSH2 0x2754 278C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2786 stack[0] = 0x278d } // Block ends with unconditional jump to 0x2754 label_278D: // Incoming jump from 0x2785, if stack[-2] // Inputs[3] // { // @278F stack[-2] // @278F stack[-3] // @2790 stack[-4] // } 278D 5B JUMPDEST 278E 50 POP 278F 06 MOD 2790 90 SWAP1 2791 56 *JUMP // Stack delta = -3 // Outputs[1] { @2790 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_2792: // Incoming call from 0x19FE, returns to 0x19FF // Incoming call from 0x12EE, returns to 0x12EF // Inputs[2] // { // @2795 stack[-2] // @2797 stack[-1] // } 2792 5B JUMPDEST 2793 60 PUSH1 0x00 2795 82 DUP3 2796 19 NOT 2797 82 DUP3 2798 11 GT 2799 15 ISZERO 279A 61 PUSH2 0x27a5 279D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2793 stack[0] = 0x00 } // Block ends with conditional jump to 0x27a5, if !(stack[-1] > ~stack[-2]) label_279E: // Incoming jump from 0x279D, if not !(stack[-1] > ~stack[-2]) 279E 61 PUSH2 0x27a5 27A1 61 PUSH2 0x26f6 27A4 56 *JUMP // Stack delta = +1 // Outputs[1] { @279E stack[0] = 0x27a5 } // Block ends with unconditional jump to 0x26f6 label_27A5: // Incoming jump from 0x279D, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @27A7 stack[-2] // @27A7 stack[-3] // @27A8 stack[-4] // } 27A5 5B JUMPDEST 27A6 50 POP 27A7 01 ADD 27A8 90 SWAP1 27A9 56 *JUMP // Stack delta = -3 // Outputs[1] { @27A8 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_27AA: // Incoming call from 0x182F, returns to 0x1830 // Incoming call from 0x1A67, returns to 0x1A68 // Inputs[2] // { // @27AD stack[-1] // @27B8 stack[-3] // } 27AA 5B JUMPDEST 27AB 60 PUSH1 0x40 27AD 81 DUP2 27AE 52 MSTORE 27AF 60 PUSH1 0x00 27B1 61 PUSH2 0x27bd 27B4 60 PUSH1 0x40 27B6 83 DUP4 27B7 01 ADD 27B8 85 DUP6 27B9 61 PUSH2 0x24c5 27BC 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @27AE memory[stack[-1]:stack[-1] + 0x20] = 0x40 // @27AF stack[0] = 0x00 // @27B1 stack[1] = 0x27bd // @27B7 stack[2] = stack[-1] + 0x40 // @27B8 stack[3] = stack[-3] // } // Block ends with call to 0x24c5, returns to 0x27BD label_27BD: // Incoming return from call to 0x24C5 at 0x27BC // Inputs[3] // { // @27BE stack[-3] // @27BF stack[-1] // @27CA stack[-4] // } 27BD 5B JUMPDEST 27BE 82 DUP3 27BF 81 DUP2 27C0 03 SUB 27C1 60 PUSH1 0x20 27C3 84 DUP5 27C4 01 ADD 27C5 52 MSTORE 27C6 61 PUSH2 0x27cf 27C9 81 DUP2 27CA 85 DUP6 27CB 61 PUSH2 0x24c5 27CE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @27C5 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] - stack[-3] // @27C6 stack[0] = 0x27cf // @27C9 stack[1] = stack[-1] // @27CA stack[2] = stack[-4] // } // Block ends with call to 0x24c5, returns to 0x27CF label_27CF: // Incoming return from call to 0x24C5 at 0x27CE // Inputs[3] // { // @27D0 stack[-1] // @27D0 stack[-7] // @27D1 stack[-6] // } 27CF 5B JUMPDEST 27D0 95 SWAP6 27D1 94 SWAP5 27D2 50 POP 27D3 50 POP 27D4 50 POP 27D5 50 POP 27D6 50 POP 27D7 56 *JUMP // Stack delta = -6 // Outputs[1] { @27D0 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_27D8: // Incoming call from 0x1CAD, returns to 0x1CAE // Inputs[4] // { // @27E4 stack[-6] // @27E6 stack[-1] // @27E9 stack[-5] // @27FF stack[-4] // } 27D8 5B JUMPDEST 27D9 60 PUSH1 0x00 27DB 60 PUSH1 0x01 27DD 60 PUSH1 0x01 27DF 60 PUSH1 0xa0 27E1 1B SHL 27E2 03 SUB 27E3 80 DUP1 27E4 88 DUP9 27E5 16 AND 27E6 83 DUP4 27E7 52 MSTORE 27E8 80 DUP1 27E9 87 DUP8 27EA 16 AND 27EB 60 PUSH1 0x20 27ED 84 DUP5 27EE 01 ADD 27EF 52 MSTORE 27F0 50 POP 27F1 60 PUSH1 0xa0 27F3 60 PUSH1 0x40 27F5 83 DUP4 27F6 01 ADD 27F7 52 MSTORE 27F8 61 PUSH2 0x2804 27FB 60 PUSH1 0xa0 27FD 83 DUP4 27FE 01 ADD 27FF 86 DUP7 2800 61 PUSH2 0x24c5 2803 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @27D9 stack[0] = 0x00 // @27E7 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @27EF memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @27F7 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0xa0 // @27F8 stack[1] = 0x2804 // @27FE stack[2] = stack[-1] + 0xa0 // @27FF stack[3] = stack[-4] // } // Block ends with call to 0x24c5, returns to 0x2804 label_2804: // Incoming return from call to 0x24C5 at 0x2803 // Inputs[3] // { // @2805 stack[-3] // @2806 stack[-1] // @2811 stack[-5] // } 2804 5B JUMPDEST 2805 82 DUP3 2806 81 DUP2 2807 03 SUB 2808 60 PUSH1 0x60 280A 84 DUP5 280B 01 ADD 280C 52 MSTORE 280D 61 PUSH2 0x2816 2810 81 DUP2 2811 86 DUP7 2812 61 PUSH2 0x24c5 2815 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @280C memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] = stack[-1] - stack[-3] // @280D stack[0] = 0x2816 // @2810 stack[1] = stack[-1] // @2811 stack[2] = stack[-5] // } // Block ends with call to 0x24c5, returns to 0x2816 label_2816: // Incoming return from call to 0x24C5 at 0x2815 // Inputs[4] // { // @2817 stack[-1] // @2817 stack[-2] // @2819 stack[-4] // @2825 stack[-5] // } 2816 5B JUMPDEST 2817 90 SWAP1 2818 50 POP 2819 82 DUP3 281A 81 DUP2 281B 03 SUB 281C 60 PUSH1 0x80 281E 84 DUP5 281F 01 ADD 2820 52 MSTORE 2821 61 PUSH2 0x282a 2824 81 DUP2 2825 85 DUP6 2826 61 PUSH2 0x225c 2829 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2817 stack[-2] = stack[-1] // @2820 memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] = stack[-1] - stack[-4] // @2821 stack[-1] = 0x282a // @2824 stack[0] = stack[-1] // @2825 stack[1] = stack[-5] // } // Block ends with call to 0x225c, returns to 0x282A label_282A: // Incoming return from call to 0x225C at 0x2829 // Inputs[3] // { // @282B stack[-10] // @282B stack[-1] // @282C stack[-9] // } 282A 5B JUMPDEST 282B 98 SWAP9 282C 97 SWAP8 282D 50 POP 282E 50 POP 282F 50 POP 2830 50 POP 2831 50 POP 2832 50 POP 2833 50 POP 2834 50 POP 2835 56 *JUMP // Stack delta = -9 // Outputs[1] { @282B stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_2836: // Incoming jump from 0x1CE5 // Inputs[2] // { // @283B stack[-1] // @283C stack[-2] // } 2836 5B JUMPDEST 2837 60 PUSH1 0x00 2839 60 PUSH1 0x20 283B 82 DUP3 283C 84 DUP5 283D 03 SUB 283E 12 SLT 283F 15 ISZERO 2840 61 PUSH2 0x2848 2843 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2837 stack[0] = 0x00 } // Block ends with conditional jump to 0x2848, if !(stack[-2] - stack[-1] i< 0x20) label_2844: // Incoming jump from 0x2843, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2847 memory[0x00:0x00] } 2844 60 PUSH1 0x00 2846 80 DUP1 2847 FD *REVERT // Stack delta = +0 // Outputs[1] { @2847 revert(memory[0x00:0x00]); } // Block terminates label_2848: // Incoming jump from 0x2843, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2849 stack[-2] // @284A memory[stack[-2]:stack[-2] + 0x20] // } 2848 5B JUMPDEST 2849 81 DUP2 284A 51 MLOAD 284B 61 PUSH2 0x2126 284E 81 DUP2 284F 61 PUSH2 0x20db 2852 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @284A stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @284B stack[1] = 0x2126 // @284E stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x20db, returns to 0x2126 label_2853: // Incoming call from 0x1CF4, returns to 0x1CF5 // Inputs[1] { @2858 returndata.length } 2853 5B JUMPDEST 2854 60 PUSH1 0x00 2856 60 PUSH1 0x03 2858 3D RETURNDATASIZE 2859 11 GT 285A 15 ISZERO 285B 61 PUSH2 0x286c 285E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2854 stack[0] = 0x00 } // Block ends with conditional jump to 0x286c, if !(returndata.length > 0x03) label_285F: // Incoming jump from 0x285E, if not !(returndata.length > 0x03) // Inputs[3] // { // @2864 returndata[0x00:0x04] // @2868 memory[0x00:0x20] // @286D stack[-2] // } 285F 60 PUSH1 0x04 2861 60 PUSH1 0x00 2863 80 DUP1 2864 3E RETURNDATACOPY 2865 50 POP 2866 60 PUSH1 0x00 2868 51 MLOAD 2869 60 PUSH1 0xe0 286B 1C SHR 286C 5B JUMPDEST 286D 90 SWAP1 286E 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2864 memory[0x00:0x04] = returndata[0x00:0x04] // @286D stack[-2] = memory[0x00:0x20] >> 0xe0 // } // Block ends with unconditional jump to stack[-2] label_286F: // Incoming call from 0x1D09, returns to 0x1D0A // Inputs[1] { @2874 returndata.length } 286F 5B JUMPDEST 2870 60 PUSH1 0x00 2872 60 PUSH1 0x44 2874 3D RETURNDATASIZE 2875 10 LT 2876 15 ISZERO 2877 61 PUSH2 0x287d 287A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2870 stack[0] = 0x00 } // Block ends with conditional jump to 0x287d, if !(returndata.length < 0x44) label_287B: // Incoming jump from 0x287A, if not !(returndata.length < 0x44) // Inputs[2] // { // @287B stack[-2] // @287B stack[-1] // } 287B 90 SWAP1 287C 56 *JUMP // Stack delta = -1 // Outputs[1] { @287B stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_287D: // Incoming jump from 0x287A, if !(returndata.length < 0x44) // Inputs[5] // { // @2880 memory[0x40:0x60] // @28A3 returndata.length // @28A8 returndata[0x04:0x04 + returndata.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc] // @28AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @28AB returndata.length // } 287D 5B JUMPDEST 287E 60 PUSH1 0x40 2880 51 MLOAD 2881 7F PUSH32 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc 28A2 80 DUP1 28A3 3D RETURNDATASIZE 28A4 01 ADD 28A5 60 PUSH1 0x04 28A7 83 DUP4 28A8 3E RETURNDATACOPY 28A9 81 DUP2 28AA 51 MLOAD 28AB 3D RETURNDATASIZE 28AC 67 PUSH8 0xffffffffffffffff 28B5 81 DUP2 28B6 60 PUSH1 0x24 28B8 84 DUP5 28B9 01 ADD 28BA 11 GT 28BB 81 DUP2 28BC 84 DUP5 28BD 11 GT 28BE 17 OR 28BF 15 ISZERO 28C0 61 PUSH2 0x28cb 28C3 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @2880 stack[0] = memory[0x40:0x60] // @2881 stack[1] = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc // @28A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc] = returndata[0x04:0x04 + returndata.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc] // @28AA stack[2] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @28AB stack[3] = returndata.length // @28AC stack[4] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x28cb, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) label_28C4: // Incoming jump from 0x28C3, if not !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[2] // { // @28C9 stack[-6] // @28C9 stack[-7] // } 28C4 50 POP 28C5 50 POP 28C6 50 POP 28C7 50 POP 28C8 50 POP 28C9 90 SWAP1 28CA 56 *JUMP // Stack delta = -6 // Outputs[1] { @28C9 stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_28CB: // Incoming jump from 0x28C3, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[5] // { // @28CC stack[-3] // @28CD stack[-5] // @28CF stack[-2] // @28D2 memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // @28D3 stack[-1] // } 28CB 5B JUMPDEST 28CC 82 DUP3 28CD 85 DUP6 28CE 01 ADD 28CF 91 SWAP2 28D0 50 POP 28D1 81 DUP2 28D2 51 MLOAD 28D3 81 DUP2 28D4 81 DUP2 28D5 11 GT 28D6 15 ISZERO 28D7 61 PUSH2 0x28e3 28DA 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @28CF stack[-2] = stack[-5] + stack[-3] // @28D2 stack[0] = memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x28e3, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) label_28DB: // Incoming jump from 0x28DA, if not !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[2] // { // @28E1 stack[-7] // @28E1 stack[-8] // } 28DB 50 POP 28DC 50 POP 28DD 50 POP 28DE 50 POP 28DF 50 POP 28E0 50 POP 28E1 90 SWAP1 28E2 56 *JUMP // Stack delta = -7 // Outputs[1] { @28E1 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_28E3: // Incoming jump from 0x28DA, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[5] // { // @28E4 stack[-5] // @28E5 returndata.length // @28E6 stack[-6] // @28EB stack[-1] // @28EC stack[-3] // } 28E3 5B JUMPDEST 28E4 84 DUP5 28E5 3D RETURNDATASIZE 28E6 87 DUP8 28E7 01 ADD 28E8 01 ADD 28E9 60 PUSH1 0x20 28EB 82 DUP3 28EC 85 DUP6 28ED 01 ADD 28EE 01 ADD 28EF 11 GT 28F0 15 ISZERO 28F1 61 PUSH2 0x28fd 28F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x28fd, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) label_28F5: // Incoming jump from 0x28F4, if not !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[2] // { // @28FB stack[-8] // @28FB stack[-7] // } 28F5 50 POP 28F6 50 POP 28F7 50 POP 28F8 50 POP 28F9 50 POP 28FA 50 POP 28FB 90 SWAP1 28FC 56 *JUMP // Stack delta = -7 // Outputs[1] { @28FB stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_28FD: // Incoming jump from 0x28F4, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[3] // { // @2903 stack[-1] // @2904 stack[-4] // @2907 stack[-6] // } 28FD 5B JUMPDEST 28FE 61 PUSH2 0x290c 2901 60 PUSH1 0x20 2903 82 DUP3 2904 86 DUP7 2905 01 ADD 2906 01 ADD 2907 87 DUP8 2908 61 PUSH2 0x215c 290B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @28FE stack[0] = 0x290c // @2906 stack[1] = stack[-4] + stack[-1] + 0x20 // @2907 stack[2] = stack[-6] // } // Block ends with call to 0x215c, returns to 0x290C label_290C: // Incoming return from call to 0x215C at 0x290B // Inputs[4] // { // @290E stack[-2] // @290E stack[-3] // @290F stack[-8] // @2910 stack[-7] // } 290C 5B JUMPDEST 290D 50 POP 290E 90 SWAP1 290F 95 SWAP6 2910 94 SWAP5 2911 50 POP 2912 50 POP 2913 50 POP 2914 50 POP 2915 50 POP 2916 56 *JUMP // Stack delta = -7 // Outputs[1] { @290F stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] 2917 5B JUMPDEST 2918 60 PUSH1 0x00 291A 60 PUSH1 0x01 291C 60 PUSH1 0x01 291E 60 PUSH1 0xa0 2920 1B SHL 2921 03 SUB 2922 80 DUP1 2923 88 DUP9 2924 16 AND 2925 83 DUP4 2926 52 MSTORE 2927 80 DUP1 2928 87 DUP8 2929 16 AND 292A 60 PUSH1 0x20 292C 84 DUP5 292D 01 ADD 292E 52 MSTORE 292F 50 POP 2930 84 DUP5 2931 60 PUSH1 0x40 2933 83 DUP4 2934 01 ADD 2935 52 MSTORE 2936 83 DUP4 2937 60 PUSH1 0x60 2939 83 DUP4 293A 01 ADD 293B 52 MSTORE 293C 60 PUSH1 0xa0 293E 60 PUSH1 0x80 2940 83 DUP4 2941 01 ADD 2942 52 MSTORE 2943 61 PUSH2 0x294f 2946 60 PUSH1 0xa0 2948 83 DUP4 2949 01 ADD 294A 84 DUP5 294B 61 PUSH2 0x225c 294E 56 *JUMP 294F 5B JUMPDEST 2950 97 SWAP8 2951 96 SWAP7 2952 50 POP 2953 50 POP 2954 50 POP 2955 50 POP 2956 50 POP 2957 50 POP 2958 50 POP 2959 56 *JUMP 295A FE *ASSERT 295B A2 LOG2 295C 64 PUSH5 0x6970667358 2962 22 22 2963 12 SLT 2964 20 SHA3 2965 96 SWAP7 2966 54 SLOAD 2967 2B 2B 2968 78 PUSH25 0xe31e96d0d4dcc9a57bd97dbc594b9672b4739f557d9c0400dc 2982 22 22 2983 E1 E1 2984 D4 D4 2985 64 PUSH5 0x736f6c6343 298B 00 *STOP 298C 08 ADDMOD 298D 0C 0C 298E 00 *STOP 298F 33 CALLER