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 0x01d9 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01d9, 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 0x8456cb59 0026 11 GT 0027 61 PUSH2 0x0104 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0104, if 0x8456cb59 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x8456cb59 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xd547741f 0031 11 GT 0032 61 PUSH2 0x00a2 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a2, if 0xd547741f > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xd547741f > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe985e9c5 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xe985e9c5 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe985e9c5 0047 14 EQ 0048 61 PUSH2 0x03df 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03df, if 0xe985e9c5 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf242432a 0052 14 EQ 0053 61 PUSH2 0x041b 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041b, if 0xf242432a == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf242432a == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2aa3d43 005D 14 EQ 005E 61 PUSH2 0x042e 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042e, if 0xf2aa3d43 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf2aa3d43 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xfe6d8124 0068 14 EQ 0069 61 PUSH2 0x0441 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0441, if 0xfe6d8124 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xfe6d8124 == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x0040, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xd547741f 0078 14 EQ 0079 61 PUSH2 0x039e 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039e, if 0xd547741f == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xd547741f == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xe2e784d5 0083 14 EQ 0084 61 PUSH2 0x03b1 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b1, if 0xe2e784d5 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xe2e784d5 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xe7d3fe6b 008E 14 EQ 008F 61 PUSH2 0x03c4 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c4, if 0xe7d3fe6b == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xe7d3fe6b == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xe8a3d485 0099 14 EQ 009A 61 PUSH2 0x03d7 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d7, if 0xe8a3d485 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @00A1 memory[0x00:0x00] } 009E 60 PUSH1 0x00 00A0 80 DUP1 00A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A1 revert(memory[0x00:0x00]); } // Block terminates label_00A2: // Incoming jump from 0x0035, if 0xd547741f > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0x95d89b41 00A9 11 GT 00AA 61 PUSH2 0x00de 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00de, if 0x95d89b41 > stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x95d89b41 > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x95d89b41 00B4 14 EQ 00B5 61 PUSH2 0x0368 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0368, if 0x95d89b41 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0xa06d8fc7 00BF 14 EQ 00C0 61 PUSH2 0x0370 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0370, if 0xa06d8fc7 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xa06d8fc7 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xa217fddf 00CA 14 EQ 00CB 61 PUSH2 0x0383 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0383, if 0xa217fddf == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xa217fddf == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xa22cb465 00D5 14 EQ 00D6 61 PUSH2 0x038b 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038b, if 0xa22cb465 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00DD memory[0x00:0x00] } 00DA 60 PUSH1 0x00 00DC 80 DUP1 00DD FD *REVERT // Stack delta = +0 // Outputs[1] { @00DD revert(memory[0x00:0x00]); } // Block terminates label_00DE: // Incoming jump from 0x00AD, if 0x95d89b41 > stack[-1] // Inputs[1] { @00DF stack[-1] } 00DE 5B JUMPDEST 00DF 80 DUP1 00E0 63 PUSH4 0x8456cb59 00E5 14 EQ 00E6 61 PUSH2 0x033a 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033a, if 0x8456cb59 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x8456cb59 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x91d14854 00F0 14 EQ 00F1 61 PUSH2 0x0342 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0342, if 0x91d14854 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x91d14854 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x938e3d7b 00FB 14 EQ 00FC 61 PUSH2 0x0355 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0355, if 0x938e3d7b == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x938e3d7b == stack[-1] // Inputs[1] { @0103 memory[0x00:0x00] } 0100 60 PUSH1 0x00 0102 80 DUP1 0103 FD *REVERT // Stack delta = +0 // Outputs[1] { @0103 revert(memory[0x00:0x00]); } // Block terminates label_0104: // Incoming jump from 0x002A, if 0x8456cb59 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0105 stack[-1] } 0104 5B JUMPDEST 0105 80 DUP1 0106 63 PUSH4 0x2f2ff15d 010B 11 GT 010C 61 PUSH2 0x017c 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017c, if 0x2f2ff15d > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x2f2ff15d > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x3f4ba83a 0116 11 GT 0117 61 PUSH2 0x014b 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x014b, if 0x3f4ba83a > stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x3f4ba83a > stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x3f4ba83a 0121 14 EQ 0122 61 PUSH2 0x02f4 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f4, if 0x3f4ba83a == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x4e1273f4 012C 14 EQ 012D 61 PUSH2 0x02fc 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fc, if 0x4e1273f4 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x55f804b3 0137 14 EQ 0138 61 PUSH2 0x031c 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031c, if 0x55f804b3 == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x55f804b3 == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x5c975abb 0142 14 EQ 0143 61 PUSH2 0x032f 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032f, if 0x5c975abb == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x5c975abb == stack[-1] // Inputs[1] { @014A memory[0x00:0x00] } 0147 60 PUSH1 0x00 0149 80 DUP1 014A FD *REVERT // Stack delta = +0 // Outputs[1] { @014A revert(memory[0x00:0x00]); } // Block terminates label_014B: // Incoming jump from 0x011A, if 0x3f4ba83a > stack[-1] // Inputs[1] { @014C stack[-1] } 014B 5B JUMPDEST 014C 80 DUP1 014D 63 PUSH4 0x2f2ff15d 0152 14 EQ 0153 61 PUSH2 0x02a8 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a8, if 0x2f2ff15d == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x36568abe 015D 14 EQ 015E 61 PUSH2 0x02bb 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bb, if 0x36568abe == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x36568abe == stack[-1] // Inputs[1] { @0162 stack[-1] } 0162 80 DUP1 0163 63 PUSH4 0x3935bac6 0168 14 EQ 0169 61 PUSH2 0x02ce 016C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ce, if 0x3935bac6 == stack[-1] label_016D: // Incoming jump from 0x016C, if not 0x3935bac6 == stack[-1] // Inputs[1] { @016D stack[-1] } 016D 80 DUP1 016E 63 PUSH4 0x3adf80b4 0173 14 EQ 0174 61 PUSH2 0x02e1 0177 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e1, if 0x3adf80b4 == stack[-1] label_0178: // Incoming jump from 0x0177, if not 0x3adf80b4 == stack[-1] // Inputs[1] { @017B memory[0x00:0x00] } 0178 60 PUSH1 0x00 017A 80 DUP1 017B FD *REVERT // Stack delta = +0 // Outputs[1] { @017B revert(memory[0x00:0x00]); } // Block terminates label_017C: // Incoming jump from 0x010F, if 0x2f2ff15d > stack[-1] // Inputs[1] { @017D stack[-1] } 017C 5B JUMPDEST 017D 80 DUP1 017E 63 PUSH4 0x0e89341c 0183 11 GT 0184 61 PUSH2 0x01b8 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b8, if 0x0e89341c > stack[-1] label_0188: // Incoming jump from 0x0187, if not 0x0e89341c > stack[-1] // Inputs[1] { @0188 stack[-1] } 0188 80 DUP1 0189 63 PUSH4 0x0e89341c 018E 14 EQ 018F 61 PUSH2 0x023c 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023c, if 0x0e89341c == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x0e89341c == stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x248a9ca3 0199 14 EQ 019A 61 PUSH2 0x024f 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024f, if 0x248a9ca3 == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @019E stack[-1] } 019E 80 DUP1 019F 63 PUSH4 0x2a55205a 01A4 14 EQ 01A5 61 PUSH2 0x0272 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0272, if 0x2a55205a == stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x2a55205a == stack[-1] // Inputs[1] { @01A9 stack[-1] } 01A9 80 DUP1 01AA 63 PUSH4 0x2eb2c2d6 01AF 14 EQ 01B0 61 PUSH2 0x0293 01B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0293, if 0x2eb2c2d6 == stack[-1] label_01B4: // Incoming jump from 0x01B3, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @01B7 memory[0x00:0x00] } 01B4 60 PUSH1 0x00 01B6 80 DUP1 01B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B7 revert(memory[0x00:0x00]); } // Block terminates label_01B8: // Incoming jump from 0x0187, if 0x0e89341c > stack[-1] // Inputs[1] { @01B9 stack[-1] } 01B8 5B JUMPDEST 01B9 80 DUP1 01BA 62 PUSH3 0xfdd58e 01BE 14 EQ 01BF 61 PUSH2 0x01de 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01de, if 0xfdd58e == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0xfdd58e == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x01ffc9a7 01C9 14 EQ 01CA 61 PUSH2 0x0207 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0207, if 0x01ffc9a7 == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x06fdde03 01D4 14 EQ 01D5 61 PUSH2 0x0227 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0227, if 0x06fdde03 == stack[-1] label_01D9: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x01D8, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01DD memory[0x00:0x00] } 01D9 5B JUMPDEST 01DA 60 PUSH1 0x00 01DC 80 DUP1 01DD FD *REVERT // Stack delta = +0 // Outputs[1] { @01DD revert(memory[0x00:0x00]); } // Block terminates label_01DE: // Incoming jump from 0x01C2, if 0xfdd58e == stack[-1] // Inputs[1] { @01E5 msg.data.length } 01DE 5B JUMPDEST 01DF 61 PUSH2 0x01f1 01E2 61 PUSH2 0x01ec 01E5 36 CALLDATASIZE 01E6 60 PUSH1 0x04 01E8 61 PUSH2 0x172f 01EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01DF stack[0] = 0x01f1 // @01E2 stack[1] = 0x01ec // @01E5 stack[2] = msg.data.length // @01E6 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x172f 01EC 5B JUMPDEST 01ED 61 PUSH2 0x0456 01F0 56 *JUMP label_01F1: // Incoming jump from 0x038A // Incoming jump from 0x0455 // Inputs[2] // { // @01F4 memory[0x40:0x60] // @01F8 stack[-1] // } 01F1 5B JUMPDEST 01F2 60 PUSH1 0x40 01F4 51 MLOAD 01F5 61 PUSH2 0x01fe 01F8 91 SWAP2 01F9 90 SWAP1 01FA 61 PUSH2 0x1774 01FD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01F8 stack[-1] = 0x01fe // @01F9 stack[1] = memory[0x40:0x60] // @01F9 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1774 label_01FE: // Incoming return from call to 0x183A at 0x023B // Inputs[3] // { // @0201 memory[0x40:0x60] // @0203 stack[-1] // @0206 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01FE 5B JUMPDEST 01FF 60 PUSH1 0x40 0201 51 MLOAD 0202 80 DUP1 0203 91 SWAP2 0204 03 SUB 0205 90 SWAP1 0206 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0206 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0207: // Incoming jump from 0x01CD, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @020E msg.data.length } 0207 5B JUMPDEST 0208 61 PUSH2 0x021a 020B 61 PUSH2 0x0215 020E 36 CALLDATASIZE 020F 60 PUSH1 0x04 0211 61 PUSH2 0x179d 0214 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0208 stack[0] = 0x021a // @020B stack[1] = 0x0215 // @020E stack[2] = msg.data.length // @020F stack[3] = 0x04 // } // Block ends with unconditional jump to 0x179d 0215 5B JUMPDEST 0216 61 PUSH2 0x04b0 0219 56 *JUMP label_021A: // Incoming jump from 0x0339 // Inputs[2] // { // @021D memory[0x40:0x60] // @0221 stack[-1] // } 021A 5B JUMPDEST 021B 60 PUSH1 0x40 021D 51 MLOAD 021E 61 PUSH2 0x01fe 0221 91 SWAP2 0222 90 SWAP1 0223 61 PUSH2 0x17ce 0226 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0221 stack[-1] = 0x01fe // @0222 stack[1] = memory[0x40:0x60] // @0222 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x17ce label_0227: // Incoming jump from 0x01D8, if 0x06fdde03 == stack[-1] 0227 5B JUMPDEST 0228 61 PUSH2 0x022f 022B 61 PUSH2 0x04f0 022E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0228 stack[0] = 0x022f } // Block ends with call to 0x04f0, returns to 0x022F label_022F: // Incoming return from call to 0x0A55 at 0x03DE // Incoming return from call to 0x0990 at 0x036F // Incoming return from call to 0x04F0 at 0x022E // Inputs[2] // { // @0232 memory[0x40:0x60] // @0236 stack[-1] // } 022F 5B JUMPDEST 0230 60 PUSH1 0x40 0232 51 MLOAD 0233 61 PUSH2 0x01fe 0236 91 SWAP2 0237 90 SWAP1 0238 61 PUSH2 0x183a 023B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0236 stack[-1] = 0x01fe // @0237 stack[1] = memory[0x40:0x60] // @0237 stack[0] = stack[-1] // } // Block ends with call to 0x183a, returns to 0x01FE label_023C: // Incoming jump from 0x0192, if 0x0e89341c == stack[-1] // Inputs[1] { @0243 msg.data.length } 023C 5B JUMPDEST 023D 61 PUSH2 0x022f 0240 61 PUSH2 0x024a 0243 36 CALLDATASIZE 0244 60 PUSH1 0x04 0246 61 PUSH2 0x184b 0249 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023D stack[0] = 0x022f // @0240 stack[1] = 0x024a // @0243 stack[2] = msg.data.length // @0244 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x184b 024A 5B JUMPDEST 024B 61 PUSH2 0x057e 024E 56 *JUMP label_024F: // Incoming jump from 0x019D, if 0x248a9ca3 == stack[-1] // Inputs[1] { @0256 msg.data.length } 024F 5B JUMPDEST 0250 61 PUSH2 0x01f1 0253 61 PUSH2 0x025d 0256 36 CALLDATASIZE 0257 60 PUSH1 0x04 0259 61 PUSH2 0x184b 025C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0250 stack[0] = 0x01f1 // @0253 stack[1] = 0x025d // @0256 stack[2] = msg.data.length // @0257 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x184b 025D 5B JUMPDEST 025E 60 PUSH1 0x00 0260 90 SWAP1 0261 81 DUP2 0262 52 MSTORE 0263 60 PUSH1 0x03 0265 60 PUSH1 0x20 0267 52 MSTORE 0268 60 PUSH1 0x40 026A 90 SWAP1 026B 20 SHA3 026C 60 PUSH1 0x01 026E 01 ADD 026F 54 SLOAD 0270 90 SWAP1 0271 56 *JUMP label_0272: // Incoming jump from 0x01A8, if 0x2a55205a == stack[-1] // Inputs[1] { @0279 msg.data.length } 0272 5B JUMPDEST 0273 61 PUSH2 0x0285 0276 61 PUSH2 0x0280 0279 36 CALLDATASIZE 027A 60 PUSH1 0x04 027C 61 PUSH2 0x186c 027F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0273 stack[0] = 0x0285 // @0276 stack[1] = 0x0280 // @0279 stack[2] = msg.data.length // @027A stack[3] = 0x04 // } // Block ends with unconditional jump to 0x186c 0280 5B JUMPDEST 0281 61 PUSH2 0x06d9 0284 56 *JUMP 0285 5B JUMPDEST 0286 60 PUSH1 0x40 0288 51 MLOAD 0289 61 PUSH2 0x01fe 028C 92 SWAP3 028D 91 SWAP2 028E 90 SWAP1 028F 61 PUSH2 0x1897 0292 56 *JUMP label_0293: // Incoming jump from 0x01B3, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @029A msg.data.length } 0293 5B JUMPDEST 0294 61 PUSH2 0x02a6 0297 61 PUSH2 0x02a1 029A 36 CALLDATASIZE 029B 60 PUSH1 0x04 029D 61 PUSH2 0x1a45 02A0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0294 stack[0] = 0x02a6 // @0297 stack[1] = 0x02a1 // @029A stack[2] = msg.data.length // @029B stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1a45 02A1 5B JUMPDEST 02A2 61 PUSH2 0x070d 02A5 56 *JUMP 02A6 5B JUMPDEST 02A7 00 *STOP label_02A8: // Incoming jump from 0x0156, if 0x2f2ff15d == stack[-1] // Inputs[1] { @02AF msg.data.length } 02A8 5B JUMPDEST 02A9 61 PUSH2 0x02a6 02AC 61 PUSH2 0x02b6 02AF 36 CALLDATASIZE 02B0 60 PUSH1 0x04 02B2 61 PUSH2 0x1b0b 02B5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A9 stack[0] = 0x02a6 // @02AC stack[1] = 0x02b6 // @02AF stack[2] = msg.data.length // @02B0 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b0b 02B6 5B JUMPDEST 02B7 61 PUSH2 0x0759 02BA 56 *JUMP label_02BB: // Incoming jump from 0x0161, if 0x36568abe == stack[-1] // Inputs[1] { @02C2 msg.data.length } 02BB 5B JUMPDEST 02BC 61 PUSH2 0x02a6 02BF 61 PUSH2 0x02c9 02C2 36 CALLDATASIZE 02C3 60 PUSH1 0x04 02C5 61 PUSH2 0x1b0b 02C8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BC stack[0] = 0x02a6 // @02BF stack[1] = 0x02c9 // @02C2 stack[2] = msg.data.length // @02C3 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b0b 02C9 5B JUMPDEST 02CA 61 PUSH2 0x0783 02CD 56 *JUMP label_02CE: // Incoming jump from 0x016C, if 0x3935bac6 == stack[-1] // Inputs[1] { @02D5 msg.data.length } 02CE 5B JUMPDEST 02CF 61 PUSH2 0x02a6 02D2 61 PUSH2 0x02dc 02D5 36 CALLDATASIZE 02D6 60 PUSH1 0x04 02D8 61 PUSH2 0x1b3e 02DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02CF stack[0] = 0x02a6 // @02D2 stack[1] = 0x02dc // @02D5 stack[2] = msg.data.length // @02D6 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b3e 02DC 5B JUMPDEST 02DD 61 PUSH2 0x07b9 02E0 56 *JUMP label_02E1: // Incoming jump from 0x0177, if 0x3adf80b4 == stack[-1] // Inputs[1] { @02E8 msg.data.length } 02E1 5B JUMPDEST 02E2 61 PUSH2 0x02a6 02E5 61 PUSH2 0x02ef 02E8 36 CALLDATASIZE 02E9 60 PUSH1 0x04 02EB 61 PUSH2 0x1b5f 02EE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E2 stack[0] = 0x02a6 // @02E5 stack[1] = 0x02ef // @02E8 stack[2] = msg.data.length // @02E9 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b5f 02EF 5B JUMPDEST 02F0 61 PUSH2 0x07dc 02F3 56 *JUMP label_02F4: // Incoming jump from 0x0125, if 0x3f4ba83a == stack[-1] 02F4 5B JUMPDEST 02F5 61 PUSH2 0x02a6 02F8 61 PUSH2 0x0819 02FB 56 *JUMP // Stack delta = +1 // Outputs[1] { @02F5 stack[0] = 0x02a6 } // Block ends with unconditional jump to 0x0819 label_02FC: // Incoming jump from 0x0130, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0303 msg.data.length } 02FC 5B JUMPDEST 02FD 61 PUSH2 0x030f 0300 61 PUSH2 0x030a 0303 36 CALLDATASIZE 0304 60 PUSH1 0x04 0306 61 PUSH2 0x1c21 0309 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02FD stack[0] = 0x030f // @0300 stack[1] = 0x030a // @0303 stack[2] = msg.data.length // @0304 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1c21 030A 5B JUMPDEST 030B 61 PUSH2 0x082f 030E 56 *JUMP 030F 5B JUMPDEST 0310 60 PUSH1 0x40 0312 51 MLOAD 0313 61 PUSH2 0x01fe 0316 91 SWAP2 0317 90 SWAP1 0318 61 PUSH2 0x1ce4 031B 56 *JUMP label_031C: // Incoming jump from 0x013B, if 0x55f804b3 == stack[-1] // Inputs[1] { @0323 msg.data.length } 031C 5B JUMPDEST 031D 61 PUSH2 0x02a6 0320 61 PUSH2 0x032a 0323 36 CALLDATASIZE 0324 60 PUSH1 0x04 0326 61 PUSH2 0x1cf5 0329 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @031D stack[0] = 0x02a6 // @0320 stack[1] = 0x032a // @0323 stack[2] = msg.data.length // @0324 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1cf5 032A 5B JUMPDEST 032B 61 PUSH2 0x0916 032E 56 *JUMP label_032F: // Incoming jump from 0x0146, if 0x5c975abb == stack[-1] // Inputs[1] { @0332 storage[0x04] } 032F 5B JUMPDEST 0330 60 PUSH1 0x04 0332 54 SLOAD 0333 60 PUSH1 0xff 0335 16 AND 0336 61 PUSH2 0x021a 0339 56 *JUMP // Stack delta = +1 // Outputs[1] { @0335 stack[0] = 0xff & storage[0x04] } // Block ends with unconditional jump to 0x021a label_033A: // Incoming jump from 0x00E9, if 0x8456cb59 == stack[-1] 033A 5B JUMPDEST 033B 61 PUSH2 0x02a6 033E 61 PUSH2 0x0934 0341 56 *JUMP // Stack delta = +1 // Outputs[1] { @033B stack[0] = 0x02a6 } // Block ends with unconditional jump to 0x0934 label_0342: // Incoming jump from 0x00F4, if 0x91d14854 == stack[-1] // Inputs[1] { @0349 msg.data.length } 0342 5B JUMPDEST 0343 61 PUSH2 0x021a 0346 61 PUSH2 0x0350 0349 36 CALLDATASIZE 034A 60 PUSH1 0x04 034C 61 PUSH2 0x1b0b 034F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0343 stack[0] = 0x021a // @0346 stack[1] = 0x0350 // @0349 stack[2] = msg.data.length // @034A stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b0b 0350 5B JUMPDEST 0351 61 PUSH2 0x0947 0354 56 *JUMP label_0355: // Incoming jump from 0x00FF, if 0x938e3d7b == stack[-1] // Inputs[1] { @035C msg.data.length } 0355 5B JUMPDEST 0356 61 PUSH2 0x02a6 0359 61 PUSH2 0x0363 035C 36 CALLDATASIZE 035D 60 PUSH1 0x04 035F 61 PUSH2 0x1cf5 0362 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0356 stack[0] = 0x02a6 // @0359 stack[1] = 0x0363 // @035C stack[2] = msg.data.length // @035D stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1cf5 0363 5B JUMPDEST 0364 61 PUSH2 0x0972 0367 56 *JUMP label_0368: // Incoming jump from 0x00B8, if 0x95d89b41 == stack[-1] 0368 5B JUMPDEST 0369 61 PUSH2 0x022f 036C 61 PUSH2 0x0990 036F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0369 stack[0] = 0x022f } // Block ends with call to 0x0990, returns to 0x022F label_0370: // Incoming jump from 0x00C3, if 0xa06d8fc7 == stack[-1] // Inputs[1] { @0377 msg.data.length } 0370 5B JUMPDEST 0371 61 PUSH2 0x02a6 0374 61 PUSH2 0x037e 0377 36 CALLDATASIZE 0378 60 PUSH1 0x04 037A 61 PUSH2 0x1b3e 037D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0371 stack[0] = 0x02a6 // @0374 stack[1] = 0x037e // @0377 stack[2] = msg.data.length // @0378 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b3e 037E 5B JUMPDEST 037F 61 PUSH2 0x099d 0382 56 *JUMP label_0383: // Incoming jump from 0x00CE, if 0xa217fddf == stack[-1] 0383 5B JUMPDEST 0384 61 PUSH2 0x01f1 0387 60 PUSH1 0x00 0389 81 DUP2 038A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0384 stack[0] = 0x01f1 // @0387 stack[1] = 0x00 // } // Block ends with unconditional jump to 0x01f1 label_038B: // Incoming jump from 0x00D9, if 0xa22cb465 == stack[-1] // Inputs[1] { @0392 msg.data.length } 038B 5B JUMPDEST 038C 61 PUSH2 0x02a6 038F 61 PUSH2 0x0399 0392 36 CALLDATASIZE 0393 60 PUSH1 0x04 0395 61 PUSH2 0x1d42 0398 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @038C stack[0] = 0x02a6 // @038F stack[1] = 0x0399 // @0392 stack[2] = msg.data.length // @0393 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1d42 0399 5B JUMPDEST 039A 61 PUSH2 0x09c0 039D 56 *JUMP label_039E: // Incoming jump from 0x007C, if 0xd547741f == stack[-1] // Inputs[1] { @03A5 msg.data.length } 039E 5B JUMPDEST 039F 61 PUSH2 0x02a6 03A2 61 PUSH2 0x03ac 03A5 36 CALLDATASIZE 03A6 60 PUSH1 0x04 03A8 61 PUSH2 0x1b0b 03AB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @039F stack[0] = 0x02a6 // @03A2 stack[1] = 0x03ac // @03A5 stack[2] = msg.data.length // @03A6 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b0b 03AC 5B JUMPDEST 03AD 61 PUSH2 0x09cb 03B0 56 *JUMP label_03B1: // Incoming jump from 0x0087, if 0xe2e784d5 == stack[-1] // Inputs[1] { @03B8 msg.data.length } 03B1 5B JUMPDEST 03B2 61 PUSH2 0x02a6 03B5 61 PUSH2 0x03bf 03B8 36 CALLDATASIZE 03B9 60 PUSH1 0x04 03BB 61 PUSH2 0x172f 03BE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B2 stack[0] = 0x02a6 // @03B5 stack[1] = 0x03bf // @03B8 stack[2] = msg.data.length // @03B9 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x172f 03BF 5B JUMPDEST 03C0 61 PUSH2 0x09f0 03C3 56 *JUMP label_03C4: // Incoming jump from 0x0092, if 0xe7d3fe6b == stack[-1] // Inputs[1] { @03CB msg.data.length } 03C4 5B JUMPDEST 03C5 61 PUSH2 0x02a6 03C8 61 PUSH2 0x03d2 03CB 36 CALLDATASIZE 03CC 60 PUSH1 0x04 03CE 61 PUSH2 0x1d75 03D1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C5 stack[0] = 0x02a6 // @03C8 stack[1] = 0x03d2 // @03CB stack[2] = msg.data.length // @03CC stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1d75 03D2 5B JUMPDEST 03D3 61 PUSH2 0x0a22 03D6 56 *JUMP label_03D7: // Incoming jump from 0x009D, if 0xe8a3d485 == stack[-1] 03D7 5B JUMPDEST 03D8 61 PUSH2 0x022f 03DB 61 PUSH2 0x0a55 03DE 56 *JUMP // Stack delta = +1 // Outputs[1] { @03D8 stack[0] = 0x022f } // Block ends with call to 0x0a55, returns to 0x022F label_03DF: // Incoming jump from 0x004B, if 0xe985e9c5 == stack[-1] // Inputs[1] { @03E6 msg.data.length } 03DF 5B JUMPDEST 03E0 61 PUSH2 0x021a 03E3 61 PUSH2 0x03ed 03E6 36 CALLDATASIZE 03E7 60 PUSH1 0x04 03E9 61 PUSH2 0x1dc5 03EC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03E0 stack[0] = 0x021a // @03E3 stack[1] = 0x03ed // @03E6 stack[2] = msg.data.length // @03E7 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1dc5 03ED 5B JUMPDEST 03EE 60 PUSH1 0x01 03F0 60 PUSH1 0x01 03F2 60 PUSH1 0xa0 03F4 1B SHL 03F5 03 SUB 03F6 91 SWAP2 03F7 82 DUP3 03F8 16 AND 03F9 60 PUSH1 0x00 03FB 90 SWAP1 03FC 81 DUP2 03FD 52 MSTORE 03FE 60 PUSH1 0x01 0400 60 PUSH1 0x20 0402 90 SWAP1 0403 81 DUP2 0404 52 MSTORE 0405 60 PUSH1 0x40 0407 80 DUP1 0408 83 DUP4 0409 20 SHA3 040A 93 SWAP4 040B 90 SWAP1 040C 94 SWAP5 040D 16 AND 040E 82 DUP3 040F 52 MSTORE 0410 91 SWAP2 0411 90 SWAP1 0412 91 SWAP2 0413 52 MSTORE 0414 20 SHA3 0415 54 SLOAD 0416 60 PUSH1 0xff 0418 16 AND 0419 90 SWAP1 041A 56 *JUMP label_041B: // Incoming jump from 0x0056, if 0xf242432a == stack[-1] // Inputs[1] { @0422 msg.data.length } 041B 5B JUMPDEST 041C 61 PUSH2 0x02a6 041F 61 PUSH2 0x0429 0422 36 CALLDATASIZE 0423 60 PUSH1 0x04 0425 61 PUSH2 0x1de7 0428 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @041C stack[0] = 0x02a6 // @041F stack[1] = 0x0429 // @0422 stack[2] = msg.data.length // @0423 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1de7 0429 5B JUMPDEST 042A 61 PUSH2 0x0ae7 042D 56 *JUMP label_042E: // Incoming jump from 0x0061, if 0xf2aa3d43 == stack[-1] // Inputs[1] { @0435 msg.data.length } 042E 5B JUMPDEST 042F 61 PUSH2 0x02a6 0432 61 PUSH2 0x043c 0435 36 CALLDATASIZE 0436 60 PUSH1 0x04 0438 61 PUSH2 0x1e41 043B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @042F stack[0] = 0x02a6 // @0432 stack[1] = 0x043c // @0435 stack[2] = msg.data.length // @0436 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1e41 043C 5B JUMPDEST 043D 61 PUSH2 0x0b2c 0440 56 *JUMP label_0441: // Incoming jump from 0x006C, if 0xfe6d8124 == stack[-1] // Inputs[2] // { // @0448 memory[0x00:0x20] // @0451 memory[0x00:0x20] // } 0441 5B JUMPDEST 0442 61 PUSH2 0x01f1 0445 60 PUSH1 0x00 0447 80 DUP1 0448 51 MLOAD 0449 60 PUSH1 0x20 044B 61 PUSH2 0x271b 044E 83 DUP4 044F 39 CODECOPY 0450 81 DUP2 0451 51 MLOAD 0452 91 SWAP2 0453 52 MSTORE 0454 81 DUP2 0455 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0442 stack[0] = 0x01f1 // @044F memory[0x00:0x20] = code[0x271b:0x273b] // @0452 stack[1] = memory[0x00:0x20] // @0453 memory[0x00:0x20] = memory[0x00:0x20] // } // Block ends with unconditional jump to 0x01f1 0456 5B JUMPDEST 0457 60 PUSH1 0x00 0459 60 PUSH1 0x01 045B 60 PUSH1 0x01 045D 60 PUSH1 0xa0 045F 1B SHL 0460 03 SUB 0461 83 DUP4 0462 16 AND 0463 61 PUSH2 0x0487 0466 57 *JUMPI 0467 60 PUSH1 0x40 0469 51 MLOAD 046A 62 PUSH3 0x461bcd 046E 60 PUSH1 0xe5 0470 1B SHL 0471 81 DUP2 0472 52 MSTORE 0473 60 PUSH1 0x04 0475 01 ADD 0476 61 PUSH2 0x047e 0479 90 SWAP1 047A 61 PUSH2 0x1f0a 047D 56 *JUMP 047E 5B JUMPDEST 047F 60 PUSH1 0x40 0481 51 MLOAD 0482 80 DUP1 0483 91 SWAP2 0484 03 SUB 0485 90 SWAP1 0486 FD *REVERT 0487 5B JUMPDEST 0488 50 POP 0489 60 PUSH1 0x00 048B 81 DUP2 048C 81 DUP2 048D 52 MSTORE 048E 60 PUSH1 0x20 0490 81 DUP2 0491 81 DUP2 0492 52 MSTORE 0493 60 PUSH1 0x40 0495 80 DUP1 0496 83 DUP4 0497 20 SHA3 0498 60 PUSH1 0x01 049A 60 PUSH1 0x01 049C 60 PUSH1 0xa0 049E 1B SHL 049F 03 SUB 04A0 86 DUP7 04A1 16 AND 04A2 84 DUP5 04A3 52 MSTORE 04A4 90 SWAP1 04A5 91 SWAP2 04A6 52 MSTORE 04A7 90 SWAP1 04A8 20 SHA3 04A9 54 SLOAD label_04AA: // Incoming return from call to 0x17C6 at 0x17DB // Incoming return from call to 0x1782 at 0x179C // Incoming return from call to 0x2183 at 0x21C7 // Incoming jump from 0x16FE // Incoming return from call to 0x176C at 0x1781 // Incoming return from call to 0x171E at 0x172E // Inputs[3] // { // @04AB stack[-4] // @04AB stack[-1] // @04AC stack[-3] // } 04AA 5B JUMPDEST 04AB 92 SWAP3 04AC 91 SWAP2 04AD 50 POP 04AE 50 POP 04AF 56 *JUMP // Stack delta = -3 // Outputs[1] { @04AB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 04B0 5B JUMPDEST 04B1 60 PUSH1 0x00 04B3 60 PUSH1 0x01 04B5 60 PUSH1 0x01 04B7 60 PUSH1 0xe0 04B9 1B SHL 04BA 03 SUB 04BB 19 NOT 04BC 82 DUP3 04BD 16 AND 04BE 63 PUSH4 0x152a902d 04C3 60 PUSH1 0xe1 04C5 1B SHL 04C6 14 EQ 04C7 80 DUP1 04C8 61 PUSH2 0x04e1 04CB 57 *JUMPI 04CC 50 POP 04CD 60 PUSH1 0x01 04CF 60 PUSH1 0x01 04D1 60 PUSH1 0xe0 04D3 1B SHL 04D4 03 SUB 04D5 19 NOT 04D6 82 DUP3 04D7 16 AND 04D8 63 PUSH4 0xda8def73 04DD 60 PUSH1 0xe0 04DF 1B SHL 04E0 14 EQ 04E1 5B JUMPDEST 04E2 80 DUP1 04E3 61 PUSH2 0x04aa 04E6 57 *JUMPI 04E7 50 POP 04E8 61 PUSH2 0x04aa 04EB 82 DUP3 04EC 61 PUSH2 0x0cdb 04EF 56 *JUMP label_04F0: // Incoming call from 0x022E, returns to 0x022F // Inputs[1] { @04F4 storage[0x05] } 04F0 5B JUMPDEST 04F1 60 PUSH1 0x05 04F3 80 DUP1 04F4 54 SLOAD 04F5 61 PUSH2 0x04fd 04F8 90 SWAP1 04F9 61 PUSH2 0x1f30 04FC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04F1 stack[0] = 0x05 // @04F8 stack[1] = 0x04fd // @04F8 stack[2] = storage[0x05] // } // Block ends with call to 0x1f30, returns to 0x04FD label_04FD: // Incoming return from call to 0x1F30 at 0x099C // Incoming return from call to 0x1F30 at 0x04FC // Inputs[4] // { // @04FE stack[-1] // @050D memory[0x40:0x60] // @0515 stack[-2] // @0520 storage[stack[-2]] // } 04FD 5B JUMPDEST 04FE 80 DUP1 04FF 60 PUSH1 0x1f 0501 01 ADD 0502 60 PUSH1 0x20 0504 80 DUP1 0505 91 SWAP2 0506 04 DIV 0507 02 MUL 0508 60 PUSH1 0x20 050A 01 ADD 050B 60 PUSH1 0x40 050D 51 MLOAD 050E 90 SWAP1 050F 81 DUP2 0510 01 ADD 0511 60 PUSH1 0x40 0513 52 MSTORE 0514 80 DUP1 0515 92 SWAP3 0516 91 SWAP2 0517 90 SWAP1 0518 81 DUP2 0519 81 DUP2 051A 52 MSTORE 051B 60 PUSH1 0x20 051D 01 ADD 051E 82 DUP3 051F 80 DUP1 0520 54 SLOAD 0521 61 PUSH2 0x0529 0524 90 SWAP1 0525 61 PUSH2 0x1f30 0528 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0513 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0515 stack[-2] = memory[0x40:0x60] // @0516 stack[-1] = stack[-2] // @0517 stack[0] = stack[-1] // @051A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @051D stack[1] = 0x20 + memory[0x40:0x60] // @051E stack[2] = stack[-2] // @0524 stack[4] = storage[stack[-2]] // @0524 stack[3] = 0x0529 // } // Block ends with call to 0x1f30, returns to 0x0529 label_0529: // Incoming return from call to 0x1F30 at 0x0528 // Inputs[1] { @052A stack[-1] } 0529 5B JUMPDEST 052A 80 DUP1 052B 15 ISZERO 052C 61 PUSH2 0x0576 052F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0576, if !stack[-1] label_0530: // Incoming jump from 0x052F, if not !stack[-1] // Inputs[1] { @0530 stack[-1] } 0530 80 DUP1 0531 60 PUSH1 0x1f 0533 10 LT 0534 61 PUSH2 0x054b 0537 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054b, if 0x1f < stack[-1] label_0538: // Incoming jump from 0x0537, if not 0x1f < stack[-1] // Inputs[4] // { // @053C stack[-2] // @053D storage[stack[-2]] // @0540 stack[-3] // @0542 stack[-1] // } 0538 61 PUSH2 0x0100 053B 80 DUP1 053C 83 DUP4 053D 54 SLOAD 053E 04 DIV 053F 02 MUL 0540 83 DUP4 0541 52 MSTORE 0542 91 SWAP2 0543 60 PUSH1 0x20 0545 01 ADD 0546 91 SWAP2 0547 61 PUSH2 0x0576 054A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0541 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0546 stack[-1] = stack[-1] // @0546 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0576 label_054B: // Incoming jump from 0x0537, if 0x1f < stack[-1] // Inputs[5] // { // @054C stack[-3] // @054D stack[-1] // @054F stack[-2] // @0557 memory[0x00:0x20] // @055B storage[keccak256(memory[0x00:0x20])] // } 054B 5B JUMPDEST 054C 82 DUP3 054D 01 ADD 054E 91 SWAP2 054F 90 SWAP1 0550 60 PUSH1 0x00 0552 52 MSTORE 0553 60 PUSH1 0x20 0555 60 PUSH1 0x00 0557 20 SHA3 0558 90 SWAP1 0559 5B JUMPDEST 055A 81 DUP2 055B 54 SLOAD 055C 81 DUP2 055D 52 MSTORE 055E 90 SWAP1 055F 60 PUSH1 0x01 0561 01 ADD 0562 90 SWAP1 0563 60 PUSH1 0x20 0565 01 ADD 0566 80 DUP1 0567 83 DUP4 0568 11 GT 0569 61 PUSH2 0x0559 056C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @054E stack[-3] = stack[-3] + stack[-1] // @0552 memory[0x00:0x20] = stack[-2] // @055D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0562 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0565 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0559, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_056D: // Incoming jump from 0x056C, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x056C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @056D stack[-3] // @056E stack[-1] // } 056D 82 DUP3 056E 90 SWAP1 056F 03 SUB 0570 60 PUSH1 0x1f 0572 16 AND 0573 82 DUP3 0574 01 ADD 0575 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0575 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0575 stack[-1] = stack[-3] // } // Block continues label_0576: // Incoming jump from 0x052F, if !stack[-1] // Incoming jump from 0x054A // Incoming jump from 0x0575 // Inputs[1] { @057C stack[-7] } 0576 5B JUMPDEST 0577 50 POP 0578 50 POP 0579 50 POP 057A 50 POP 057B 50 POP 057C 81 DUP2 057D 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] 057E 5B JUMPDEST 057F 60 PUSH1 0x00 0581 81 DUP2 0582 81 DUP2 0583 52 MSTORE 0584 60 PUSH1 0x08 0586 60 PUSH1 0x20 0588 52 MSTORE 0589 60 PUSH1 0x40 058B 81 DUP2 058C 20 SHA3 058D 80 DUP1 058E 54 SLOAD 058F 60 PUSH1 0x60 0591 92 SWAP3 0592 91 SWAP2 0593 90 SWAP1 0594 61 PUSH2 0x059c 0597 90 SWAP1 0598 61 PUSH2 0x1f30 059B 56 *JUMP 059C 5B JUMPDEST 059D 80 DUP1 059E 60 PUSH1 0x1f 05A0 01 ADD 05A1 60 PUSH1 0x20 05A3 80 DUP1 05A4 91 SWAP2 05A5 04 DIV 05A6 02 MUL 05A7 60 PUSH1 0x20 05A9 01 ADD 05AA 60 PUSH1 0x40 05AC 51 MLOAD 05AD 90 SWAP1 05AE 81 DUP2 05AF 01 ADD 05B0 60 PUSH1 0x40 05B2 52 MSTORE 05B3 80 DUP1 05B4 92 SWAP3 05B5 91 SWAP2 05B6 90 SWAP1 05B7 81 DUP2 05B8 81 DUP2 05B9 52 MSTORE 05BA 60 PUSH1 0x20 05BC 01 ADD 05BD 82 DUP3 05BE 80 DUP1 05BF 54 SLOAD 05C0 61 PUSH2 0x05c8 05C3 90 SWAP1 05C4 61 PUSH2 0x1f30 05C7 56 *JUMP 05C8 5B JUMPDEST 05C9 80 DUP1 05CA 15 ISZERO 05CB 61 PUSH2 0x0615 05CE 57 *JUMPI 05CF 80 DUP1 05D0 60 PUSH1 0x1f 05D2 10 LT 05D3 61 PUSH2 0x05ea 05D6 57 *JUMPI 05D7 61 PUSH2 0x0100 05DA 80 DUP1 05DB 83 DUP4 05DC 54 SLOAD 05DD 04 DIV 05DE 02 MUL 05DF 83 DUP4 05E0 52 MSTORE 05E1 91 SWAP2 05E2 60 PUSH1 0x20 05E4 01 ADD 05E5 91 SWAP2 05E6 61 PUSH2 0x0615 05E9 56 *JUMP 05EA 5B JUMPDEST 05EB 82 DUP3 05EC 01 ADD 05ED 91 SWAP2 05EE 90 SWAP1 05EF 60 PUSH1 0x00 05F1 52 MSTORE 05F2 60 PUSH1 0x20 05F4 60 PUSH1 0x00 05F6 20 SHA3 05F7 90 SWAP1 05F8 5B JUMPDEST 05F9 81 DUP2 05FA 54 SLOAD 05FB 81 DUP2 05FC 52 MSTORE 05FD 90 SWAP1 05FE 60 PUSH1 0x01 0600 01 ADD 0601 90 SWAP1 0602 60 PUSH1 0x20 0604 01 ADD 0605 80 DUP1 0606 83 DUP4 0607 11 GT 0608 61 PUSH2 0x05f8 060B 57 *JUMPI 060C 82 DUP3 060D 90 SWAP1 060E 03 SUB 060F 60 PUSH1 0x1f 0611 16 AND 0612 82 DUP3 0613 01 ADD 0614 91 SWAP2 0615 5B JUMPDEST 0616 50 POP 0617 50 POP 0618 50 POP 0619 50 POP 061A 50 POP 061B 90 SWAP1 061C 50 POP 061D 60 PUSH1 0x40 061F 51 MLOAD 0620 80 DUP1 0621 60 PUSH1 0x20 0623 01 ADD 0624 60 PUSH1 0x40 0626 52 MSTORE 0627 80 DUP1 0628 60 PUSH1 0x00 062A 81 DUP2 062B 52 MSTORE 062C 50 POP 062D 80 DUP1 062E 51 MLOAD 062F 90 SWAP1 0630 60 PUSH1 0x20 0632 01 ADD 0633 20 SHA3 0634 81 DUP2 0635 80 DUP1 0636 51 MLOAD 0637 90 SWAP1 0638 60 PUSH1 0x20 063A 01 ADD 063B 20 SHA3 063C 14 EQ 063D 61 PUSH2 0x0646 0640 57 *JUMPI 0641 92 SWAP3 0642 91 SWAP2 0643 50 POP 0644 50 POP 0645 56 *JUMP 0646 5B JUMPDEST 0647 60 PUSH1 0x07 0649 80 DUP1 064A 54 SLOAD 064B 61 PUSH2 0x0653 064E 90 SWAP1 064F 61 PUSH2 0x1f30 0652 56 *JUMP 0653 5B JUMPDEST 0654 80 DUP1 0655 60 PUSH1 0x1f 0657 01 ADD 0658 60 PUSH1 0x20 065A 80 DUP1 065B 91 SWAP2 065C 04 DIV 065D 02 MUL 065E 60 PUSH1 0x20 0660 01 ADD 0661 60 PUSH1 0x40 0663 51 MLOAD 0664 90 SWAP1 0665 81 DUP2 0666 01 ADD 0667 60 PUSH1 0x40 0669 52 MSTORE 066A 80 DUP1 066B 92 SWAP3 066C 91 SWAP2 066D 90 SWAP1 066E 81 DUP2 066F 81 DUP2 0670 52 MSTORE 0671 60 PUSH1 0x20 0673 01 ADD 0674 82 DUP3 0675 80 DUP1 0676 54 SLOAD 0677 61 PUSH2 0x067f 067A 90 SWAP1 067B 61 PUSH2 0x1f30 067E 56 *JUMP 067F 5B JUMPDEST 0680 80 DUP1 0681 15 ISZERO 0682 61 PUSH2 0x06cc 0685 57 *JUMPI 0686 80 DUP1 0687 60 PUSH1 0x1f 0689 10 LT 068A 61 PUSH2 0x06a1 068D 57 *JUMPI 068E 61 PUSH2 0x0100 0691 80 DUP1 0692 83 DUP4 0693 54 SLOAD 0694 04 DIV 0695 02 MUL 0696 83 DUP4 0697 52 MSTORE 0698 91 SWAP2 0699 60 PUSH1 0x20 069B 01 ADD 069C 91 SWAP2 069D 61 PUSH2 0x06cc 06A0 56 *JUMP 06A1 5B JUMPDEST 06A2 82 DUP3 06A3 01 ADD 06A4 91 SWAP2 06A5 90 SWAP1 06A6 60 PUSH1 0x00 06A8 52 MSTORE 06A9 60 PUSH1 0x20 06AB 60 PUSH1 0x00 06AD 20 SHA3 06AE 90 SWAP1 06AF 5B JUMPDEST 06B0 81 DUP2 06B1 54 SLOAD 06B2 81 DUP2 06B3 52 MSTORE 06B4 90 SWAP1 06B5 60 PUSH1 0x01 06B7 01 ADD 06B8 90 SWAP1 06B9 60 PUSH1 0x20 06BB 01 ADD 06BC 80 DUP1 06BD 83 DUP4 06BE 11 GT 06BF 61 PUSH2 0x06af 06C2 57 *JUMPI 06C3 82 DUP3 06C4 90 SWAP1 06C5 03 SUB 06C6 60 PUSH1 0x1f 06C8 16 AND 06C9 82 DUP3 06CA 01 ADD 06CB 91 SWAP2 06CC 5B JUMPDEST 06CD 50 POP 06CE 50 POP 06CF 50 POP 06D0 50 POP 06D1 50 POP 06D2 91 SWAP2 06D3 50 POP 06D4 50 POP 06D5 91 SWAP2 06D6 90 SWAP1 06D7 50 POP 06D8 56 *JUMP 06D9 5B JUMPDEST 06DA 60 PUSH1 0x00 06DC 80 DUP1 06DD 60 PUSH1 0x0b 06DF 54 SLOAD 06E0 61 PUSH2 0x2710 06E3 84 DUP5 06E4 61 PUSH2 0x06ed 06E7 91 SWAP2 06E8 90 SWAP1 06E9 61 PUSH2 0x1f89 06EC 56 *JUMP 06ED 5B JUMPDEST 06EE 61 PUSH2 0x06f7 06F1 91 SWAP2 06F2 90 SWAP1 06F3 61 PUSH2 0x1f9d 06F6 56 *JUMP 06F7 5B JUMPDEST 06F8 60 PUSH1 0x0a 06FA 54 SLOAD 06FB 60 PUSH1 0x01 06FD 60 PUSH1 0x01 06FF 60 PUSH1 0xa0 0701 1B SHL 0702 03 SUB 0703 16 AND 0704 95 SWAP6 0705 90 SWAP1 0706 94 SWAP5 0707 50 POP 0708 92 SWAP3 0709 50 POP 070A 50 POP 070B 50 POP 070C 56 *JUMP 070D 5B JUMPDEST 070E 60 PUSH1 0x01 0710 60 PUSH1 0x01 0712 60 PUSH1 0xa0 0714 1B SHL 0715 03 SUB 0716 85 DUP6 0717 16 AND 0718 33 CALLER 0719 14 EQ 071A 80 DUP1 071B 61 PUSH2 0x0729 071E 57 *JUMPI 071F 50 POP 0720 61 PUSH2 0x0729 0723 85 DUP6 0724 33 CALLER 0725 61 PUSH2 0x03ed 0728 56 *JUMP 0729 5B JUMPDEST 072A 61 PUSH2 0x0745 072D 57 *JUMPI 072E 60 PUSH1 0x40 0730 51 MLOAD 0731 62 PUSH3 0x461bcd 0735 60 PUSH1 0xe5 0737 1B SHL 0738 81 DUP2 0739 52 MSTORE 073A 60 PUSH1 0x04 073C 01 ADD 073D 61 PUSH2 0x047e 0740 90 SWAP1 0741 61 PUSH2 0x200b 0744 56 *JUMP 0745 5B JUMPDEST 0746 61 PUSH2 0x0752 0749 85 DUP6 074A 85 DUP6 074B 85 DUP6 074C 85 DUP6 074D 85 DUP6 074E 61 PUSH2 0x0d00 0751 56 *JUMP 0752 5B JUMPDEST 0753 50 POP 0754 50 POP 0755 50 POP 0756 50 POP 0757 50 POP 0758 56 *JUMP 0759 5B JUMPDEST 075A 60 PUSH1 0x00 075C 82 DUP3 075D 81 DUP2 075E 52 MSTORE 075F 60 PUSH1 0x03 0761 60 PUSH1 0x20 0763 52 MSTORE 0764 60 PUSH1 0x40 0766 90 SWAP1 0767 20 SHA3 0768 60 PUSH1 0x01 076A 01 ADD 076B 54 SLOAD 076C 61 PUSH2 0x0774 076F 81 DUP2 0770 61 PUSH2 0x0eaa 0773 56 *JUMP 0774 5B JUMPDEST 0775 61 PUSH2 0x077e 0778 83 DUP4 0779 83 DUP4 077A 61 PUSH2 0x0eb4 077D 56 *JUMP 077E 5B JUMPDEST 077F 50 POP 0780 50 POP 0781 50 POP 0782 56 *JUMP 0783 5B JUMPDEST 0784 60 PUSH1 0x01 0786 60 PUSH1 0x01 0788 60 PUSH1 0xa0 078A 1B SHL 078B 03 SUB 078C 81 DUP2 078D 16 AND 078E 33 CALLER 078F 14 EQ 0790 61 PUSH2 0x07ab 0793 57 *JUMPI 0794 60 PUSH1 0x40 0796 51 MLOAD 0797 62 PUSH3 0x461bcd 079B 60 PUSH1 0xe5 079D 1B SHL 079E 81 DUP2 079F 52 MSTORE 07A0 60 PUSH1 0x04 07A2 01 ADD 07A3 61 PUSH2 0x047e 07A6 90 SWAP1 07A7 61 PUSH2 0x2067 07AA 56 *JUMP 07AB 5B JUMPDEST 07AC 61 PUSH2 0x07b5 07AF 82 DUP3 07B0 82 DUP3 07B1 61 PUSH2 0x0f3a 07B4 56 *JUMP label_07B5: // Incoming jump from 0x14C7, if stack[-1] // Inputs[1] { @07B8 stack[-3] } 07B5 5B JUMPDEST 07B6 50 POP 07B7 50 POP 07B8 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] 07B9 5B JUMPDEST 07BA 60 PUSH1 0x00 07BC 61 PUSH2 0x07c4 07BF 81 DUP2 07C0 61 PUSH2 0x0eaa 07C3 56 *JUMP 07C4 5B JUMPDEST 07C5 61 PUSH2 0x07b5 07C8 60 PUSH1 0x00 07CA 80 DUP1 07CB 51 MLOAD 07CC 60 PUSH1 0x20 07CE 61 PUSH2 0x271b 07D1 83 DUP4 07D2 39 CODECOPY 07D3 81 DUP2 07D4 51 MLOAD 07D5 91 SWAP2 07D6 52 MSTORE 07D7 83 DUP4 07D8 61 PUSH2 0x09cb 07DB 56 *JUMP 07DC 5B JUMPDEST 07DD 60 PUSH1 0x00 07DF 80 DUP1 07E0 51 MLOAD 07E1 60 PUSH1 0x20 07E3 61 PUSH2 0x271b 07E6 83 DUP4 07E7 39 CODECOPY 07E8 81 DUP2 07E9 51 MLOAD 07EA 91 SWAP2 07EB 52 MSTORE 07EC 61 PUSH2 0x07f4 07EF 81 DUP2 07F0 61 PUSH2 0x0eaa 07F3 56 *JUMP 07F4 5B JUMPDEST 07F5 60 PUSH1 0x00 07F7 83 DUP4 07F8 81 DUP2 07F9 52 MSTORE 07FA 60 PUSH1 0x08 07FC 60 PUSH1 0x20 07FE 90 SWAP1 07FF 81 DUP2 0800 52 MSTORE 0801 60 PUSH1 0x40 0803 90 SWAP1 0804 91 SWAP2 0805 20 SHA3 0806 83 DUP4 0807 51 MLOAD 0808 61 PUSH2 0x0813 080B 92 SWAP3 080C 85 DUP6 080D 01 ADD 080E 90 SWAP1 080F 61 PUSH2 0x1655 0812 56 *JUMP label_0813: // Incoming jump from 0x17FF, if !(stack[-1] > stack[-4]) // Inputs[1] { @0818 stack[-5] } 0813 5B JUMPDEST 0814 50 POP 0815 50 POP 0816 50 POP 0817 50 POP 0818 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0819: // Incoming jump from 0x02FB 0819 5B JUMPDEST 081A 60 PUSH1 0x00 081C 61 PUSH2 0x0824 081F 81 DUP2 0820 61 PUSH2 0x0eaa 0823 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @081A stack[0] = 0x00 // @081C stack[1] = 0x0824 // @081F stack[2] = 0x00 // } // Block ends with unconditional jump to 0x0eaa 0824 5B JUMPDEST 0825 61 PUSH2 0x082c 0828 61 PUSH2 0x0fa1 082B 56 *JUMP label_082C: // Incoming jump from 0x170E, if stack[-2] == stack[-1] // Incoming return from call to 0x14B9 at 0x0EB3 // Inputs[1] { @082E stack[-2] } 082C 5B JUMPDEST 082D 50 POP 082E 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 082F 5B JUMPDEST 0830 60 PUSH1 0x60 0832 81 DUP2 0833 51 MLOAD 0834 83 DUP4 0835 51 MLOAD 0836 14 EQ 0837 61 PUSH2 0x0852 083A 57 *JUMPI 083B 60 PUSH1 0x40 083D 51 MLOAD 083E 62 PUSH3 0x461bcd 0842 60 PUSH1 0xe5 0844 1B SHL 0845 81 DUP2 0846 52 MSTORE 0847 60 PUSH1 0x04 0849 01 ADD 084A 61 PUSH2 0x047e 084D 90 SWAP1 084E 61 PUSH2 0x20bd 0851 56 *JUMP 0852 5B JUMPDEST 0853 60 PUSH1 0x00 0855 83 DUP4 0856 51 MLOAD 0857 60 PUSH1 0x01 0859 60 PUSH1 0x01 085B 60 PUSH1 0x40 085D 1B SHL 085E 03 SUB 085F 81 DUP2 0860 11 GT 0861 15 ISZERO 0862 61 PUSH2 0x086d 0865 57 *JUMPI 0866 61 PUSH2 0x086d 0869 61 PUSH2 0x18b2 086C 56 *JUMP 086D 5B JUMPDEST 086E 60 PUSH1 0x40 0870 51 MLOAD 0871 90 SWAP1 0872 80 DUP1 0873 82 DUP3 0874 52 MSTORE 0875 80 DUP1 0876 60 PUSH1 0x20 0878 02 MUL 0879 60 PUSH1 0x20 087B 01 ADD 087C 82 DUP3 087D 01 ADD 087E 60 PUSH1 0x40 0880 52 MSTORE 0881 80 DUP1 0882 15 ISZERO 0883 61 PUSH2 0x0896 0886 57 *JUMPI 0887 81 DUP2 0888 60 PUSH1 0x20 088A 01 ADD 088B 60 PUSH1 0x20 088D 82 DUP3 088E 02 MUL 088F 80 DUP1 0890 36 CALLDATASIZE 0891 83 DUP4 0892 37 CALLDATACOPY 0893 01 ADD 0894 90 SWAP1 0895 50 POP 0896 5B JUMPDEST 0897 50 POP 0898 90 SWAP1 0899 50 POP 089A 60 PUSH1 0x00 089C 5B JUMPDEST 089D 84 DUP5 089E 51 MLOAD 089F 81 DUP2 08A0 10 LT 08A1 15 ISZERO 08A2 61 PUSH2 0x090e 08A5 57 *JUMPI 08A6 61 PUSH2 0x08e1 08A9 85 DUP6 08AA 82 DUP3 08AB 81 DUP2 08AC 51 MLOAD 08AD 81 DUP2 08AE 10 LT 08AF 61 PUSH2 0x08ba 08B2 57 *JUMPI 08B3 61 PUSH2 0x08ba 08B6 61 PUSH2 0x20cd 08B9 56 *JUMP 08BA 5B JUMPDEST 08BB 60 PUSH1 0x20 08BD 02 MUL 08BE 60 PUSH1 0x20 08C0 01 ADD 08C1 01 ADD 08C2 51 MLOAD 08C3 85 DUP6 08C4 83 DUP4 08C5 81 DUP2 08C6 51 MLOAD 08C7 81 DUP2 08C8 10 LT 08C9 61 PUSH2 0x08d4 08CC 57 *JUMPI 08CD 61 PUSH2 0x08d4 08D0 61 PUSH2 0x20cd 08D3 56 *JUMP 08D4 5B JUMPDEST 08D5 60 PUSH1 0x20 08D7 02 MUL 08D8 60 PUSH1 0x20 08DA 01 ADD 08DB 01 ADD 08DC 51 MLOAD 08DD 61 PUSH2 0x0456 08E0 56 *JUMP 08E1 5B JUMPDEST 08E2 82 DUP3 08E3 82 DUP3 08E4 81 DUP2 08E5 51 MLOAD 08E6 81 DUP2 08E7 10 LT 08E8 61 PUSH2 0x08f3 08EB 57 *JUMPI 08EC 61 PUSH2 0x08f3 08EF 61 PUSH2 0x20cd 08F2 56 *JUMP 08F3 5B JUMPDEST 08F4 60 PUSH1 0x20 08F6 90 SWAP1 08F7 81 DUP2 08F8 02 MUL 08F9 91 SWAP2 08FA 90 SWAP1 08FB 91 SWAP2 08FC 01 ADD 08FD 01 ADD 08FE 52 MSTORE 08FF 61 PUSH2 0x0907 0902 81 DUP2 0903 61 PUSH2 0x20e3 0906 56 *JUMP 0907 5B JUMPDEST 0908 90 SWAP1 0909 50 POP 090A 61 PUSH2 0x089c 090D 56 *JUMP label_090E: // Incoming return from call to 0x19E1 at 0x1A20 // Inputs[3] // { // @0910 stack[-6] // @0910 stack[-2] // @0911 stack[-5] // } 090E 5B JUMPDEST 090F 50 POP 0910 93 SWAP4 0911 92 SWAP3 0912 50 POP 0913 50 POP 0914 50 POP 0915 56 *JUMP // Stack delta = -5 // Outputs[1] { @0910 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] 0916 5B JUMPDEST 0917 60 PUSH1 0x00 0919 61 PUSH2 0x0921 091C 81 DUP2 091D 61 PUSH2 0x0eaa 0920 56 *JUMP 0921 5B JUMPDEST 0922 81 DUP2 0923 51 MLOAD 0924 61 PUSH2 0x077e 0927 90 SWAP1 0928 60 PUSH1 0x07 092A 90 SWAP1 092B 60 PUSH1 0x20 092D 85 DUP6 092E 01 ADD 092F 90 SWAP1 0930 61 PUSH2 0x1655 0933 56 *JUMP label_0934: // Incoming jump from 0x0341 0934 5B JUMPDEST 0935 60 PUSH1 0x00 0937 61 PUSH2 0x093f 093A 81 DUP2 093B 61 PUSH2 0x0eaa 093E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0935 stack[0] = 0x00 // @0937 stack[1] = 0x093f // @093A stack[2] = 0x00 // } // Block ends with unconditional jump to 0x0eaa 093F 5B JUMPDEST 0940 61 PUSH2 0x082c 0943 61 PUSH2 0x1007 0946 56 *JUMP label_0947: // Incoming call from 0x14C2, returns to 0x14C3 // Inputs[6] // { // @094A stack[-2] // @0958 memory[0x00:0x40] // @0961 stack[-1] // @096B memory[0x00:0x40] // @096C storage[keccak256(memory[0x00:0x40])] // @0970 stack[-3] // } 0947 5B JUMPDEST 0948 60 PUSH1 0x00 094A 91 SWAP2 094B 82 DUP3 094C 52 MSTORE 094D 60 PUSH1 0x03 094F 60 PUSH1 0x20 0951 90 SWAP1 0952 81 DUP2 0953 52 MSTORE 0954 60 PUSH1 0x40 0956 80 DUP1 0957 84 DUP5 0958 20 SHA3 0959 60 PUSH1 0x01 095B 60 PUSH1 0x01 095D 60 PUSH1 0xa0 095F 1B SHL 0960 03 SUB 0961 93 SWAP4 0962 90 SWAP1 0963 93 SWAP4 0964 16 AND 0965 84 DUP5 0966 52 MSTORE 0967 91 SWAP2 0968 90 SWAP1 0969 52 MSTORE 096A 90 SWAP1 096B 20 SHA3 096C 54 SLOAD 096D 60 PUSH1 0xff 096F 16 AND 0970 90 SWAP1 0971 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @094C memory[0x00:0x20] = stack[-2] // @0953 memory[0x20:0x40] = 0x03 // @0966 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0969 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0970 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 0972 5B JUMPDEST 0973 60 PUSH1 0x00 0975 61 PUSH2 0x097d 0978 81 DUP2 0979 61 PUSH2 0x0eaa 097C 56 *JUMP 097D 5B JUMPDEST 097E 81 DUP2 097F 51 MLOAD 0980 61 PUSH2 0x077e 0983 90 SWAP1 0984 60 PUSH1 0x09 0986 90 SWAP1 0987 60 PUSH1 0x20 0989 85 DUP6 098A 01 ADD 098B 90 SWAP1 098C 61 PUSH2 0x1655 098F 56 *JUMP label_0990: // Incoming call from 0x036F, returns to 0x022F // Inputs[1] { @0994 storage[0x06] } 0990 5B JUMPDEST 0991 60 PUSH1 0x06 0993 80 DUP1 0994 54 SLOAD 0995 61 PUSH2 0x04fd 0998 90 SWAP1 0999 61 PUSH2 0x1f30 099C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0991 stack[0] = 0x06 // @0998 stack[1] = 0x04fd // @0998 stack[2] = storage[0x06] // } // Block ends with call to 0x1f30, returns to 0x04FD 099D 5B JUMPDEST 099E 60 PUSH1 0x00 09A0 61 PUSH2 0x09a8 09A3 81 DUP2 09A4 61 PUSH2 0x0eaa 09A7 56 *JUMP 09A8 5B JUMPDEST 09A9 61 PUSH2 0x07b5 09AC 60 PUSH1 0x00 09AE 80 DUP1 09AF 51 MLOAD 09B0 60 PUSH1 0x20 09B2 61 PUSH2 0x271b 09B5 83 DUP4 09B6 39 CODECOPY 09B7 81 DUP2 09B8 51 MLOAD 09B9 91 SWAP2 09BA 52 MSTORE 09BB 83 DUP4 09BC 61 PUSH2 0x0759 09BF 56 *JUMP 09C0 5B JUMPDEST 09C1 61 PUSH2 0x07b5 09C4 33 CALLER 09C5 83 DUP4 09C6 83 DUP4 09C7 61 PUSH2 0x105f 09CA 56 *JUMP 09CB 5B JUMPDEST 09CC 60 PUSH1 0x00 09CE 82 DUP3 09CF 81 DUP2 09D0 52 MSTORE 09D1 60 PUSH1 0x03 09D3 60 PUSH1 0x20 09D5 52 MSTORE 09D6 60 PUSH1 0x40 09D8 90 SWAP1 09D9 20 SHA3 09DA 60 PUSH1 0x01 09DC 01 ADD 09DD 54 SLOAD 09DE 61 PUSH2 0x09e6 09E1 81 DUP2 09E2 61 PUSH2 0x0eaa 09E5 56 *JUMP 09E6 5B JUMPDEST 09E7 61 PUSH2 0x077e 09EA 83 DUP4 09EB 83 DUP4 09EC 61 PUSH2 0x0f3a 09EF 56 *JUMP 09F0 5B JUMPDEST 09F1 60 PUSH1 0x00 09F3 61 PUSH2 0x09fb 09F6 81 DUP2 09F7 61 PUSH2 0x0eaa 09FA 56 *JUMP 09FB 5B JUMPDEST 09FC 50 POP 09FD 60 PUSH1 0x0a 09FF 80 DUP1 0A00 54 SLOAD 0A01 60 PUSH1 0x01 0A03 60 PUSH1 0x01 0A05 60 PUSH1 0xa0 0A07 1B SHL 0A08 03 SUB 0A09 19 NOT 0A0A 16 AND 0A0B 60 PUSH1 0x01 0A0D 60 PUSH1 0x01 0A0F 60 PUSH1 0xa0 0A11 1B SHL 0A12 03 SUB 0A13 93 SWAP4 0A14 90 SWAP1 0A15 93 SWAP4 0A16 16 AND 0A17 92 SWAP3 0A18 90 SWAP1 0A19 92 SWAP3 0A1A 17 OR 0A1B 90 SWAP1 0A1C 91 SWAP2 0A1D 55 SSTORE 0A1E 60 PUSH1 0x0b 0A20 55 SSTORE 0A21 56 *JUMP 0A22 5B JUMPDEST 0A23 60 PUSH1 0x00 0A25 80 DUP1 0A26 51 MLOAD 0A27 60 PUSH1 0x20 0A29 61 PUSH2 0x271b 0A2C 83 DUP4 0A2D 39 CODECOPY 0A2E 81 DUP2 0A2F 51 MLOAD 0A30 91 SWAP2 0A31 52 MSTORE 0A32 61 PUSH2 0x0a3a 0A35 81 DUP2 0A36 61 PUSH2 0x0eaa 0A39 56 *JUMP 0A3A 5B JUMPDEST 0A3B 61 PUSH2 0x0813 0A3E 82 DUP3 0A3F 85 DUP6 0A40 85 DUP6 0A41 60 PUSH1 0x40 0A43 51 MLOAD 0A44 80 DUP1 0A45 60 PUSH1 0x20 0A47 01 ADD 0A48 60 PUSH1 0x40 0A4A 52 MSTORE 0A4B 80 DUP1 0A4C 60 PUSH1 0x00 0A4E 81 DUP2 0A4F 52 MSTORE 0A50 50 POP 0A51 61 PUSH2 0x1102 0A54 56 *JUMP label_0A55: // Incoming call from 0x03DE, returns to 0x022F // Inputs[1] { @0A5B storage[0x09] } 0A55 5B JUMPDEST 0A56 60 PUSH1 0x60 0A58 60 PUSH1 0x09 0A5A 80 DUP1 0A5B 54 SLOAD 0A5C 61 PUSH2 0x0a64 0A5F 90 SWAP1 0A60 61 PUSH2 0x1f30 0A63 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A56 stack[0] = 0x60 // @0A58 stack[1] = 0x09 // @0A5F stack[2] = 0x0a64 // @0A5F stack[3] = storage[0x09] // } // Block ends with call to 0x1f30, returns to 0x0A64 label_0A64: // Incoming return from call to 0x1F30 at 0x0A63 // Inputs[4] // { // @0A65 stack[-1] // @0A74 memory[0x40:0x60] // @0A7C stack[-2] // @0A87 storage[stack[-2]] // } 0A64 5B JUMPDEST 0A65 80 DUP1 0A66 60 PUSH1 0x1f 0A68 01 ADD 0A69 60 PUSH1 0x20 0A6B 80 DUP1 0A6C 91 SWAP2 0A6D 04 DIV 0A6E 02 MUL 0A6F 60 PUSH1 0x20 0A71 01 ADD 0A72 60 PUSH1 0x40 0A74 51 MLOAD 0A75 90 SWAP1 0A76 81 DUP2 0A77 01 ADD 0A78 60 PUSH1 0x40 0A7A 52 MSTORE 0A7B 80 DUP1 0A7C 92 SWAP3 0A7D 91 SWAP2 0A7E 90 SWAP1 0A7F 81 DUP2 0A80 81 DUP2 0A81 52 MSTORE 0A82 60 PUSH1 0x20 0A84 01 ADD 0A85 82 DUP3 0A86 80 DUP1 0A87 54 SLOAD 0A88 61 PUSH2 0x0a90 0A8B 90 SWAP1 0A8C 61 PUSH2 0x1f30 0A8F 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0A7A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0A7C stack[-2] = memory[0x40:0x60] // @0A7D stack[-1] = stack[-2] // @0A7E stack[0] = stack[-1] // @0A81 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0A84 stack[1] = 0x20 + memory[0x40:0x60] // @0A85 stack[2] = stack[-2] // @0A8B stack[4] = storage[stack[-2]] // @0A8B stack[3] = 0x0a90 // } // Block ends with call to 0x1f30, returns to 0x0A90 label_0A90: // Incoming return from call to 0x1F30 at 0x0A8F // Inputs[1] { @0A91 stack[-1] } 0A90 5B JUMPDEST 0A91 80 DUP1 0A92 15 ISZERO 0A93 61 PUSH2 0x0add 0A96 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0add, if !stack[-1] label_0A97: // Incoming jump from 0x0A96, if not !stack[-1] // Inputs[1] { @0A97 stack[-1] } 0A97 80 DUP1 0A98 60 PUSH1 0x1f 0A9A 10 LT 0A9B 61 PUSH2 0x0ab2 0A9E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ab2, if 0x1f < stack[-1] label_0A9F: // Incoming jump from 0x0A9E, if not 0x1f < stack[-1] // Inputs[4] // { // @0AA3 stack[-2] // @0AA4 storage[stack[-2]] // @0AA7 stack[-3] // @0AA9 stack[-1] // } 0A9F 61 PUSH2 0x0100 0AA2 80 DUP1 0AA3 83 DUP4 0AA4 54 SLOAD 0AA5 04 DIV 0AA6 02 MUL 0AA7 83 DUP4 0AA8 52 MSTORE 0AA9 91 SWAP2 0AAA 60 PUSH1 0x20 0AAC 01 ADD 0AAD 91 SWAP2 0AAE 61 PUSH2 0x0add 0AB1 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AA8 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0AAD stack[-1] = stack[-1] // @0AAD stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0add label_0AB2: // Incoming jump from 0x0A9E, if 0x1f < stack[-1] // Inputs[5] // { // @0AB3 stack[-3] // @0AB4 stack[-1] // @0AB6 stack[-2] // @0ABE memory[0x00:0x20] // @0AC2 storage[keccak256(memory[0x00:0x20])] // } 0AB2 5B JUMPDEST 0AB3 82 DUP3 0AB4 01 ADD 0AB5 91 SWAP2 0AB6 90 SWAP1 0AB7 60 PUSH1 0x00 0AB9 52 MSTORE 0ABA 60 PUSH1 0x20 0ABC 60 PUSH1 0x00 0ABE 20 SHA3 0ABF 90 SWAP1 0AC0 5B JUMPDEST 0AC1 81 DUP2 0AC2 54 SLOAD 0AC3 81 DUP2 0AC4 52 MSTORE 0AC5 90 SWAP1 0AC6 60 PUSH1 0x01 0AC8 01 ADD 0AC9 90 SWAP1 0ACA 60 PUSH1 0x20 0ACC 01 ADD 0ACD 80 DUP1 0ACE 83 DUP4 0ACF 11 GT 0AD0 61 PUSH2 0x0ac0 0AD3 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0AB5 stack[-3] = stack[-3] + stack[-1] // @0AB9 memory[0x00:0x20] = stack[-2] // @0AC4 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0AC9 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0ACC stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0ac0, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0AD4: // Incoming jump from 0x0AD3, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0AD3, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0AD4 stack[-3] // @0AD5 stack[-1] // } 0AD4 82 DUP3 0AD5 90 SWAP1 0AD6 03 SUB 0AD7 60 PUSH1 0x1f 0AD9 16 AND 0ADA 82 DUP3 0ADB 01 ADD 0ADC 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0ADC stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0ADC stack[-1] = stack[-3] // } // Block continues label_0ADD: // Incoming jump from 0x0A96, if !stack[-1] // Incoming jump from 0x0AB1 // Incoming jump from 0x0ADC // Inputs[3] // { // @0AE3 stack[-6] // @0AE3 stack[-7] // @0AE5 stack[-8] // } 0ADD 5B JUMPDEST 0ADE 50 POP 0ADF 50 POP 0AE0 50 POP 0AE1 50 POP 0AE2 50 POP 0AE3 90 SWAP1 0AE4 50 POP 0AE5 90 SWAP1 0AE6 56 *JUMP // Stack delta = -7 // Outputs[1] { @0AE5 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] 0AE7 5B JUMPDEST 0AE8 60 PUSH1 0x01 0AEA 60 PUSH1 0x01 0AEC 60 PUSH1 0xa0 0AEE 1B SHL 0AEF 03 SUB 0AF0 85 DUP6 0AF1 16 AND 0AF2 33 CALLER 0AF3 14 EQ 0AF4 80 DUP1 0AF5 61 PUSH2 0x0b03 0AF8 57 *JUMPI 0AF9 50 POP 0AFA 61 PUSH2 0x0b03 0AFD 85 DUP6 0AFE 33 CALLER 0AFF 61 PUSH2 0x03ed 0B02 56 *JUMP 0B03 5B JUMPDEST 0B04 61 PUSH2 0x0b1f 0B07 57 *JUMPI 0B08 60 PUSH1 0x40 0B0A 51 MLOAD 0B0B 62 PUSH3 0x461bcd 0B0F 60 PUSH1 0xe5 0B11 1B SHL 0B12 81 DUP2 0B13 52 MSTORE 0B14 60 PUSH1 0x04 0B16 01 ADD 0B17 61 PUSH2 0x047e 0B1A 90 SWAP1 0B1B 61 PUSH2 0x2144 0B1E 56 *JUMP 0B1F 5B JUMPDEST 0B20 61 PUSH2 0x0752 0B23 85 DUP6 0B24 85 DUP6 0B25 85 DUP6 0B26 85 DUP6 0B27 85 DUP6 0B28 61 PUSH2 0x11f9 0B2B 56 *JUMP 0B2C 5B JUMPDEST 0B2D 60 PUSH1 0x00 0B2F 80 DUP1 0B30 51 MLOAD 0B31 60 PUSH1 0x20 0B33 61 PUSH2 0x271b 0B36 83 DUP4 0B37 39 CODECOPY 0B38 81 DUP2 0B39 51 MLOAD 0B3A 91 SWAP2 0B3B 52 MSTORE 0B3C 61 PUSH2 0x0b44 0B3F 81 DUP2 0B40 61 PUSH2 0x0eaa 0B43 56 *JUMP 0B44 5B JUMPDEST 0B45 61 PUSH2 0x0b4e 0B48 85 DUP6 0B49 83 DUP4 0B4A 61 PUSH2 0x07dc 0B4D 56 *JUMP 0B4E 5B JUMPDEST 0B4F 61 PUSH2 0x0752 0B52 83 DUP4 0B53 86 DUP7 0B54 86 DUP7 0B55 60 PUSH1 0x40 0B57 51 MLOAD 0B58 80 DUP1 0B59 60 PUSH1 0x20 0B5B 01 ADD 0B5C 60 PUSH1 0x40 0B5E 52 MSTORE 0B5F 80 DUP1 0B60 60 PUSH1 0x00 0B62 81 DUP2 0B63 52 MSTORE 0B64 50 POP 0B65 61 PUSH2 0x1102 0B68 56 *JUMP label_0B69: // Incoming call from 0x14DA, returns to 0x14DB // Incoming call from 0x14E5, returns to 0x14E6 // Inputs[1] { @0B71 stack[-1] } 0B69 5B JUMPDEST 0B6A 60 PUSH1 0x60 0B6C 60 PUSH1 0x00 0B6E 61 PUSH2 0x0b78 0B71 83 DUP4 0B72 60 PUSH1 0x02 0B74 61 PUSH2 0x1f9d 0B77 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0B6A stack[0] = 0x60 // @0B6C stack[1] = 0x00 // @0B6E stack[2] = 0x0b78 // @0B71 stack[3] = stack[-1] // @0B72 stack[4] = 0x02 // } // Block ends with call to 0x1f9d, returns to 0x0B78 label_0B78: // Incoming return from call to 0x1F9D at 0x0B77 // Inputs[1] { @0B7C stack[-1] } 0B78 5B JUMPDEST 0B79 61 PUSH2 0x0b83 0B7C 90 SWAP1 0B7D 60 PUSH1 0x02 0B7F 61 PUSH2 0x2154 0B82 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B7C stack[0] = stack[-1] // @0B7C stack[-1] = 0x0b83 // @0B7D stack[1] = 0x02 // } // Block ends with call to 0x2154, returns to 0x0B83 label_0B83: // Incoming return from call to 0x2154 at 0x0B82 // Inputs[1] { @0B8C stack[-1] } 0B83 5B JUMPDEST 0B84 60 PUSH1 0x01 0B86 60 PUSH1 0x01 0B88 60 PUSH1 0x40 0B8A 1B SHL 0B8B 03 SUB 0B8C 81 DUP2 0B8D 11 GT 0B8E 15 ISZERO 0B8F 61 PUSH2 0x0b9a 0B92 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b9a, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_0B93: // Incoming jump from 0x0B92, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 0B93 61 PUSH2 0x0b9a 0B96 61 PUSH2 0x18b2 0B99 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B93 stack[0] = 0x0b9a } // Block ends with unconditional jump to 0x18b2 label_0B9A: // Incoming jump from 0x0B92, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @0B9D memory[0x40:0x60] // @0B9E stack[-1] // } 0B9A 5B JUMPDEST 0B9B 60 PUSH1 0x40 0B9D 51 MLOAD 0B9E 90 SWAP1 0B9F 80 DUP1 0BA0 82 DUP3 0BA1 52 MSTORE 0BA2 80 DUP1 0BA3 60 PUSH1 0x1f 0BA5 01 ADD 0BA6 60 PUSH1 0x1f 0BA8 19 NOT 0BA9 16 AND 0BAA 60 PUSH1 0x20 0BAC 01 ADD 0BAD 82 DUP3 0BAE 01 ADD 0BAF 60 PUSH1 0x40 0BB1 52 MSTORE 0BB2 80 DUP1 0BB3 15 ISZERO 0BB4 61 PUSH2 0x0bc4 0BB7 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0B9E stack[-1] = memory[0x40:0x60] // @0B9E stack[0] = stack[-1] // @0BA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0BB1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x0bc4, if !stack[-1] label_0BB8: // Incoming jump from 0x0BB7, if not !stack[-1] // Inputs[6] // { // @0BBA stack[-2] // @0BBC stack[-1] // @0BBE msg.data.length // @0BC0 msg.data[msg.data.length:msg.data.length + stack[-1]] // @0BC6 stack[-3] // @0BD1 memory[stack[-2]:stack[-2] + 0x20] // } 0BB8 60 PUSH1 0x20 0BBA 82 DUP3 0BBB 01 ADD 0BBC 81 DUP2 0BBD 80 DUP1 0BBE 36 CALLDATASIZE 0BBF 83 DUP4 0BC0 37 CALLDATACOPY 0BC1 01 ADD 0BC2 90 SWAP1 0BC3 50 POP 0BC4 5B JUMPDEST 0BC5 50 POP 0BC6 90 SWAP1 0BC7 50 POP 0BC8 60 PUSH1 0x03 0BCA 60 PUSH1 0xfc 0BCC 1B SHL 0BCD 81 DUP2 0BCE 60 PUSH1 0x00 0BD0 81 DUP2 0BD1 51 MLOAD 0BD2 81 DUP2 0BD3 10 LT 0BD4 61 PUSH2 0x0bdf 0BD7 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0BC0 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @0BC6 stack[-3] = stack[-2] // @0BCC stack[-2] = 0x03 << 0xfc // @0BCD stack[-1] = stack[-2] // @0BCE stack[0] = 0x00 // } // Block ends with conditional jump to 0x0bdf, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_0BD8: // Incoming jump from 0x0BD7, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0BD7, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 0BD8 61 PUSH2 0x0bdf 0BDB 61 PUSH2 0x20cd 0BDE 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BD8 stack[0] = 0x0bdf } // Block ends with unconditional jump to 0x20cd label_0BDF: // Incoming jump from 0x0BD7, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0BD7, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @0BE2 stack[-1] // @0BE3 stack[-2] // @0BE4 stack[-3] // @0BFC stack[-4] // @0C00 memory[stack[-4]:stack[-4] + 0x20] // } 0BDF 5B JUMPDEST 0BE0 60 PUSH1 0x20 0BE2 01 ADD 0BE3 01 ADD 0BE4 90 SWAP1 0BE5 60 PUSH1 0x01 0BE7 60 PUSH1 0x01 0BE9 60 PUSH1 0xf8 0BEB 1B SHL 0BEC 03 SUB 0BED 19 NOT 0BEE 16 AND 0BEF 90 SWAP1 0BF0 81 DUP2 0BF1 60 PUSH1 0x00 0BF3 1A BYTE 0BF4 90 SWAP1 0BF5 53 MSTORE8 0BF6 50 POP 0BF7 60 PUSH1 0x0f 0BF9 60 PUSH1 0xfb 0BFB 1B SHL 0BFC 81 DUP2 0BFD 60 PUSH1 0x01 0BFF 81 DUP2 0C00 51 MLOAD 0C01 81 DUP2 0C02 10 LT 0C03 61 PUSH2 0x0c0e 0C06 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0BF5 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @0BFB stack[-3] = 0x0f << 0xfb // @0BFC stack[-2] = stack[-4] // @0BFD stack[-1] = 0x01 // } // Block ends with conditional jump to 0x0c0e, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_0C07: // Incoming jump from 0x0C06, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 0C07 61 PUSH2 0x0c0e 0C0A 61 PUSH2 0x20cd 0C0D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C07 stack[0] = 0x0c0e } // Block ends with unconditional jump to 0x20cd label_0C0E: // Incoming jump from 0x0C06, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @0C11 stack[-1] // @0C12 stack[-2] // @0C13 stack[-3] // @0C2B stack[-6] // } 0C0E 5B JUMPDEST 0C0F 60 PUSH1 0x20 0C11 01 ADD 0C12 01 ADD 0C13 90 SWAP1 0C14 60 PUSH1 0x01 0C16 60 PUSH1 0x01 0C18 60 PUSH1 0xf8 0C1A 1B SHL 0C1B 03 SUB 0C1C 19 NOT 0C1D 16 AND 0C1E 90 SWAP1 0C1F 81 DUP2 0C20 60 PUSH1 0x00 0C22 1A BYTE 0C23 90 SWAP1 0C24 53 MSTORE8 0C25 50 POP 0C26 60 PUSH1 0x00 0C28 61 PUSH2 0x0c32 0C2B 84 DUP5 0C2C 60 PUSH1 0x02 0C2E 61 PUSH2 0x1f9d 0C31 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C24 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @0C26 stack[-3] = 0x00 // @0C28 stack[-2] = 0x0c32 // @0C2B stack[-1] = stack[-6] // @0C2C stack[0] = 0x02 // } // Block ends with call to 0x1f9d, returns to 0x0C32 label_0C32: // Incoming return from call to 0x1F9D at 0x0C31 // Inputs[1] { @0C36 stack[-1] } 0C32 5B JUMPDEST 0C33 61 PUSH2 0x0c3d 0C36 90 SWAP1 0C37 60 PUSH1 0x01 0C39 61 PUSH2 0x2154 0C3C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C36 stack[0] = stack[-1] // @0C36 stack[-1] = 0x0c3d // @0C37 stack[1] = 0x01 // } // Block ends with call to 0x2154, returns to 0x0C3D label_0C3D: // Incoming return from call to 0x2154 at 0x0C3C // Inputs[2] // { // @0C3E stack[-2] // @0C3E stack[-1] // } 0C3D 5B JUMPDEST 0C3E 90 SWAP1 0C3F 50 POP 0C40 5B JUMPDEST 0C41 60 PUSH1 0x01 0C43 81 DUP2 0C44 11 GT 0C45 15 ISZERO 0C46 61 PUSH2 0x0cb5 0C49 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0C3E stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0cb5, if !(stack[-1] > 0x01) label_0C4A: // Incoming jump from 0x0C49, if not !(stack[-1] > 0x01) // Incoming jump from 0x0C49, if not !(stack[-1] > 0x01) // Inputs[1] { @0C5E stack[-5] } 0C4A 6F PUSH16 0x181899199a1a9b1b9c1cb0b131b232b3 0C5B 60 PUSH1 0x81 0C5D 1B SHL 0C5E 85 DUP6 0C5F 60 PUSH1 0x0f 0C61 16 AND 0C62 60 PUSH1 0x10 0C64 81 DUP2 0C65 10 LT 0C66 61 PUSH2 0x0c71 0C69 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C5D stack[0] = 0x181899199a1a9b1b9c1cb0b131b232b3 << 0x81 // @0C61 stack[1] = 0x0f & stack[-5] // } // Block ends with conditional jump to 0x0c71, if 0x0f & stack[-5] < 0x10 label_0C6A: // Incoming jump from 0x0C69, if not 0x0f & stack[-5] < 0x10 0C6A 61 PUSH2 0x0c71 0C6D 61 PUSH2 0x20cd 0C70 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C6A stack[0] = 0x0c71 } // Block ends with unconditional jump to 0x20cd label_0C71: // Incoming jump from 0x0C69, if 0x0f & stack[-5] < 0x10 // Inputs[5] // { // @0C72 stack[-2] // @0C72 stack[-1] // @0C76 stack[-4] // @0C77 stack[-3] // @0C79 memory[stack[-4]:stack[-4] + 0x20] // } 0C71 5B JUMPDEST 0C72 1A BYTE 0C73 60 PUSH1 0xf8 0C75 1B SHL 0C76 82 DUP3 0C77 82 DUP3 0C78 81 DUP2 0C79 51 MLOAD 0C7A 81 DUP2 0C7B 10 LT 0C7C 61 PUSH2 0x0c87 0C7F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0C75 stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @0C76 stack[-1] = stack[-4] // @0C77 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x0c87, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_0C80: // Incoming jump from 0x0C7F, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 0C80 61 PUSH2 0x0c87 0C83 61 PUSH2 0x20cd 0C86 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C80 stack[0] = 0x0c87 } // Block ends with unconditional jump to 0x20cd label_0C87: // Incoming jump from 0x0C7F, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @0C8A stack[-1] // @0C8B stack[-2] // @0C8C stack[-3] // @0CA1 stack[-8] // @0CA2 stack[-4] // } 0C87 5B JUMPDEST 0C88 60 PUSH1 0x20 0C8A 01 ADD 0C8B 01 ADD 0C8C 90 SWAP1 0C8D 60 PUSH1 0x01 0C8F 60 PUSH1 0x01 0C91 60 PUSH1 0xf8 0C93 1B SHL 0C94 03 SUB 0C95 19 NOT 0C96 16 AND 0C97 90 SWAP1 0C98 81 DUP2 0C99 60 PUSH1 0x00 0C9B 1A BYTE 0C9C 90 SWAP1 0C9D 53 MSTORE8 0C9E 50 POP 0C9F 60 PUSH1 0x04 0CA1 94 SWAP5 0CA2 90 SWAP1 0CA3 94 SWAP5 0CA4 1C SHR 0CA5 93 SWAP4 0CA6 61 PUSH2 0x0cae 0CA9 81 DUP2 0CAA 61 PUSH2 0x216c 0CAD 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @0C9D memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @0CA5 stack[-4] = stack[-4] // @0CA5 stack[-8] = stack[-8] >> 0x04 // @0CA6 stack[-3] = 0x0cae // @0CA9 stack[-2] = stack[-4] // } // Block ends with call to 0x216c, returns to 0x0CAE label_0CAE: // Incoming return from call to 0x216C at 0x0CAD // Inputs[2] // { // @0CAF stack[-1] // @0CAF stack[-2] // } 0CAE 5B JUMPDEST 0CAF 90 SWAP1 0CB0 50 POP 0CB1 61 PUSH2 0x0c40 0CB4 56 *JUMP // Stack delta = -1 // Outputs[1] { @0CAF stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0c40 label_0CB5: // Incoming jump from 0x0C49, if !(stack[-1] > 0x01) // Incoming jump from 0x0C49, if !(stack[-1] > 0x01) // Inputs[1] { @0CB7 stack[-5] } 0CB5 5B JUMPDEST 0CB6 50 POP 0CB7 83 DUP4 0CB8 15 ISZERO 0CB9 61 PUSH2 0x0cd4 0CBC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cd4, if !stack[-5] label_0CBD: // Incoming jump from 0x0CBC, if not !stack[-5] // Inputs[1] { @0CBF memory[0x40:0x60] } 0CBD 60 PUSH1 0x40 0CBF 51 MLOAD 0CC0 62 PUSH3 0x461bcd 0CC4 60 PUSH1 0xe5 0CC6 1B SHL 0CC7 81 DUP2 0CC8 52 MSTORE 0CC9 60 PUSH1 0x04 0CCB 01 ADD 0CCC 61 PUSH2 0x047e 0CCF 90 SWAP1 0CD0 61 PUSH2 0x21b8 0CD3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CCF stack[0] = 0x047e // @0CCF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x21b8 label_0CD4: // Incoming jump from 0x0CBC, if !stack[-5] // Incoming return from call to 0x1808 at 0x184A // Inputs[3] // { // @0CD5 stack[-5] // @0CD5 stack[-1] // @0CD6 stack[-4] // } 0CD4 5B JUMPDEST 0CD5 93 SWAP4 0CD6 92 SWAP3 0CD7 50 POP 0CD8 50 POP 0CD9 50 POP 0CDA 56 *JUMP // Stack delta = -4 // Outputs[1] { @0CD5 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 0CDB 5B JUMPDEST 0CDC 60 PUSH1 0x00 0CDE 60 PUSH1 0x01 0CE0 60 PUSH1 0x01 0CE2 60 PUSH1 0xe0 0CE4 1B SHL 0CE5 03 SUB 0CE6 19 NOT 0CE7 82 DUP3 0CE8 16 AND 0CE9 63 PUSH4 0x7965db0b 0CEE 60 PUSH1 0xe0 0CF0 1B SHL 0CF1 14 EQ 0CF2 80 DUP1 0CF3 61 PUSH2 0x04aa 0CF6 57 *JUMPI 0CF7 50 POP 0CF8 61 PUSH2 0x04aa 0CFB 82 DUP3 0CFC 61 PUSH2 0x133d 0CFF 56 *JUMP 0D00 5B JUMPDEST 0D01 81 DUP2 0D02 51 MLOAD 0D03 83 DUP4 0D04 51 MLOAD 0D05 14 EQ 0D06 61 PUSH2 0x0d21 0D09 57 *JUMPI 0D0A 60 PUSH1 0x40 0D0C 51 MLOAD 0D0D 62 PUSH3 0x461bcd 0D11 60 PUSH1 0xe5 0D13 1B SHL 0D14 81 DUP2 0D15 52 MSTORE 0D16 60 PUSH1 0x04 0D18 01 ADD 0D19 61 PUSH2 0x047e 0D1C 90 SWAP1 0D1D 61 PUSH2 0x220d 0D20 56 *JUMP 0D21 5B JUMPDEST 0D22 60 PUSH1 0x01 0D24 60 PUSH1 0x01 0D26 60 PUSH1 0xa0 0D28 1B SHL 0D29 03 SUB 0D2A 84 DUP5 0D2B 16 AND 0D2C 61 PUSH2 0x0d47 0D2F 57 *JUMPI 0D30 60 PUSH1 0x40 0D32 51 MLOAD 0D33 62 PUSH3 0x461bcd 0D37 60 PUSH1 0xe5 0D39 1B SHL 0D3A 81 DUP2 0D3B 52 MSTORE 0D3C 60 PUSH1 0x04 0D3E 01 ADD 0D3F 61 PUSH2 0x047e 0D42 90 SWAP1 0D43 61 PUSH2 0x225f 0D46 56 *JUMP 0D47 5B JUMPDEST 0D48 33 CALLER 0D49 61 PUSH2 0x0d56 0D4C 81 DUP2 0D4D 87 DUP8 0D4E 87 DUP8 0D4F 87 DUP8 0D50 87 DUP8 0D51 87 DUP8 0D52 61 PUSH2 0x138d 0D55 56 *JUMP 0D56 5B JUMPDEST 0D57 60 PUSH1 0x00 0D59 5B JUMPDEST 0D5A 84 DUP5 0D5B 51 MLOAD 0D5C 81 DUP2 0D5D 10 LT 0D5E 15 ISZERO 0D5F 61 PUSH2 0x0e3c 0D62 57 *JUMPI 0D63 60 PUSH1 0x00 0D65 85 DUP6 0D66 82 DUP3 0D67 81 DUP2 0D68 51 MLOAD 0D69 81 DUP2 0D6A 10 LT 0D6B 61 PUSH2 0x0d76 0D6E 57 *JUMPI 0D6F 61 PUSH2 0x0d76 0D72 61 PUSH2 0x20cd 0D75 56 *JUMP 0D76 5B JUMPDEST 0D77 60 PUSH1 0x20 0D79 02 MUL 0D7A 60 PUSH1 0x20 0D7C 01 ADD 0D7D 01 ADD 0D7E 51 MLOAD 0D7F 90 SWAP1 0D80 50 POP 0D81 60 PUSH1 0x00 0D83 85 DUP6 0D84 83 DUP4 0D85 81 DUP2 0D86 51 MLOAD 0D87 81 DUP2 0D88 10 LT 0D89 61 PUSH2 0x0d94 0D8C 57 *JUMPI 0D8D 61 PUSH2 0x0d94 0D90 61 PUSH2 0x20cd 0D93 56 *JUMP 0D94 5B JUMPDEST 0D95 60 PUSH1 0x20 0D97 90 SWAP1 0D98 81 DUP2 0D99 02 MUL 0D9A 91 SWAP2 0D9B 90 SWAP1 0D9C 91 SWAP2 0D9D 01 ADD 0D9E 81 DUP2 0D9F 01 ADD 0DA0 51 MLOAD 0DA1 60 PUSH1 0x00 0DA3 84 DUP5 0DA4 81 DUP2 0DA5 52 MSTORE 0DA6 80 DUP1 0DA7 83 DUP4 0DA8 52 MSTORE 0DA9 60 PUSH1 0x40 0DAB 80 DUP1 0DAC 82 DUP3 0DAD 20 SHA3 0DAE 60 PUSH1 0x01 0DB0 60 PUSH1 0x01 0DB2 60 PUSH1 0xa0 0DB4 1B SHL 0DB5 03 SUB 0DB6 8E DUP15 0DB7 16 AND 0DB8 83 DUP4 0DB9 52 MSTORE 0DBA 90 SWAP1 0DBB 93 SWAP4 0DBC 52 MSTORE 0DBD 91 SWAP2 0DBE 90 SWAP1 0DBF 91 SWAP2 0DC0 20 SHA3 0DC1 54 SLOAD 0DC2 90 SWAP1 0DC3 91 SWAP2 0DC4 50 POP 0DC5 81 DUP2 0DC6 81 DUP2 0DC7 10 LT 0DC8 15 ISZERO 0DC9 61 PUSH2 0x0de4 0DCC 57 *JUMPI 0DCD 60 PUSH1 0x40 0DCF 51 MLOAD 0DD0 62 PUSH3 0x461bcd 0DD4 60 PUSH1 0xe5 0DD6 1B SHL 0DD7 81 DUP2 0DD8 52 MSTORE 0DD9 60 PUSH1 0x04 0DDB 01 ADD 0DDC 61 PUSH2 0x047e 0DDF 90 SWAP1 0DE0 61 PUSH2 0x22b6 0DE3 56 *JUMP 0DE4 5B JUMPDEST 0DE5 60 PUSH1 0x00 0DE7 83 DUP4 0DE8 81 DUP2 0DE9 52 MSTORE 0DEA 60 PUSH1 0x20 0DEC 81 DUP2 0DED 81 DUP2 0DEE 52 MSTORE 0DEF 60 PUSH1 0x40 0DF1 80 DUP1 0DF2 83 DUP4 0DF3 20 SHA3 0DF4 60 PUSH1 0x01 0DF6 60 PUSH1 0x01 0DF8 60 PUSH1 0xa0 0DFA 1B SHL 0DFB 03 SUB 0DFC 8E DUP15 0DFD 81 DUP2 0DFE 16 AND 0DFF 85 DUP6 0E00 52 MSTORE 0E01 92 SWAP3 0E02 52 MSTORE 0E03 80 DUP1 0E04 83 DUP4 0E05 20 SHA3 0E06 85 DUP6 0E07 85 DUP6 0E08 03 SUB 0E09 90 SWAP1 0E0A 55 SSTORE 0E0B 90 SWAP1 0E0C 8B DUP12 0E0D 16 AND 0E0E 82 DUP3 0E0F 52 MSTORE 0E10 81 DUP2 0E11 20 SHA3 0E12 80 DUP1 0E13 54 SLOAD 0E14 84 DUP5 0E15 92 SWAP3 0E16 90 SWAP1 0E17 61 PUSH2 0x0e21 0E1A 90 SWAP1 0E1B 84 DUP5 0E1C 90 SWAP1 0E1D 61 PUSH2 0x2154 0E20 56 *JUMP 0E21 5B JUMPDEST 0E22 92 SWAP3 0E23 50 POP 0E24 50 POP 0E25 81 DUP2 0E26 90 SWAP1 0E27 55 SSTORE 0E28 50 POP 0E29 50 POP 0E2A 50 POP 0E2B 50 POP 0E2C 80 DUP1 0E2D 61 PUSH2 0x0e35 0E30 90 SWAP1 0E31 61 PUSH2 0x20e3 0E34 56 *JUMP 0E35 5B JUMPDEST 0E36 90 SWAP1 0E37 50 POP 0E38 61 PUSH2 0x0d59 0E3B 56 *JUMP 0E3C 5B JUMPDEST 0E3D 50 POP 0E3E 84 DUP5 0E3F 60 PUSH1 0x01 0E41 60 PUSH1 0x01 0E43 60 PUSH1 0xa0 0E45 1B SHL 0E46 03 SUB 0E47 16 AND 0E48 86 DUP7 0E49 60 PUSH1 0x01 0E4B 60 PUSH1 0x01 0E4D 60 PUSH1 0xa0 0E4F 1B SHL 0E50 03 SUB 0E51 16 AND 0E52 82 DUP3 0E53 60 PUSH1 0x01 0E55 60 PUSH1 0x01 0E57 60 PUSH1 0xa0 0E59 1B SHL 0E5A 03 SUB 0E5B 16 AND 0E5C 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 0E7D 87 DUP8 0E7E 87 DUP8 0E7F 60 PUSH1 0x40 0E81 51 MLOAD 0E82 61 PUSH2 0x0e8c 0E85 92 SWAP3 0E86 91 SWAP2 0E87 90 SWAP1 0E88 61 PUSH2 0x22c6 0E8B 56 *JUMP 0E8C 5B JUMPDEST 0E8D 60 PUSH1 0x40 0E8F 51 MLOAD 0E90 80 DUP1 0E91 91 SWAP2 0E92 03 SUB 0E93 90 SWAP1 0E94 A4 LOG4 0E95 61 PUSH2 0x0ea2 0E98 81 DUP2 0E99 87 DUP8 0E9A 87 DUP8 0E9B 87 DUP8 0E9C 87 DUP8 0E9D 87 DUP8 0E9E 61 PUSH2 0x139b 0EA1 56 *JUMP 0EA2 5B JUMPDEST 0EA3 50 POP 0EA4 50 POP 0EA5 50 POP 0EA6 50 POP 0EA7 50 POP 0EA8 50 POP 0EA9 56 *JUMP label_0EAA: // Incoming jump from 0x0823 // Incoming jump from 0x093E // Inputs[2] // { // @0EAE stack[-1] // @0EAF msg.sender // } 0EAA 5B JUMPDEST 0EAB 61 PUSH2 0x082c 0EAE 81 DUP2 0EAF 33 CALLER 0EB0 61 PUSH2 0x14b9 0EB3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EAB stack[0] = 0x082c // @0EAE stack[1] = stack[-1] // @0EAF stack[2] = msg.sender // } // Block ends with call to 0x14b9, returns to 0x082C 0EB4 5B JUMPDEST 0EB5 61 PUSH2 0x0ebe 0EB8 82 DUP3 0EB9 82 DUP3 0EBA 61 PUSH2 0x0947 0EBD 56 *JUMP 0EBE 5B JUMPDEST 0EBF 61 PUSH2 0x07b5 0EC2 57 *JUMPI 0EC3 60 PUSH1 0x00 0EC5 82 DUP3 0EC6 81 DUP2 0EC7 52 MSTORE 0EC8 60 PUSH1 0x03 0ECA 60 PUSH1 0x20 0ECC 90 SWAP1 0ECD 81 DUP2 0ECE 52 MSTORE 0ECF 60 PUSH1 0x40 0ED1 80 DUP1 0ED2 83 DUP4 0ED3 20 SHA3 0ED4 60 PUSH1 0x01 0ED6 60 PUSH1 0x01 0ED8 60 PUSH1 0xa0 0EDA 1B SHL 0EDB 03 SUB 0EDC 85 DUP6 0EDD 16 AND 0EDE 84 DUP5 0EDF 52 MSTORE 0EE0 90 SWAP1 0EE1 91 SWAP2 0EE2 52 MSTORE 0EE3 90 SWAP1 0EE4 20 SHA3 0EE5 80 DUP1 0EE6 54 SLOAD 0EE7 60 PUSH1 0xff 0EE9 19 NOT 0EEA 16 AND 0EEB 60 PUSH1 0x01 0EED 17 OR 0EEE 90 SWAP1 0EEF 55 SSTORE 0EF0 61 PUSH2 0x0ef6 0EF3 33 CALLER 0EF4 90 SWAP1 0EF5 56 *JUMP 0EF6 5B JUMPDEST 0EF7 60 PUSH1 0x01 0EF9 60 PUSH1 0x01 0EFB 60 PUSH1 0xa0 0EFD 1B SHL 0EFE 03 SUB 0EFF 16 AND 0F00 81 DUP2 0F01 60 PUSH1 0x01 0F03 60 PUSH1 0x01 0F05 60 PUSH1 0xa0 0F07 1B SHL 0F08 03 SUB 0F09 16 AND 0F0A 83 DUP4 0F0B 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 0F2C 60 PUSH1 0x40 0F2E 51 MLOAD 0F2F 60 PUSH1 0x40 0F31 51 MLOAD 0F32 80 DUP1 0F33 91 SWAP2 0F34 03 SUB 0F35 90 SWAP1 0F36 A4 LOG4 0F37 50 POP 0F38 50 POP 0F39 56 *JUMP 0F3A 5B JUMPDEST 0F3B 61 PUSH2 0x0f44 0F3E 82 DUP3 0F3F 82 DUP3 0F40 61 PUSH2 0x0947 0F43 56 *JUMP 0F44 5B JUMPDEST 0F45 15 ISZERO 0F46 61 PUSH2 0x07b5 0F49 57 *JUMPI 0F4A 60 PUSH1 0x00 0F4C 82 DUP3 0F4D 81 DUP2 0F4E 52 MSTORE 0F4F 60 PUSH1 0x03 0F51 60 PUSH1 0x20 0F53 90 SWAP1 0F54 81 DUP2 0F55 52 MSTORE 0F56 60 PUSH1 0x40 0F58 80 DUP1 0F59 83 DUP4 0F5A 20 SHA3 0F5B 60 PUSH1 0x01 0F5D 60 PUSH1 0x01 0F5F 60 PUSH1 0xa0 0F61 1B SHL 0F62 03 SUB 0F63 85 DUP6 0F64 16 AND 0F65 80 DUP1 0F66 85 DUP6 0F67 52 MSTORE 0F68 92 SWAP3 0F69 52 MSTORE 0F6A 80 DUP1 0F6B 83 DUP4 0F6C 20 SHA3 0F6D 80 DUP1 0F6E 54 SLOAD 0F6F 60 PUSH1 0xff 0F71 19 NOT 0F72 16 AND 0F73 90 SWAP1 0F74 55 SSTORE 0F75 51 MLOAD 0F76 33 CALLER 0F77 92 SWAP3 0F78 85 DUP6 0F79 91 SWAP2 0F7A 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 0F9B 91 SWAP2 0F9C 90 SWAP1 0F9D A4 LOG4 0F9E 50 POP 0F9F 50 POP 0FA0 56 *JUMP 0FA1 5B JUMPDEST 0FA2 60 PUSH1 0x04 0FA4 54 SLOAD 0FA5 60 PUSH1 0xff 0FA7 16 AND 0FA8 61 PUSH2 0x0fc3 0FAB 57 *JUMPI 0FAC 60 PUSH1 0x40 0FAE 51 MLOAD 0FAF 62 PUSH3 0x461bcd 0FB3 60 PUSH1 0xe5 0FB5 1B SHL 0FB6 81 DUP2 0FB7 52 MSTORE 0FB8 60 PUSH1 0x04 0FBA 01 ADD 0FBB 61 PUSH2 0x047e 0FBE 90 SWAP1 0FBF 61 PUSH2 0x2316 0FC2 56 *JUMP 0FC3 5B JUMPDEST 0FC4 60 PUSH1 0x04 0FC6 80 DUP1 0FC7 54 SLOAD 0FC8 60 PUSH1 0xff 0FCA 19 NOT 0FCB 16 AND 0FCC 90 SWAP1 0FCD 55 SSTORE 0FCE 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 0FEF 33 CALLER 0FF0 5B JUMPDEST 0FF1 60 PUSH1 0x40 0FF3 51 MLOAD 0FF4 61 PUSH2 0x0ffd 0FF7 91 SWAP2 0FF8 90 SWAP1 0FF9 61 PUSH2 0x2326 0FFC 56 *JUMP 0FFD 5B JUMPDEST 0FFE 60 PUSH1 0x40 1000 51 MLOAD 1001 80 DUP1 1002 91 SWAP2 1003 03 SUB 1004 90 SWAP1 1005 A1 LOG1 1006 56 *JUMP 1007 5B JUMPDEST 1008 60 PUSH1 0x04 100A 54 SLOAD 100B 60 PUSH1 0xff 100D 16 AND 100E 15 ISZERO 100F 61 PUSH2 0x102a 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 0x04 1021 01 ADD 1022 61 PUSH2 0x047e 1025 90 SWAP1 1026 61 PUSH2 0x235b 1029 56 *JUMP 102A 5B JUMPDEST 102B 60 PUSH1 0x04 102D 80 DUP1 102E 54 SLOAD 102F 60 PUSH1 0xff 1031 19 NOT 1032 16 AND 1033 60 PUSH1 0x01 1035 17 OR 1036 90 SWAP1 1037 55 SSTORE 1038 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 1059 61 PUSH2 0x0ff0 105C 33 CALLER 105D 90 SWAP1 105E 56 *JUMP 105F 5B JUMPDEST 1060 81 DUP2 1061 60 PUSH1 0x01 1063 60 PUSH1 0x01 1065 60 PUSH1 0xa0 1067 1B SHL 1068 03 SUB 1069 16 AND 106A 83 DUP4 106B 60 PUSH1 0x01 106D 60 PUSH1 0x01 106F 60 PUSH1 0xa0 1071 1B SHL 1072 03 SUB 1073 16 AND 1074 14 EQ 1075 15 ISZERO 1076 61 PUSH2 0x1091 1079 57 *JUMPI 107A 60 PUSH1 0x40 107C 51 MLOAD 107D 62 PUSH3 0x461bcd 1081 60 PUSH1 0xe5 1083 1B SHL 1084 81 DUP2 1085 52 MSTORE 1086 60 PUSH1 0x04 1088 01 ADD 1089 61 PUSH2 0x047e 108C 90 SWAP1 108D 61 PUSH2 0x23b1 1090 56 *JUMP 1091 5B JUMPDEST 1092 60 PUSH1 0x01 1094 60 PUSH1 0x01 1096 60 PUSH1 0xa0 1098 1B SHL 1099 03 SUB 109A 83 DUP4 109B 81 DUP2 109C 16 AND 109D 60 PUSH1 0x00 109F 81 DUP2 10A0 81 DUP2 10A1 52 MSTORE 10A2 60 PUSH1 0x01 10A4 60 PUSH1 0x20 10A6 90 SWAP1 10A7 81 DUP2 10A8 52 MSTORE 10A9 60 PUSH1 0x40 10AB 80 DUP1 10AC 83 DUP4 10AD 20 SHA3 10AE 94 SWAP5 10AF 87 DUP8 10B0 16 AND 10B1 80 DUP1 10B2 84 DUP5 10B3 52 MSTORE 10B4 94 SWAP5 10B5 90 SWAP1 10B6 91 SWAP2 10B7 52 MSTORE 10B8 90 SWAP1 10B9 81 DUP2 10BA 90 SWAP1 10BB 20 SHA3 10BC 80 DUP1 10BD 54 SLOAD 10BE 60 PUSH1 0xff 10C0 19 NOT 10C1 16 AND 10C2 85 DUP6 10C3 15 ISZERO 10C4 15 ISZERO 10C5 17 OR 10C6 90 SWAP1 10C7 55 SSTORE 10C8 51 MLOAD 10C9 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 10EA 90 SWAP1 10EB 61 PUSH2 0x10f5 10EE 90 SWAP1 10EF 85 DUP6 10F0 90 SWAP1 10F1 61 PUSH2 0x17ce 10F4 56 *JUMP 10F5 5B JUMPDEST 10F6 60 PUSH1 0x40 10F8 51 MLOAD 10F9 80 DUP1 10FA 91 SWAP2 10FB 03 SUB 10FC 90 SWAP1 10FD A3 LOG3 10FE 50 POP 10FF 50 POP 1100 50 POP 1101 56 *JUMP 1102 5B JUMPDEST 1103 60 PUSH1 0x01 1105 60 PUSH1 0x01 1107 60 PUSH1 0xa0 1109 1B SHL 110A 03 SUB 110B 84 DUP5 110C 16 AND 110D 61 PUSH2 0x1128 1110 57 *JUMPI 1111 60 PUSH1 0x40 1113 51 MLOAD 1114 62 PUSH3 0x461bcd 1118 60 PUSH1 0xe5 111A 1B SHL 111B 81 DUP2 111C 52 MSTORE 111D 60 PUSH1 0x04 111F 01 ADD 1120 61 PUSH2 0x047e 1123 90 SWAP1 1124 61 PUSH2 0x23ff 1127 56 *JUMP 1128 5B JUMPDEST 1129 33 CALLER 112A 60 PUSH1 0x00 112C 61 PUSH2 0x1134 112F 85 DUP6 1130 61 PUSH2 0x151d 1133 56 *JUMP 1134 5B JUMPDEST 1135 90 SWAP1 1136 50 POP 1137 60 PUSH1 0x00 1139 61 PUSH2 0x1141 113C 85 DUP6 113D 61 PUSH2 0x151d 1140 56 *JUMP 1141 5B JUMPDEST 1142 90 SWAP1 1143 50 POP 1144 61 PUSH2 0x1152 1147 83 DUP4 1148 60 PUSH1 0x00 114A 89 DUP10 114B 85 DUP6 114C 85 DUP6 114D 89 DUP10 114E 61 PUSH2 0x138d 1151 56 *JUMP 1152 5B JUMPDEST 1153 60 PUSH1 0x00 1155 86 DUP7 1156 81 DUP2 1157 52 MSTORE 1158 60 PUSH1 0x20 115A 81 DUP2 115B 81 DUP2 115C 52 MSTORE 115D 60 PUSH1 0x40 115F 80 DUP1 1160 83 DUP4 1161 20 SHA3 1162 60 PUSH1 0x01 1164 60 PUSH1 0x01 1166 60 PUSH1 0xa0 1168 1B SHL 1169 03 SUB 116A 8B DUP12 116B 16 AND 116C 84 DUP5 116D 52 MSTORE 116E 90 SWAP1 116F 91 SWAP2 1170 52 MSTORE 1171 81 DUP2 1172 20 SHA3 1173 80 DUP1 1174 54 SLOAD 1175 87 DUP8 1176 92 SWAP3 1177 90 SWAP1 1178 61 PUSH2 0x1182 117B 90 SWAP1 117C 84 DUP5 117D 90 SWAP1 117E 61 PUSH2 0x2154 1181 56 *JUMP 1182 5B JUMPDEST 1183 92 SWAP3 1184 50 POP 1185 50 POP 1186 81 DUP2 1187 90 SWAP1 1188 55 SSTORE 1189 50 POP 118A 86 DUP7 118B 60 PUSH1 0x01 118D 60 PUSH1 0x01 118F 60 PUSH1 0xa0 1191 1B SHL 1192 03 SUB 1193 16 AND 1194 60 PUSH1 0x00 1196 60 PUSH1 0x01 1198 60 PUSH1 0x01 119A 60 PUSH1 0xa0 119C 1B SHL 119D 03 SUB 119E 16 AND 119F 84 DUP5 11A0 60 PUSH1 0x01 11A2 60 PUSH1 0x01 11A4 60 PUSH1 0xa0 11A6 1B SHL 11A7 03 SUB 11A8 16 AND 11A9 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 11CA 89 DUP10 11CB 89 DUP10 11CC 60 PUSH1 0x40 11CE 51 MLOAD 11CF 61 PUSH2 0x11d9 11D2 92 SWAP3 11D3 91 SWAP2 11D4 90 SWAP1 11D5 61 PUSH2 0x240f 11D8 56 *JUMP 11D9 5B JUMPDEST 11DA 60 PUSH1 0x40 11DC 51 MLOAD 11DD 80 DUP1 11DE 91 SWAP2 11DF 03 SUB 11E0 90 SWAP1 11E1 A4 LOG4 11E2 61 PUSH2 0x11f0 11E5 83 DUP4 11E6 60 PUSH1 0x00 11E8 89 DUP10 11E9 89 DUP10 11EA 89 DUP10 11EB 89 DUP10 11EC 61 PUSH2 0x1568 11EF 56 *JUMP 11F0 5B JUMPDEST 11F1 50 POP 11F2 50 POP 11F3 50 POP 11F4 50 POP 11F5 50 POP 11F6 50 POP 11F7 50 POP 11F8 56 *JUMP 11F9 5B JUMPDEST 11FA 60 PUSH1 0x01 11FC 60 PUSH1 0x01 11FE 60 PUSH1 0xa0 1200 1B SHL 1201 03 SUB 1202 84 DUP5 1203 16 AND 1204 61 PUSH2 0x121f 1207 57 *JUMPI 1208 60 PUSH1 0x40 120A 51 MLOAD 120B 62 PUSH3 0x461bcd 120F 60 PUSH1 0xe5 1211 1B SHL 1212 81 DUP2 1213 52 MSTORE 1214 60 PUSH1 0x04 1216 01 ADD 1217 61 PUSH2 0x047e 121A 90 SWAP1 121B 61 PUSH2 0x225f 121E 56 *JUMP 121F 5B JUMPDEST 1220 33 CALLER 1221 60 PUSH1 0x00 1223 61 PUSH2 0x122b 1226 85 DUP6 1227 61 PUSH2 0x151d 122A 56 *JUMP 122B 5B JUMPDEST 122C 90 SWAP1 122D 50 POP 122E 60 PUSH1 0x00 1230 61 PUSH2 0x1238 1233 85 DUP6 1234 61 PUSH2 0x151d 1237 56 *JUMP 1238 5B JUMPDEST 1239 90 SWAP1 123A 50 POP 123B 61 PUSH2 0x1248 123E 83 DUP4 123F 89 DUP10 1240 89 DUP10 1241 85 DUP6 1242 85 DUP6 1243 89 DUP10 1244 61 PUSH2 0x138d 1247 56 *JUMP 1248 5B JUMPDEST 1249 60 PUSH1 0x00 124B 86 DUP7 124C 81 DUP2 124D 52 MSTORE 124E 60 PUSH1 0x20 1250 81 DUP2 1251 81 DUP2 1252 52 MSTORE 1253 60 PUSH1 0x40 1255 80 DUP1 1256 83 DUP4 1257 20 SHA3 1258 60 PUSH1 0x01 125A 60 PUSH1 0x01 125C 60 PUSH1 0xa0 125E 1B SHL 125F 03 SUB 1260 8C DUP13 1261 16 AND 1262 84 DUP5 1263 52 MSTORE 1264 90 SWAP1 1265 91 SWAP2 1266 52 MSTORE 1267 90 SWAP1 1268 20 SHA3 1269 54 SLOAD 126A 85 DUP6 126B 81 DUP2 126C 10 LT 126D 15 ISZERO 126E 61 PUSH2 0x1289 1271 57 *JUMPI 1272 60 PUSH1 0x40 1274 51 MLOAD 1275 62 PUSH3 0x461bcd 1279 60 PUSH1 0xe5 127B 1B SHL 127C 81 DUP2 127D 52 MSTORE 127E 60 PUSH1 0x04 1280 01 ADD 1281 61 PUSH2 0x047e 1284 90 SWAP1 1285 61 PUSH2 0x22b6 1288 56 *JUMP 1289 5B JUMPDEST 128A 60 PUSH1 0x00 128C 87 DUP8 128D 81 DUP2 128E 52 MSTORE 128F 60 PUSH1 0x20 1291 81 DUP2 1292 81 DUP2 1293 52 MSTORE 1294 60 PUSH1 0x40 1296 80 DUP1 1297 83 DUP4 1298 20 SHA3 1299 60 PUSH1 0x01 129B 60 PUSH1 0x01 129D 60 PUSH1 0xa0 129F 1B SHL 12A0 03 SUB 12A1 8D DUP14 12A2 81 DUP2 12A3 16 AND 12A4 85 DUP6 12A5 52 MSTORE 12A6 92 SWAP3 12A7 52 MSTORE 12A8 80 DUP1 12A9 83 DUP4 12AA 20 SHA3 12AB 89 DUP10 12AC 85 DUP6 12AD 03 SUB 12AE 90 SWAP1 12AF 55 SSTORE 12B0 90 SWAP1 12B1 8A DUP11 12B2 16 AND 12B3 82 DUP3 12B4 52 MSTORE 12B5 81 DUP2 12B6 20 SHA3 12B7 80 DUP1 12B8 54 SLOAD 12B9 88 DUP9 12BA 92 SWAP3 12BB 90 SWAP1 12BC 61 PUSH2 0x12c6 12BF 90 SWAP1 12C0 84 DUP5 12C1 90 SWAP1 12C2 61 PUSH2 0x2154 12C5 56 *JUMP 12C6 5B JUMPDEST 12C7 92 SWAP3 12C8 50 POP 12C9 50 POP 12CA 81 DUP2 12CB 90 SWAP1 12CC 55 SSTORE 12CD 50 POP 12CE 87 DUP8 12CF 60 PUSH1 0x01 12D1 60 PUSH1 0x01 12D3 60 PUSH1 0xa0 12D5 1B SHL 12D6 03 SUB 12D7 16 AND 12D8 89 DUP10 12D9 60 PUSH1 0x01 12DB 60 PUSH1 0x01 12DD 60 PUSH1 0xa0 12DF 1B SHL 12E0 03 SUB 12E1 16 AND 12E2 85 DUP6 12E3 60 PUSH1 0x01 12E5 60 PUSH1 0x01 12E7 60 PUSH1 0xa0 12E9 1B SHL 12EA 03 SUB 12EB 16 AND 12EC 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 130D 8A DUP11 130E 8A DUP11 130F 60 PUSH1 0x40 1311 51 MLOAD 1312 61 PUSH2 0x131c 1315 92 SWAP3 1316 91 SWAP2 1317 90 SWAP1 1318 61 PUSH2 0x240f 131B 56 *JUMP 131C 5B JUMPDEST 131D 60 PUSH1 0x40 131F 51 MLOAD 1320 80 DUP1 1321 91 SWAP2 1322 03 SUB 1323 90 SWAP1 1324 A4 LOG4 1325 61 PUSH2 0x1332 1328 84 DUP5 1329 8A DUP11 132A 8A DUP11 132B 8A DUP11 132C 8A DUP11 132D 8A DUP11 132E 61 PUSH2 0x1568 1331 56 *JUMP 1332 5B JUMPDEST 1333 50 POP 1334 50 POP 1335 50 POP 1336 50 POP 1337 50 POP 1338 50 POP 1339 50 POP 133A 50 POP 133B 50 POP 133C 56 *JUMP 133D 5B JUMPDEST 133E 60 PUSH1 0x00 1340 60 PUSH1 0x01 1342 60 PUSH1 0x01 1344 60 PUSH1 0xe0 1346 1B SHL 1347 03 SUB 1348 19 NOT 1349 82 DUP3 134A 16 AND 134B 63 PUSH4 0x6cdb3d13 1350 60 PUSH1 0xe1 1352 1B SHL 1353 14 EQ 1354 80 DUP1 1355 61 PUSH2 0x136e 1358 57 *JUMPI 1359 50 POP 135A 60 PUSH1 0x01 135C 60 PUSH1 0x01 135E 60 PUSH1 0xe0 1360 1B SHL 1361 03 SUB 1362 19 NOT 1363 82 DUP3 1364 16 AND 1365 63 PUSH4 0x03a24d07 136A 60 PUSH1 0xe2 136C 1B SHL 136D 14 EQ 136E 5B JUMPDEST 136F 80 DUP1 1370 61 PUSH2 0x04aa 1373 57 *JUMPI 1374 50 POP 1375 63 PUSH4 0x01ffc9a7 137A 60 PUSH1 0xe0 137C 1B SHL 137D 60 PUSH1 0x01 137F 60 PUSH1 0x01 1381 60 PUSH1 0xe0 1383 1B SHL 1384 03 SUB 1385 19 NOT 1386 83 DUP4 1387 16 AND 1388 14 EQ 1389 61 PUSH2 0x04aa 138C 56 *JUMP 138D 5B JUMPDEST 138E 61 PUSH2 0x0ea2 1391 86 DUP7 1392 86 DUP7 1393 86 DUP7 1394 86 DUP7 1395 86 DUP7 1396 86 DUP7 1397 61 PUSH2 0x1632 139A 56 *JUMP 139B 5B JUMPDEST 139C 60 PUSH1 0x01 139E 60 PUSH1 0x01 13A0 60 PUSH1 0xa0 13A2 1B SHL 13A3 03 SUB 13A4 84 DUP5 13A5 16 AND 13A6 3B EXTCODESIZE 13A7 15 ISZERO 13A8 61 PUSH2 0x0ea2 13AB 57 *JUMPI 13AC 60 PUSH1 0x40 13AE 51 MLOAD 13AF 63 PUSH4 0xbc197c81 13B4 60 PUSH1 0xe0 13B6 1B SHL 13B7 81 DUP2 13B8 52 MSTORE 13B9 60 PUSH1 0x01 13BB 60 PUSH1 0x01 13BD 60 PUSH1 0xa0 13BF 1B SHL 13C0 03 SUB 13C1 85 DUP6 13C2 16 AND 13C3 90 SWAP1 13C4 63 PUSH4 0xbc197c81 13C9 90 SWAP1 13CA 61 PUSH2 0x13df 13CD 90 SWAP1 13CE 89 DUP10 13CF 90 SWAP1 13D0 89 DUP10 13D1 90 SWAP1 13D2 88 DUP9 13D3 90 SWAP1 13D4 88 DUP9 13D5 90 SWAP1 13D6 88 DUP9 13D7 90 SWAP1 13D8 60 PUSH1 0x04 13DA 01 ADD 13DB 61 PUSH2 0x241d 13DE 56 *JUMP 13DF 5B JUMPDEST 13E0 60 PUSH1 0x20 13E2 60 PUSH1 0x40 13E4 51 MLOAD 13E5 80 DUP1 13E6 83 DUP4 13E7 03 SUB 13E8 81 DUP2 13E9 60 PUSH1 0x00 13EB 87 DUP8 13EC 80 DUP1 13ED 3B EXTCODESIZE 13EE 15 ISZERO 13EF 80 DUP1 13F0 15 ISZERO 13F1 61 PUSH2 0x13f9 13F4 57 *JUMPI 13F5 60 PUSH1 0x00 13F7 80 DUP1 13F8 FD *REVERT 13F9 5B JUMPDEST 13FA 50 POP 13FB 5A GAS 13FC F1 CALL 13FD 92 SWAP3 13FE 50 POP 13FF 50 POP 1400 50 POP 1401 80 DUP1 1402 15 ISZERO 1403 61 PUSH2 0x1429 1406 57 *JUMPI 1407 50 POP 1408 60 PUSH1 0x40 140A 80 DUP1 140B 51 MLOAD 140C 60 PUSH1 0x1f 140E 3D RETURNDATASIZE 140F 90 SWAP1 1410 81 DUP2 1411 01 ADD 1412 60 PUSH1 0x1f 1414 19 NOT 1415 16 AND 1416 82 DUP3 1417 01 ADD 1418 90 SWAP1 1419 92 SWAP3 141A 52 MSTORE 141B 61 PUSH2 0x1426 141E 91 SWAP2 141F 81 DUP2 1420 01 ADD 1421 90 SWAP1 1422 61 PUSH2 0x2488 1425 56 *JUMP 1426 5B JUMPDEST 1427 60 PUSH1 0x01 1429 5B JUMPDEST 142A 61 PUSH2 0x1489 142D 57 *JUMPI 142E 61 PUSH2 0x1435 1431 61 PUSH2 0x24a9 1434 56 *JUMP 1435 5B JUMPDEST 1436 80 DUP1 1437 63 PUSH4 0x08c379a0 143C 14 EQ 143D 15 ISZERO 143E 61 PUSH2 0x146f 1441 57 *JUMPI 1442 50 POP 1443 61 PUSH2 0x144a 1446 61 PUSH2 0x24c5 1449 56 *JUMP 144A 5B JUMPDEST 144B 80 DUP1 144C 61 PUSH2 0x1455 144F 57 *JUMPI 1450 50 POP 1451 61 PUSH2 0x1471 1454 56 *JUMP 1455 5B JUMPDEST 1456 80 DUP1 1457 60 PUSH1 0x40 1459 51 MLOAD 145A 62 PUSH3 0x461bcd 145E 60 PUSH1 0xe5 1460 1B SHL 1461 81 DUP2 1462 52 MSTORE 1463 60 PUSH1 0x04 1465 01 ADD 1466 61 PUSH2 0x047e 1469 91 SWAP2 146A 90 SWAP1 146B 61 PUSH2 0x183a 146E 56 *JUMP 146F 5B JUMPDEST 1470 50 POP 1471 5B JUMPDEST 1472 60 PUSH1 0x40 1474 51 MLOAD 1475 62 PUSH3 0x461bcd 1479 60 PUSH1 0xe5 147B 1B SHL 147C 81 DUP2 147D 52 MSTORE 147E 60 PUSH1 0x04 1480 01 ADD 1481 61 PUSH2 0x047e 1484 90 SWAP1 1485 61 PUSH2 0x259b 1488 56 *JUMP 1489 5B JUMPDEST 148A 60 PUSH1 0x01 148C 60 PUSH1 0x01 148E 60 PUSH1 0xe0 1490 1B SHL 1491 03 SUB 1492 19 NOT 1493 81 DUP2 1494 16 AND 1495 63 PUSH4 0xbc197c81 149A 60 PUSH1 0xe0 149C 1B SHL 149D 14 EQ 149E 61 PUSH2 0x11f0 14A1 57 *JUMPI 14A2 60 PUSH1 0x40 14A4 51 MLOAD 14A5 62 PUSH3 0x461bcd 14A9 60 PUSH1 0xe5 14AB 1B SHL 14AC 81 DUP2 14AD 52 MSTORE 14AE 60 PUSH1 0x04 14B0 01 ADD 14B1 61 PUSH2 0x047e 14B4 90 SWAP1 14B5 61 PUSH2 0x25f0 14B8 56 *JUMP label_14B9: // Incoming call from 0x0EB3, returns to 0x082C // Inputs[2] // { // @14BD stack[-2] // @14BE stack[-1] // } 14B9 5B JUMPDEST 14BA 61 PUSH2 0x14c3 14BD 82 DUP3 14BE 82 DUP3 14BF 61 PUSH2 0x0947 14C2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14BA stack[0] = 0x14c3 // @14BD stack[1] = stack[-2] // @14BE stack[2] = stack[-1] // } // Block ends with call to 0x0947, returns to 0x14C3 label_14C3: // Incoming return from call to 0x0947 at 0x14C2 // Inputs[1] { @14C7 stack[-1] } 14C3 5B JUMPDEST 14C4 61 PUSH2 0x07b5 14C7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07b5, if stack[-1] label_14C8: // Incoming jump from 0x14C7, if not stack[-1] // Inputs[1] { @14CB stack[-1] } 14C8 61 PUSH2 0x14db 14CB 81 DUP2 14CC 60 PUSH1 0x01 14CE 60 PUSH1 0x01 14D0 60 PUSH1 0xa0 14D2 1B SHL 14D3 03 SUB 14D4 16 AND 14D5 60 PUSH1 0x14 14D7 61 PUSH2 0x0b69 14DA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14C8 stack[0] = 0x14db // @14D4 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @14D5 stack[2] = 0x14 // } // Block ends with call to 0x0b69, returns to 0x14DB label_14DB: // Incoming return from call to 0x0B69 at 0x14DA // Inputs[1] { @14DF stack[-3] } 14DB 5B JUMPDEST 14DC 61 PUSH2 0x14e6 14DF 83 DUP4 14E0 60 PUSH1 0x20 14E2 61 PUSH2 0x0b69 14E5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14DC stack[0] = 0x14e6 // @14DF stack[1] = stack[-3] // @14E0 stack[2] = 0x20 // } // Block ends with call to 0x0b69, returns to 0x14E6 label_14E6: // Incoming return from call to 0x0B69 at 0x14E5 // Inputs[3] // { // @14E9 memory[0x40:0x60] // @14F0 stack[-2] // @14F1 stack[-1] // } 14E6 5B JUMPDEST 14E7 60 PUSH1 0x40 14E9 51 MLOAD 14EA 60 PUSH1 0x20 14EC 01 ADD 14ED 61 PUSH2 0x14f7 14F0 92 SWAP3 14F1 91 SWAP2 14F2 90 SWAP1 14F3 61 PUSH2 0x2622 14F6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @14F0 stack[-2] = 0x14f7 // @14F1 stack[-1] = stack[-2] // @14F2 stack[1] = 0x20 + memory[0x40:0x60] // @14F2 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2622 14F7 5B JUMPDEST 14F8 60 PUSH1 0x40 14FA 80 DUP1 14FB 51 MLOAD 14FC 60 PUSH1 0x1f 14FE 19 NOT 14FF 81 DUP2 1500 84 DUP5 1501 03 SUB 1502 01 ADD 1503 81 DUP2 1504 52 MSTORE 1505 90 SWAP1 1506 82 DUP3 1507 90 SWAP1 1508 52 MSTORE 1509 62 PUSH3 0x461bcd 150D 60 PUSH1 0xe5 150F 1B SHL 1510 82 DUP3 1511 52 MSTORE 1512 61 PUSH2 0x047e 1515 91 SWAP2 1516 60 PUSH1 0x04 1518 01 ADD 1519 61 PUSH2 0x183a 151C 56 *JUMP 151D 5B JUMPDEST 151E 60 PUSH1 0x40 1520 80 DUP1 1521 51 MLOAD 1522 60 PUSH1 0x01 1524 80 DUP1 1525 82 DUP3 1526 52 MSTORE 1527 81 DUP2 1528 83 DUP4 1529 01 ADD 152A 90 SWAP1 152B 92 SWAP3 152C 52 MSTORE 152D 60 PUSH1 0x60 152F 91 SWAP2 1530 60 PUSH1 0x00 1532 91 SWAP2 1533 90 SWAP1 1534 60 PUSH1 0x20 1536 80 DUP1 1537 83 DUP4 1538 01 ADD 1539 90 SWAP1 153A 80 DUP1 153B 36 CALLDATASIZE 153C 83 DUP4 153D 37 CALLDATACOPY 153E 01 ADD 153F 90 SWAP1 1540 50 POP 1541 50 POP 1542 90 SWAP1 1543 50 POP 1544 82 DUP3 1545 81 DUP2 1546 60 PUSH1 0x00 1548 81 DUP2 1549 51 MLOAD 154A 81 DUP2 154B 10 LT 154C 61 PUSH2 0x1557 154F 57 *JUMPI 1550 61 PUSH2 0x1557 1553 61 PUSH2 0x20cd 1556 56 *JUMP 1557 5B JUMPDEST 1558 60 PUSH1 0x20 155A 90 SWAP1 155B 81 DUP2 155C 02 MUL 155D 91 SWAP2 155E 90 SWAP1 155F 91 SWAP2 1560 01 ADD 1561 01 ADD 1562 52 MSTORE 1563 92 SWAP3 1564 91 SWAP2 1565 50 POP 1566 50 POP 1567 56 *JUMP 1568 5B JUMPDEST 1569 60 PUSH1 0x01 156B 60 PUSH1 0x01 156D 60 PUSH1 0xa0 156F 1B SHL 1570 03 SUB 1571 84 DUP5 1572 16 AND 1573 3B EXTCODESIZE 1574 15 ISZERO 1575 61 PUSH2 0x0ea2 1578 57 *JUMPI 1579 60 PUSH1 0x40 157B 51 MLOAD 157C 63 PUSH4 0xf23a6e61 1581 60 PUSH1 0xe0 1583 1B SHL 1584 81 DUP2 1585 52 MSTORE 1586 60 PUSH1 0x01 1588 60 PUSH1 0x01 158A 60 PUSH1 0xa0 158C 1B SHL 158D 03 SUB 158E 85 DUP6 158F 16 AND 1590 90 SWAP1 1591 63 PUSH4 0xf23a6e61 1596 90 SWAP1 1597 61 PUSH2 0x15ac 159A 90 SWAP1 159B 89 DUP10 159C 90 SWAP1 159D 89 DUP10 159E 90 SWAP1 159F 88 DUP9 15A0 90 SWAP1 15A1 88 DUP9 15A2 90 SWAP1 15A3 88 DUP9 15A4 90 SWAP1 15A5 60 PUSH1 0x04 15A7 01 ADD 15A8 61 PUSH2 0x267a 15AB 56 *JUMP 15AC 5B JUMPDEST 15AD 60 PUSH1 0x20 15AF 60 PUSH1 0x40 15B1 51 MLOAD 15B2 80 DUP1 15B3 83 DUP4 15B4 03 SUB 15B5 81 DUP2 15B6 60 PUSH1 0x00 15B8 87 DUP8 15B9 80 DUP1 15BA 3B EXTCODESIZE 15BB 15 ISZERO 15BC 80 DUP1 15BD 15 ISZERO 15BE 61 PUSH2 0x15c6 15C1 57 *JUMPI 15C2 60 PUSH1 0x00 15C4 80 DUP1 15C5 FD *REVERT 15C6 5B JUMPDEST 15C7 50 POP 15C8 5A GAS 15C9 F1 CALL 15CA 92 SWAP3 15CB 50 POP 15CC 50 POP 15CD 50 POP 15CE 80 DUP1 15CF 15 ISZERO 15D0 61 PUSH2 0x15f6 15D3 57 *JUMPI 15D4 50 POP 15D5 60 PUSH1 0x40 15D7 80 DUP1 15D8 51 MLOAD 15D9 60 PUSH1 0x1f 15DB 3D RETURNDATASIZE 15DC 90 SWAP1 15DD 81 DUP2 15DE 01 ADD 15DF 60 PUSH1 0x1f 15E1 19 NOT 15E2 16 AND 15E3 82 DUP3 15E4 01 ADD 15E5 90 SWAP1 15E6 92 SWAP3 15E7 52 MSTORE 15E8 61 PUSH2 0x15f3 15EB 91 SWAP2 15EC 81 DUP2 15ED 01 ADD 15EE 90 SWAP1 15EF 61 PUSH2 0x2488 15F2 56 *JUMP 15F3 5B JUMPDEST 15F4 60 PUSH1 0x01 15F6 5B JUMPDEST 15F7 61 PUSH2 0x1602 15FA 57 *JUMPI 15FB 61 PUSH2 0x1435 15FE 61 PUSH2 0x24a9 1601 56 *JUMP 1602 5B JUMPDEST 1603 60 PUSH1 0x01 1605 60 PUSH1 0x01 1607 60 PUSH1 0xe0 1609 1B SHL 160A 03 SUB 160B 19 NOT 160C 81 DUP2 160D 16 AND 160E 63 PUSH4 0xf23a6e61 1613 60 PUSH1 0xe0 1615 1B SHL 1616 14 EQ 1617 61 PUSH2 0x11f0 161A 57 *JUMPI 161B 60 PUSH1 0x40 161D 51 MLOAD 161E 62 PUSH3 0x461bcd 1622 60 PUSH1 0xe5 1624 1B SHL 1625 81 DUP2 1626 52 MSTORE 1627 60 PUSH1 0x04 1629 01 ADD 162A 61 PUSH2 0x047e 162D 90 SWAP1 162E 61 PUSH2 0x25f0 1631 56 *JUMP 1632 5B JUMPDEST 1633 60 PUSH1 0x04 1635 54 SLOAD 1636 60 PUSH1 0xff 1638 16 AND 1639 15 ISZERO 163A 61 PUSH2 0x0ea2 163D 57 *JUMPI 163E 60 PUSH1 0x40 1640 51 MLOAD 1641 62 PUSH3 0x461bcd 1645 60 PUSH1 0xe5 1647 1B SHL 1648 81 DUP2 1649 52 MSTORE 164A 60 PUSH1 0x04 164C 01 ADD 164D 61 PUSH2 0x047e 1650 90 SWAP1 1651 61 PUSH2 0x270a 1654 56 *JUMP 1655 5B JUMPDEST 1656 82 DUP3 1657 80 DUP1 1658 54 SLOAD 1659 61 PUSH2 0x1661 165C 90 SWAP1 165D 61 PUSH2 0x1f30 1660 56 *JUMP 1661 5B JUMPDEST 1662 90 SWAP1 1663 60 PUSH1 0x00 1665 52 MSTORE 1666 60 PUSH1 0x20 1668 60 PUSH1 0x00 166A 20 SHA3 166B 90 SWAP1 166C 60 PUSH1 0x1f 166E 01 ADD 166F 60 PUSH1 0x20 1671 90 SWAP1 1672 04 DIV 1673 81 DUP2 1674 01 ADD 1675 92 SWAP3 1676 82 DUP3 1677 61 PUSH2 0x1683 167A 57 *JUMPI 167B 60 PUSH1 0x00 167D 85 DUP6 167E 55 SSTORE 167F 61 PUSH2 0x16c9 1682 56 *JUMP 1683 5B JUMPDEST 1684 82 DUP3 1685 60 PUSH1 0x1f 1687 10 LT 1688 61 PUSH2 0x169c 168B 57 *JUMPI 168C 80 DUP1 168D 51 MLOAD 168E 60 PUSH1 0xff 1690 19 NOT 1691 16 AND 1692 83 DUP4 1693 80 DUP1 1694 01 ADD 1695 17 OR 1696 85 DUP6 1697 55 SSTORE 1698 61 PUSH2 0x16c9 169B 56 *JUMP 169C 5B JUMPDEST 169D 82 DUP3 169E 80 DUP1 169F 01 ADD 16A0 60 PUSH1 0x01 16A2 01 ADD 16A3 85 DUP6 16A4 55 SSTORE 16A5 82 DUP3 16A6 15 ISZERO 16A7 61 PUSH2 0x16c9 16AA 57 *JUMPI 16AB 91 SWAP2 16AC 82 DUP3 16AD 01 ADD 16AE 5B JUMPDEST 16AF 82 DUP3 16B0 81 DUP2 16B1 11 GT 16B2 15 ISZERO 16B3 61 PUSH2 0x16c9 16B6 57 *JUMPI 16B7 82 DUP3 16B8 51 MLOAD 16B9 82 DUP3 16BA 55 SSTORE 16BB 91 SWAP2 16BC 60 PUSH1 0x20 16BE 01 ADD 16BF 91 SWAP2 16C0 90 SWAP1 16C1 60 PUSH1 0x01 16C3 01 ADD 16C4 90 SWAP1 16C5 61 PUSH2 0x16ae 16C8 56 *JUMP 16C9 5B JUMPDEST 16CA 50 POP 16CB 61 PUSH2 0x16d5 16CE 92 SWAP3 16CF 91 SWAP2 16D0 50 POP 16D1 61 PUSH2 0x16d9 16D4 56 *JUMP 16D5 5B JUMPDEST 16D6 50 POP 16D7 90 SWAP1 16D8 56 *JUMP 16D9 5B JUMPDEST 16DA 5B JUMPDEST 16DB 80 DUP1 16DC 82 DUP3 16DD 11 GT 16DE 15 ISZERO 16DF 61 PUSH2 0x16d5 16E2 57 *JUMPI 16E3 60 PUSH1 0x00 16E5 81 DUP2 16E6 55 SSTORE 16E7 60 PUSH1 0x01 16E9 01 ADD 16EA 61 PUSH2 0x16da 16ED 56 *JUMP label_16EE: // Incoming call from 0x1707, returns to 0x1708 // Inputs[1] { @16F9 stack[-1] } 16EE 5B JUMPDEST 16EF 60 PUSH1 0x00 16F1 60 PUSH1 0x01 16F3 60 PUSH1 0x01 16F5 60 PUSH1 0xa0 16F7 1B SHL 16F8 03 SUB 16F9 82 DUP3 16FA 16 AND 16FB 61 PUSH2 0x04aa 16FE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16EF stack[0] = 0x00 // @16FA stack[1] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x04aa label_16FF: // Incoming jump from 0x171D // Inputs[1] { @1703 stack[-1] } 16FF 5B JUMPDEST 1700 61 PUSH2 0x1708 1703 81 DUP2 1704 61 PUSH2 0x16ee 1707 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1700 stack[0] = 0x1708 // @1703 stack[1] = stack[-1] // } // Block ends with call to 0x16ee, returns to 0x1708 label_1708: // Incoming return from call to 0x16EE at 0x1707 // Incoming jump from 0x1723 // Incoming jump from 0x1791 // Inputs[2] // { // @1709 stack[-2] // @170A stack[-1] // } 1708 5B JUMPDEST 1709 81 DUP2 170A 14 EQ 170B 61 PUSH2 0x082c 170E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x082c, if stack[-2] == stack[-1] label_170F: // Incoming jump from 0x170E, if not stack[-2] == stack[-1] // Inputs[1] { @1712 memory[0x00:0x00] } 170F 60 PUSH1 0x00 1711 80 DUP1 1712 FD *REVERT // Stack delta = +0 // Outputs[1] { @1712 revert(memory[0x00:0x00]); } // Block terminates label_1713: // Incoming jump from 0x1750 // Incoming jump from 0x1D63 // Incoming jump from 0x1BED // Incoming jump from 0x1B5E // Incoming jump from 0x1E0D // Incoming jump from 0x1DE6 // Incoming jump from 0x1A6B // Inputs[2] // { // @1714 stack[-1] // @1715 msg.data[stack[-1]:stack[-1] + 0x20] // } 1713 5B JUMPDEST 1714 80 DUP1 1715 35 CALLDATALOAD 1716 61 PUSH2 0x04aa 1719 81 DUP2 171A 61 PUSH2 0x16ff 171D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1715 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1716 stack[1] = 0x04aa // @1719 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x16ff label_171E: // Incoming call from 0x172E, returns to 0x04AA // Inputs[1] { @171F stack[-1] } 171E 5B JUMPDEST 171F 80 DUP1 1720 61 PUSH2 0x1708 1723 56 *JUMP // Stack delta = +1 // Outputs[1] { @171F stack[0] = stack[-1] } // Block ends with unconditional jump to 0x1708 label_1724: // Incoming jump from 0x188D // Incoming jump from 0x186B // Incoming jump from 0x1B2C // Incoming jump from 0x1D98 // Incoming jump from 0x1979 // Incoming jump from 0x1B80 // Incoming jump from 0x1E65 // Inputs[2] // { // @1725 stack[-1] // @1726 msg.data[stack[-1]:stack[-1] + 0x20] // } 1724 5B JUMPDEST 1725 80 DUP1 1726 35 CALLDATALOAD 1727 61 PUSH2 0x04aa 172A 81 DUP2 172B 61 PUSH2 0x171e 172E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1726 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1727 stack[1] = 0x04aa // @172A stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x171e, returns to 0x04AA label_172F: // Incoming jump from 0x03BE // Incoming jump from 0x01EB // Inputs[2] // { // @1735 stack[-1] // @1736 stack[-2] // } 172F 5B JUMPDEST 1730 60 PUSH1 0x00 1732 80 DUP1 1733 60 PUSH1 0x40 1735 83 DUP4 1736 85 DUP6 1737 03 SUB 1738 12 SLT 1739 15 ISZERO 173A 61 PUSH2 0x1745 173D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1730 stack[0] = 0x00 // @1732 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1745, if !(stack[-2] - stack[-1] i< 0x40) label_173E: // Incoming jump from 0x173D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1744 memory[0x00:0x00] } 173E 61 PUSH2 0x1745 1741 60 PUSH1 0x00 1743 80 DUP1 1744 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @173E stack[0] = 0x1745 // @1744 revert(memory[0x00:0x00]); // } // Block terminates label_1745: // Incoming jump from 0x173D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @174B stack[-4] // @174C stack[-3] // } 1745 5B JUMPDEST 1746 60 PUSH1 0x00 1748 61 PUSH2 0x1751 174B 85 DUP6 174C 85 DUP6 174D 61 PUSH2 0x1713 1750 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1746 stack[0] = 0x00 // @1748 stack[1] = 0x1751 // @174B stack[2] = stack[-4] // @174C stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1713 1751 5B JUMPDEST 1752 92 SWAP3 1753 50 POP 1754 50 POP 1755 60 PUSH1 0x20 1757 61 PUSH2 0x1762 175A 85 DUP6 175B 82 DUP3 175C 86 DUP7 175D 01 ADD 175E 61 PUSH2 0x1724 1761 56 *JUMP 1762 5B JUMPDEST 1763 91 SWAP2 1764 50 POP 1765 50 POP 1766 92 SWAP3 1767 50 POP 1768 92 SWAP3 1769 90 SWAP1 176A 50 POP 176B 56 *JUMP label_176C: // Incoming call from 0x1781, returns to 0x04AA // Inputs[3] // { // @176D stack[-1] // @176F stack[-2] // @1773 stack[-3] // } 176C 5B JUMPDEST 176D 80 DUP1 176E 5B JUMPDEST 176F 82 DUP3 1770 52 MSTORE 1771 50 POP 1772 50 POP 1773 56 *JUMP // Stack delta = -3 // Outputs[1] { @1770 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1774: // Incoming jump from 0x01FD // Inputs[2] // { // @1777 stack[-1] // @177D stack[-2] // } 1774 5B JUMPDEST 1775 60 PUSH1 0x20 1777 81 DUP2 1778 01 ADD 1779 61 PUSH2 0x04aa 177C 82 DUP3 177D 84 DUP5 177E 61 PUSH2 0x176c 1781 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1778 stack[0] = stack[-1] + 0x20 // @1779 stack[1] = 0x04aa // @177C stack[2] = stack[-1] // @177D stack[3] = stack[-2] // } // Block ends with call to 0x176c, returns to 0x04AA label_1782: // Incoming call from 0x179C, returns to 0x04AA // Inputs[1] { @178C stack[-1] } 1782 5B JUMPDEST 1783 60 PUSH1 0x01 1785 60 PUSH1 0x01 1787 60 PUSH1 0xe0 1789 1B SHL 178A 03 SUB 178B 19 NOT 178C 81 DUP2 178D 16 AND 178E 61 PUSH2 0x1708 1791 56 *JUMP // Stack delta = +1 // Outputs[1] { @178D stack[0] = stack[-1] & ~((0x01 << 0xe0) - 0x01) } // Block ends with unconditional jump to 0x1708 label_1792: // Incoming jump from 0x17BD // Inputs[2] // { // @1793 stack[-1] // @1794 msg.data[stack[-1]:stack[-1] + 0x20] // } 1792 5B JUMPDEST 1793 80 DUP1 1794 35 CALLDATALOAD 1795 61 PUSH2 0x04aa 1798 81 DUP2 1799 61 PUSH2 0x1782 179C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1794 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1795 stack[1] = 0x04aa // @1798 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1782, returns to 0x04AA label_179D: // Incoming jump from 0x0214 // Inputs[2] // { // @17A2 stack[-1] // @17A3 stack[-2] // } 179D 5B JUMPDEST 179E 60 PUSH1 0x00 17A0 60 PUSH1 0x20 17A2 82 DUP3 17A3 84 DUP5 17A4 03 SUB 17A5 12 SLT 17A6 15 ISZERO 17A7 61 PUSH2 0x17b2 17AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @179E stack[0] = 0x00 } // Block ends with conditional jump to 0x17b2, if !(stack[-2] - stack[-1] i< 0x20) label_17AB: // Incoming jump from 0x17AA, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @17B1 memory[0x00:0x00] } 17AB 61 PUSH2 0x17b2 17AE 60 PUSH1 0x00 17B0 80 DUP1 17B1 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @17AB stack[0] = 0x17b2 // @17B1 revert(memory[0x00:0x00]); // } // Block terminates label_17B2: // Incoming jump from 0x17AA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @17B8 stack[-3] // @17B9 stack[-2] // } 17B2 5B JUMPDEST 17B3 60 PUSH1 0x00 17B5 61 PUSH2 0x17be 17B8 84 DUP5 17B9 84 DUP5 17BA 61 PUSH2 0x1792 17BD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @17B3 stack[0] = 0x00 // @17B5 stack[1] = 0x17be // @17B8 stack[2] = stack[-3] // @17B9 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1792 label_17BE: // Incoming return from call to 0x2600 at 0x2679 // Incoming return from call to 0x1933 at 0x19B6 // Incoming return from call to 0x19ED at 0x1A44 // Incoming return from call to 0x1BAC at 0x1C20 // Inputs[3] // { // @17BF stack[-1] // @17BF stack[-6] // @17C0 stack[-5] // } 17BE 5B JUMPDEST 17BF 94 SWAP5 17C0 93 SWAP4 17C1 50 POP 17C2 50 POP 17C3 50 POP 17C4 50 POP 17C5 56 *JUMP // Stack delta = -5 // Outputs[1] { @17BF stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_17C6: // Incoming call from 0x17DB, returns to 0x04AA // Inputs[1] { @17C7 stack[-1] } 17C6 5B JUMPDEST 17C7 80 DUP1 17C8 15 ISZERO 17C9 15 ISZERO 17CA 61 PUSH2 0x176e 17CD 56 *JUMP // Stack delta = +1 // Outputs[1] { @17C9 stack[0] = !!stack[-1] } // Block ends with unconditional jump to 0x176e label_17CE: // Incoming jump from 0x0226 // Inputs[2] // { // @17D1 stack[-1] // @17D7 stack[-2] // } 17CE 5B JUMPDEST 17CF 60 PUSH1 0x20 17D1 81 DUP2 17D2 01 ADD 17D3 61 PUSH2 0x04aa 17D6 82 DUP3 17D7 84 DUP5 17D8 61 PUSH2 0x17c6 17DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @17D2 stack[0] = stack[-1] + 0x20 // @17D3 stack[1] = 0x04aa // @17D6 stack[2] = stack[-1] // @17D7 stack[3] = stack[-2] // } // Block ends with call to 0x17c6, returns to 0x04AA label_17DC: // Incoming call from 0x1828, returns to 0x1829 // Incoming call from 0x2617, returns to 0x2618 // Inputs[1] { @17E0 stack[-3] } 17DC 5B JUMPDEST 17DD 60 PUSH1 0x00 17DF 5B JUMPDEST 17E0 83 DUP4 17E1 81 DUP2 17E2 10 LT 17E3 15 ISZERO 17E4 61 PUSH2 0x17f7 17E7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17DD stack[0] = 0x00 } // Block ends with conditional jump to 0x17f7, if !(0x00 < stack[-3]) label_17E8: // Incoming jump from 0x17E7, if not !(0x00 < stack[-3]) // Incoming jump from 0x17E7, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @17E8 stack[-2] // @17E9 stack[-1] // @17EB memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @17EC stack[-3] // } 17E8 81 DUP2 17E9 81 DUP2 17EA 01 ADD 17EB 51 MLOAD 17EC 83 DUP4 17ED 82 DUP3 17EE 01 ADD 17EF 52 MSTORE 17F0 60 PUSH1 0x20 17F2 01 ADD 17F3 61 PUSH2 0x17df 17F6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @17EF memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @17F2 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x17df label_17F7: // Incoming jump from 0x17E7, if !(0x00 < stack[-3]) // Incoming jump from 0x17E7, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @17F8 stack[-4] // @17F9 stack[-1] // } 17F7 5B JUMPDEST 17F8 83 DUP4 17F9 81 DUP2 17FA 11 GT 17FB 15 ISZERO 17FC 61 PUSH2 0x0813 17FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0813, if !(stack[-1] > stack[-4]) label_1800: // Incoming jump from 0x17FF, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1804 stack[-4] // @1805 stack[-3] // @1807 stack[-5] // } 1800 50 POP 1801 50 POP 1802 60 PUSH1 0x00 1804 91 SWAP2 1805 01 ADD 1806 52 MSTORE 1807 56 *JUMP // Stack delta = -5 // Outputs[1] { @1806 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1808: // Incoming call from 0x184A, returns to 0x0CD4 // Inputs[2] // { // @180E stack[-1] // @180F memory[stack[-1]:stack[-1] + 0x20] // } 1808 5B JUMPDEST 1809 60 PUSH1 0x00 180B 61 PUSH2 0x1812 180E 82 DUP3 180F 51 MLOAD 1810 90 SWAP1 1811 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1809 stack[0] = 0x00 // @1810 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1812 label_1812: // Incoming jump from 0x1811 // Inputs[3] // { // @1813 stack[-1] // @1814 stack[-4] // @1823 stack[-3] // } 1812 5B JUMPDEST 1813 80 DUP1 1814 84 DUP5 1815 52 MSTORE 1816 60 PUSH1 0x20 1818 84 DUP5 1819 01 ADD 181A 93 SWAP4 181B 50 POP 181C 61 PUSH2 0x1829 181F 81 DUP2 1820 85 DUP6 1821 60 PUSH1 0x20 1823 86 DUP7 1824 01 ADD 1825 61 PUSH2 0x17dc 1828 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1815 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @181A stack[-4] = stack[-4] + 0x20 // @181C stack[0] = 0x1829 // @181F stack[1] = stack[-1] // @1820 stack[2] = stack[-4] + 0x20 // @1824 stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x17dc, returns to 0x1829 label_1829: // Incoming return from call to 0x17DC at 0x1828 // Inputs[4] // { // @182C stack[-1] // @1831 stack[-4] // @1832 stack[-2] // @1835 stack[-5] // } 1829 5B JUMPDEST 182A 60 PUSH1 0x1f 182C 01 ADD 182D 60 PUSH1 0x1f 182F 19 NOT 1830 16 AND 1831 92 SWAP3 1832 90 SWAP1 1833 92 SWAP3 1834 01 ADD 1835 92 SWAP3 1836 91 SWAP2 1837 50 POP 1838 50 POP 1839 56 *JUMP // Stack delta = -4 // Outputs[1] { @1835 stack[-5] = (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_183A: // Incoming call from 0x023B, returns to 0x01FE // Inputs[2] // { // @183E stack[-1] // @1846 stack[-2] // } 183A 5B JUMPDEST 183B 60 PUSH1 0x20 183D 80 DUP1 183E 82 DUP3 183F 52 MSTORE 1840 81 DUP2 1841 01 ADD 1842 61 PUSH2 0x0cd4 1845 81 DUP2 1846 84 DUP5 1847 61 PUSH2 0x1808 184A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @183F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1841 stack[0] = stack[-1] + 0x20 // @1842 stack[1] = 0x0cd4 // @1845 stack[2] = stack[-1] + 0x20 // @1846 stack[3] = stack[-2] // } // Block ends with call to 0x1808, returns to 0x0CD4 label_184B: // Incoming jump from 0x025C // Incoming jump from 0x0249 // Inputs[2] // { // @1850 stack[-1] // @1851 stack[-2] // } 184B 5B JUMPDEST 184C 60 PUSH1 0x00 184E 60 PUSH1 0x20 1850 82 DUP3 1851 84 DUP5 1852 03 SUB 1853 12 SLT 1854 15 ISZERO 1855 61 PUSH2 0x1860 1858 57 *JUMPI // Stack delta = +1 // Outputs[1] { @184C stack[0] = 0x00 } // Block ends with conditional jump to 0x1860, if !(stack[-2] - stack[-1] i< 0x20) label_1859: // Incoming jump from 0x1858, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @185F memory[0x00:0x00] } 1859 61 PUSH2 0x1860 185C 60 PUSH1 0x00 185E 80 DUP1 185F FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1859 stack[0] = 0x1860 // @185F revert(memory[0x00:0x00]); // } // Block terminates label_1860: // Incoming jump from 0x1858, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1866 stack[-3] // @1867 stack[-2] // } 1860 5B JUMPDEST 1861 60 PUSH1 0x00 1863 61 PUSH2 0x17be 1866 84 DUP5 1867 84 DUP5 1868 61 PUSH2 0x1724 186B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1861 stack[0] = 0x00 // @1863 stack[1] = 0x17be // @1866 stack[2] = stack[-3] // @1867 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1724 label_186C: // Incoming jump from 0x027F // Inputs[2] // { // @1872 stack[-1] // @1873 stack[-2] // } 186C 5B JUMPDEST 186D 60 PUSH1 0x00 186F 80 DUP1 1870 60 PUSH1 0x40 1872 83 DUP4 1873 85 DUP6 1874 03 SUB 1875 12 SLT 1876 15 ISZERO 1877 61 PUSH2 0x1882 187A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @186D stack[0] = 0x00 // @186F stack[1] = 0x00 // } // Block ends with conditional jump to 0x1882, if !(stack[-2] - stack[-1] i< 0x40) label_187B: // Incoming jump from 0x187A, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1881 memory[0x00:0x00] } 187B 61 PUSH2 0x1882 187E 60 PUSH1 0x00 1880 80 DUP1 1881 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @187B stack[0] = 0x1882 // @1881 revert(memory[0x00:0x00]); // } // Block terminates label_1882: // Incoming jump from 0x187A, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1888 stack[-4] // @1889 stack[-3] // } 1882 5B JUMPDEST 1883 60 PUSH1 0x00 1885 61 PUSH2 0x1751 1888 85 DUP6 1889 85 DUP6 188A 61 PUSH2 0x1724 188D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1883 stack[0] = 0x00 // @1885 stack[1] = 0x1751 // @1888 stack[2] = stack[-4] // @1889 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1724 188E 5B JUMPDEST 188F 61 PUSH2 0x176e 1892 81 DUP2 1893 61 PUSH2 0x16ee 1896 56 *JUMP 1897 5B JUMPDEST 1898 60 PUSH1 0x40 189A 81 DUP2 189B 01 ADD 189C 61 PUSH2 0x18a5 189F 82 DUP3 18A0 85 DUP6 18A1 61 PUSH2 0x188e 18A4 56 *JUMP 18A5 5B JUMPDEST 18A6 61 PUSH2 0x0cd4 18A9 60 PUSH1 0x20 18AB 83 DUP4 18AC 01 ADD 18AD 84 DUP5 18AE 61 PUSH2 0x176c 18B1 56 *JUMP label_18B2: // Incoming jump from 0x0B99 // Incoming jump from 0x19CF // Incoming jump from 0x1928 // Incoming jump from 0x18EC // Inputs[1] { @18C7 memory[0x00:0x24] } 18B2 5B JUMPDEST 18B3 63 PUSH4 0x4e487b71 18B8 60 PUSH1 0xe0 18BA 1B SHL 18BB 60 PUSH1 0x00 18BD 52 MSTORE 18BE 60 PUSH1 0x41 18C0 60 PUSH1 0x04 18C2 52 MSTORE 18C3 60 PUSH1 0x24 18C5 60 PUSH1 0x00 18C7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @18BD memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @18C2 memory[0x04:0x24] = 0x41 // @18C7 revert(memory[0x00:0x24]); // } // Block terminates label_18C8: // Incoming call from 0x190A, returns to 0x190B // Inputs[2] // { // @18CE stack[-2] // @18D1 stack[-1] // } 18C8 5B JUMPDEST 18C9 60 PUSH1 0x1f 18CB 19 NOT 18CC 60 PUSH1 0x1f 18CE 83 DUP4 18CF 01 ADD 18D0 16 AND 18D1 81 DUP2 18D2 01 ADD 18D3 81 DUP2 18D4 81 DUP2 18D5 10 LT 18D6 60 PUSH1 0x01 18D8 60 PUSH1 0x01 18DA 60 PUSH1 0x40 18DC 1B SHL 18DD 03 SUB 18DE 82 DUP3 18DF 11 GT 18E0 17 OR 18E1 15 ISZERO 18E2 61 PUSH2 0x18ed 18E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18D2 stack[0] = stack[-1] + (stack[-2] + 0x1f & ~0x1f) } // Block ends with conditional jump to 0x18ed, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > (0x01 << 0x40) - 0x01) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) label_18E6: // Incoming jump from 0x18E5, if not !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > (0x01 << 0x40) - 0x01) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) 18E6 61 PUSH2 0x18ed 18E9 61 PUSH2 0x18b2 18EC 56 *JUMP // Stack delta = +1 // Outputs[1] { @18E6 stack[0] = 0x18ed } // Block ends with unconditional jump to 0x18b2 label_18ED: // Incoming jump from 0x18E5, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > (0x01 << 0x40) - 0x01) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) // Inputs[2] // { // @18F0 stack[-1] // @18F3 stack[-4] // } 18ED 5B JUMPDEST 18EE 60 PUSH1 0x40 18F0 52 MSTORE 18F1 50 POP 18F2 50 POP 18F3 56 *JUMP // Stack delta = -4 // Outputs[1] { @18F0 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_18F4: // Incoming jump from 0x1945 // Inputs[1] { @18FC memory[0x40:0x60] } 18F4 5B JUMPDEST 18F5 60 PUSH1 0x00 18F7 61 PUSH2 0x18ff 18FA 60 PUSH1 0x40 18FC 51 MLOAD 18FD 90 SWAP1 18FE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @18F5 stack[0] = 0x00 // @18FD stack[1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x18ff label_18FF: // Incoming jump from 0x18FE // Inputs[3] // { // @1900 stack[-2] // @1900 stack[-1] // @1905 stack[-3] // } 18FF 5B JUMPDEST 1900 90 SWAP1 1901 50 POP 1902 61 PUSH2 0x190b 1905 82 DUP3 1906 82 DUP3 1907 61 PUSH2 0x18c8 190A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1900 stack[-2] = stack[-1] // @1902 stack[-1] = 0x190b // @1905 stack[0] = stack[-3] // @1906 stack[1] = stack[-1] // } // Block ends with call to 0x18c8, returns to 0x190B label_190B: // Incoming return from call to 0x18C8 at 0x190A // Inputs[3] // { // @190C stack[-1] // @190C stack[-3] // @190D stack[-2] // } 190B 5B JUMPDEST 190C 91 SWAP2 190D 90 SWAP1 190E 50 POP 190F 56 *JUMP // Stack delta = -2 // Outputs[1] { @190C stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1910: // Incoming call from 0x1BB9, returns to 0x1941 // Incoming call from 0x1940, returns to 0x1941 // Inputs[1] { @191B stack[-1] } 1910 5B JUMPDEST 1911 60 PUSH1 0x00 1913 60 PUSH1 0x01 1915 60 PUSH1 0x01 1917 60 PUSH1 0x40 1919 1B SHL 191A 03 SUB 191B 82 DUP3 191C 11 GT 191D 15 ISZERO 191E 61 PUSH2 0x1929 1921 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1911 stack[0] = 0x00 } // Block ends with conditional jump to 0x1929, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_1922: // Incoming jump from 0x1921, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 1922 61 PUSH2 0x1929 1925 61 PUSH2 0x18b2 1928 56 *JUMP // Stack delta = +1 // Outputs[1] { @1922 stack[0] = 0x1929 } // Block ends with unconditional jump to 0x18b2 label_1929: // Incoming jump from 0x1921, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @192D stack[-2] // @1931 stack[-3] // } 1929 5B JUMPDEST 192A 50 POP 192B 60 PUSH1 0x20 192D 90 SWAP1 192E 81 DUP2 192F 02 MUL 1930 01 ADD 1931 90 SWAP1 1932 56 *JUMP // Stack delta = -2 // Outputs[1] { @1931 stack[-3] = 0x20 * stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_1933: // Incoming call from 0x19B6, returns to 0x17BE // Inputs[1] { @193C stack[-2] } 1933 5B JUMPDEST 1934 60 PUSH1 0x00 1936 61 PUSH2 0x1946 1939 61 PUSH2 0x1941 193C 84 DUP5 193D 61 PUSH2 0x1910 1940 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1934 stack[0] = 0x00 // @1936 stack[1] = 0x1946 // @1939 stack[2] = 0x1941 // @193C stack[3] = stack[-2] // } // Block ends with call to 0x1910, returns to 0x1941 label_1941: // Incoming return from call to 0x1910 at 0x1BB9 // Incoming return from call to 0x1910 at 0x1940 // Incoming return from call to 0x19B7 at 0x19FA 1941 5B JUMPDEST 1942 61 PUSH2 0x18f4 1945 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x18f4 label_1946: // Incoming return from call to 0x1941 at 0x1940 // Inputs[5] // { // @1947 stack[-4] // @1948 stack[-1] // @194A stack[-2] // @1954 stack[-3] // @1956 stack[-5] // } 1946 5B JUMPDEST 1947 83 DUP4 1948 81 DUP2 1949 52 MSTORE 194A 90 SWAP1 194B 50 POP 194C 60 PUSH1 0x20 194E 80 DUP1 194F 82 DUP3 1950 01 ADD 1951 90 SWAP1 1952 84 DUP5 1953 02 MUL 1954 83 DUP4 1955 01 ADD 1956 85 DUP6 1957 81 DUP2 1958 11 GT 1959 15 ISZERO 195A 61 PUSH2 0x1965 195D 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1949 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @194A stack[-2] = stack[-1] // @1951 stack[-1] = stack[-1] + 0x20 // @1955 stack[0] = stack[-3] + stack[-4] * 0x20 // } // Block ends with conditional jump to 0x1965, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) label_195E: // Incoming jump from 0x195D, if not !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @1964 memory[0x00:0x00] } 195E 61 PUSH2 0x1965 1961 60 PUSH1 0x00 1963 80 DUP1 1964 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @195E stack[0] = 0x1965 // @1964 revert(memory[0x00:0x00]); // } // Block terminates label_1965: // Incoming jump from 0x195D, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[2] // { // @1966 stack[-4] // @1968 stack[-1] // } 1965 5B JUMPDEST 1966 83 DUP4 1967 5B JUMPDEST 1968 81 DUP2 1969 81 DUP2 196A 10 LT 196B 15 ISZERO 196C 61 PUSH2 0x1989 196F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1966 stack[0] = stack[-4] } // Block ends with conditional jump to 0x1989, if !(stack[-4] < stack[-1]) label_1970: // Incoming jump from 0x196F, if not !(stack[-4] < stack[-1]) // Inputs[2] // { // @1970 stack[-1] // @1974 stack[-7] // } 1970 80 DUP1 1971 61 PUSH2 0x197a 1974 88 DUP9 1975 82 DUP3 1976 61 PUSH2 0x1724 1979 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1970 stack[0] = stack[-1] // @1971 stack[1] = 0x197a // @1974 stack[2] = stack[-7] // @1975 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1724 197A 5B JUMPDEST 197B 84 DUP5 197C 52 MSTORE 197D 50 POP 197E 60 PUSH1 0x20 1980 92 SWAP3 1981 83 DUP4 1982 01 ADD 1983 92 SWAP3 1984 01 ADD 1985 61 PUSH2 0x1967 1988 56 *JUMP label_1989: // Incoming jump from 0x196F, if !(stack[-4] < stack[-1]) // Incoming jump from 0x1BE3, if !(stack[-4] < stack[-1]) // Inputs[3] // { // @198D stack[-8] // @198D stack[-4] // @198E stack[-7] // } 1989 5B JUMPDEST 198A 50 POP 198B 50 POP 198C 50 POP 198D 93 SWAP4 198E 92 SWAP3 198F 50 POP 1990 50 POP 1991 50 POP 1992 56 *JUMP // Stack delta = -7 // Outputs[1] { @198D stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_1993: // Incoming jump from 0x1C86 // Inputs[2] // { // @1996 stack[-2] // @1999 stack[-1] // } 1993 5B JUMPDEST 1994 60 PUSH1 0x00 1996 82 DUP3 1997 60 PUSH1 0x1f 1999 83 DUP4 199A 01 ADD 199B 12 SLT 199C 61 PUSH2 0x19a7 199F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1994 stack[0] = 0x00 } // Block ends with conditional jump to 0x19a7, if stack[-1] + 0x1f i< stack[-2] label_19A0: // Incoming jump from 0x199F, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @19A6 memory[0x00:0x00] } 19A0 61 PUSH2 0x19a7 19A3 60 PUSH1 0x00 19A5 80 DUP1 19A6 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @19A0 stack[0] = 0x19a7 // @19A6 revert(memory[0x00:0x00]); // } // Block terminates label_19A7: // Incoming jump from 0x199F, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @19A8 stack[-2] // @19A9 msg.data[stack[-2]:stack[-2] + 0x20] // @19AD stack[-3] // } 19A7 5B JUMPDEST 19A8 81 DUP2 19A9 35 CALLDATALOAD 19AA 61 PUSH2 0x17be 19AD 84 DUP5 19AE 82 DUP3 19AF 60 PUSH1 0x20 19B1 86 DUP7 19B2 01 ADD 19B3 61 PUSH2 0x1933 19B6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @19A9 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @19AA stack[1] = 0x17be // @19AD stack[2] = stack[-3] // @19AE stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @19B2 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x1933, returns to 0x17BE label_19B7: // Incoming call from 0x19FA, returns to 0x1941 // Inputs[1] { @19C2 stack[-1] } 19B7 5B JUMPDEST 19B8 60 PUSH1 0x00 19BA 60 PUSH1 0x01 19BC 60 PUSH1 0x01 19BE 60 PUSH1 0x40 19C0 1B SHL 19C1 03 SUB 19C2 82 DUP3 19C3 11 GT 19C4 15 ISZERO 19C5 61 PUSH2 0x19d0 19C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19B8 stack[0] = 0x00 } // Block ends with conditional jump to 0x19d0, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_19C9: // Incoming jump from 0x19C8, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 19C9 61 PUSH2 0x19d0 19CC 61 PUSH2 0x18b2 19CF 56 *JUMP // Stack delta = +1 // Outputs[1] { @19C9 stack[0] = 0x19d0 } // Block ends with unconditional jump to 0x18b2 label_19D0: // Incoming jump from 0x19C8, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @19D6 stack[-2] // @19DC stack[-3] // } 19D0 5B JUMPDEST 19D1 60 PUSH1 0x1f 19D3 19 NOT 19D4 60 PUSH1 0x1f 19D6 83 DUP4 19D7 01 ADD 19D8 16 AND 19D9 60 PUSH1 0x20 19DB 01 ADD 19DC 92 SWAP3 19DD 91 SWAP2 19DE 50 POP 19DF 50 POP 19E0 56 *JUMP // Stack delta = -2 // Outputs[1] { @19DC stack[-3] = 0x20 + (stack[-2] + 0x1f & ~0x1f) } // Block ends with unconditional jump to stack[-3] label_19E1: // Incoming call from 0x1A20, returns to 0x090E // Inputs[5] // { // @19E2 stack[-3] // @19E3 stack[-1] // @19E4 stack[-2] // @19E5 msg.data[stack[-1]:stack[-1] + stack[-3]] // @19EC stack[-4] // } 19E1 5B JUMPDEST 19E2 82 DUP3 19E3 81 DUP2 19E4 83 DUP4 19E5 37 CALLDATACOPY 19E6 50 POP 19E7 60 PUSH1 0x00 19E9 91 SWAP2 19EA 01 ADD 19EB 52 MSTORE 19EC 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @19E5 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @19EB memory[stack[-3] + stack[-2]:stack[-3] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_19ED: // Incoming call from 0x1A44, returns to 0x17BE // Inputs[1] { @19F6 stack[-2] } 19ED 5B JUMPDEST 19EE 60 PUSH1 0x00 19F0 61 PUSH2 0x19fb 19F3 61 PUSH2 0x1941 19F6 84 DUP5 19F7 61 PUSH2 0x19b7 19FA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19EE stack[0] = 0x00 // @19F0 stack[1] = 0x19fb // @19F3 stack[2] = 0x1941 // @19F6 stack[3] = stack[-2] // } // Block ends with call to 0x19b7, returns to 0x1941 label_19FB: // Incoming return from call to 0x1941 at 0x19FA // Inputs[5] // { // @19FC stack[-2] // @19FC stack[-1] // @19FE stack[-4] // @1A05 stack[-5] // @1A07 stack[-3] // } 19FB 5B JUMPDEST 19FC 90 SWAP1 19FD 50 POP 19FE 82 DUP3 19FF 81 DUP2 1A00 52 MSTORE 1A01 60 PUSH1 0x20 1A03 81 DUP2 1A04 01 ADD 1A05 84 DUP5 1A06 84 DUP5 1A07 84 DUP5 1A08 01 ADD 1A09 11 GT 1A0A 15 ISZERO 1A0B 61 PUSH2 0x1a16 1A0E 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @19FC stack[-2] = stack[-1] // @1A00 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1A04 stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x1a16, if !(stack[-3] + stack[-4] > stack[-5]) label_1A0F: // Incoming jump from 0x1A0E, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @1A15 memory[0x00:0x00] } 1A0F 61 PUSH2 0x1a16 1A12 60 PUSH1 0x00 1A14 80 DUP1 1A15 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1A0F stack[0] = 0x1a16 // @1A15 revert(memory[0x00:0x00]); // } // Block terminates label_1A16: // Incoming jump from 0x1A0E, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @1A1A stack[-4] // @1A1B stack[-1] // @1A1C stack[-3] // } 1A16 5B JUMPDEST 1A17 61 PUSH2 0x090e 1A1A 84 DUP5 1A1B 82 DUP3 1A1C 85 DUP6 1A1D 61 PUSH2 0x19e1 1A20 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A17 stack[0] = 0x090e // @1A1A stack[1] = stack[-4] // @1A1B stack[2] = stack[-1] // @1A1C stack[3] = stack[-3] // } // Block ends with call to 0x19e1, returns to 0x090E label_1A21: // Incoming jump from 0x1D2E // Inputs[2] // { // @1A24 stack[-2] // @1A27 stack[-1] // } 1A21 5B JUMPDEST 1A22 60 PUSH1 0x00 1A24 82 DUP3 1A25 60 PUSH1 0x1f 1A27 83 DUP4 1A28 01 ADD 1A29 12 SLT 1A2A 61 PUSH2 0x1a35 1A2D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A22 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a35, if stack[-1] + 0x1f i< stack[-2] label_1A2E: // Incoming jump from 0x1A2D, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1A34 memory[0x00:0x00] } 1A2E 61 PUSH2 0x1a35 1A31 60 PUSH1 0x00 1A33 80 DUP1 1A34 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1A2E stack[0] = 0x1a35 // @1A34 revert(memory[0x00:0x00]); // } // Block terminates label_1A35: // Incoming jump from 0x1A2D, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1A36 stack[-2] // @1A37 msg.data[stack[-2]:stack[-2] + 0x20] // @1A3B stack[-3] // } 1A35 5B JUMPDEST 1A36 81 DUP2 1A37 35 CALLDATALOAD 1A38 61 PUSH2 0x17be 1A3B 84 DUP5 1A3C 82 DUP3 1A3D 60 PUSH1 0x20 1A3F 86 DUP7 1A40 01 ADD 1A41 61 PUSH2 0x19ed 1A44 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1A37 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1A38 stack[1] = 0x17be // @1A3B stack[2] = stack[-3] // @1A3C stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1A40 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x19ed, returns to 0x17BE label_1A45: // Incoming jump from 0x02A0 // Inputs[2] // { // @1A50 stack[-1] // @1A51 stack[-2] // } 1A45 5B JUMPDEST 1A46 60 PUSH1 0x00 1A48 80 DUP1 1A49 60 PUSH1 0x00 1A4B 80 DUP1 1A4C 60 PUSH1 0x00 1A4E 60 PUSH1 0xa0 1A50 86 DUP7 1A51 88 DUP9 1A52 03 SUB 1A53 12 SLT 1A54 15 ISZERO 1A55 61 PUSH2 0x1a60 1A58 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1A46 stack[0] = 0x00 // @1A48 stack[1] = 0x00 // @1A49 stack[2] = 0x00 // @1A4B stack[3] = 0x00 // @1A4C stack[4] = 0x00 // } // Block ends with conditional jump to 0x1a60, if !(stack[-2] - stack[-1] i< 0xa0) label_1A59: // Incoming jump from 0x1A58, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1A5F memory[0x00:0x00] } 1A59 61 PUSH2 0x1a60 1A5C 60 PUSH1 0x00 1A5E 80 DUP1 1A5F FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1A59 stack[0] = 0x1a60 // @1A5F revert(memory[0x00:0x00]); // } // Block terminates label_1A60: // Incoming jump from 0x1A58, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1A66 stack[-7] // @1A67 stack[-6] // } 1A60 5B JUMPDEST 1A61 60 PUSH1 0x00 1A63 61 PUSH2 0x1a6c 1A66 88 DUP9 1A67 88 DUP9 1A68 61 PUSH2 0x1713 1A6B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A61 stack[0] = 0x00 // @1A63 stack[1] = 0x1a6c // @1A66 stack[2] = stack[-7] // @1A67 stack[3] = stack[-6] // } // Block ends with unconditional jump to 0x1713 1A6C 5B JUMPDEST 1A6D 95 SWAP6 1A6E 50 POP 1A6F 50 POP 1A70 60 PUSH1 0x20 1A72 61 PUSH2 0x1a7d 1A75 88 DUP9 1A76 82 DUP3 1A77 89 DUP10 1A78 01 ADD 1A79 61 PUSH2 0x1713 1A7C 56 *JUMP 1A7D 5B JUMPDEST 1A7E 94 SWAP5 1A7F 50 POP 1A80 50 POP 1A81 60 PUSH1 0x40 1A83 86 DUP7 1A84 01 ADD 1A85 35 CALLDATALOAD 1A86 60 PUSH1 0x01 1A88 60 PUSH1 0x01 1A8A 60 PUSH1 0x40 1A8C 1B SHL 1A8D 03 SUB 1A8E 81 DUP2 1A8F 11 GT 1A90 15 ISZERO 1A91 61 PUSH2 0x1a9c 1A94 57 *JUMPI 1A95 61 PUSH2 0x1a9c 1A98 60 PUSH1 0x00 1A9A 80 DUP1 1A9B FD *REVERT 1A9C 5B JUMPDEST 1A9D 61 PUSH2 0x1aa8 1AA0 88 DUP9 1AA1 82 DUP3 1AA2 89 DUP10 1AA3 01 ADD 1AA4 61 PUSH2 0x1993 1AA7 56 *JUMP 1AA8 5B JUMPDEST 1AA9 93 SWAP4 1AAA 50 POP 1AAB 50 POP 1AAC 60 PUSH1 0x60 1AAE 86 DUP7 1AAF 01 ADD 1AB0 35 CALLDATALOAD 1AB1 60 PUSH1 0x01 1AB3 60 PUSH1 0x01 1AB5 60 PUSH1 0x40 1AB7 1B SHL 1AB8 03 SUB 1AB9 81 DUP2 1ABA 11 GT 1ABB 15 ISZERO 1ABC 61 PUSH2 0x1ac7 1ABF 57 *JUMPI 1AC0 61 PUSH2 0x1ac7 1AC3 60 PUSH1 0x00 1AC5 80 DUP1 1AC6 FD *REVERT 1AC7 5B JUMPDEST 1AC8 61 PUSH2 0x1ad3 1ACB 88 DUP9 1ACC 82 DUP3 1ACD 89 DUP10 1ACE 01 ADD 1ACF 61 PUSH2 0x1993 1AD2 56 *JUMP 1AD3 5B JUMPDEST 1AD4 92 SWAP3 1AD5 50 POP 1AD6 50 POP 1AD7 60 PUSH1 0x80 1AD9 86 DUP7 1ADA 01 ADD 1ADB 35 CALLDATALOAD 1ADC 60 PUSH1 0x01 1ADE 60 PUSH1 0x01 1AE0 60 PUSH1 0x40 1AE2 1B SHL 1AE3 03 SUB 1AE4 81 DUP2 1AE5 11 GT 1AE6 15 ISZERO 1AE7 61 PUSH2 0x1af2 1AEA 57 *JUMPI 1AEB 61 PUSH2 0x1af2 1AEE 60 PUSH1 0x00 1AF0 80 DUP1 1AF1 FD *REVERT 1AF2 5B JUMPDEST 1AF3 61 PUSH2 0x1afe 1AF6 88 DUP9 1AF7 82 DUP3 1AF8 89 DUP10 1AF9 01 ADD 1AFA 61 PUSH2 0x1a21 1AFD 56 *JUMP 1AFE 5B JUMPDEST 1AFF 91 SWAP2 1B00 50 POP 1B01 50 POP 1B02 92 SWAP3 1B03 95 SWAP6 1B04 50 POP 1B05 92 SWAP3 1B06 95 SWAP6 1B07 90 SWAP1 1B08 93 SWAP4 1B09 50 POP 1B0A 56 *JUMP label_1B0B: // Incoming jump from 0x02B5 // Incoming jump from 0x02C8 // Incoming jump from 0x03AB // Incoming jump from 0x034F // Inputs[2] // { // @1B11 stack[-1] // @1B12 stack[-2] // } 1B0B 5B JUMPDEST 1B0C 60 PUSH1 0x00 1B0E 80 DUP1 1B0F 60 PUSH1 0x40 1B11 83 DUP4 1B12 85 DUP6 1B13 03 SUB 1B14 12 SLT 1B15 15 ISZERO 1B16 61 PUSH2 0x1b21 1B19 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B0C stack[0] = 0x00 // @1B0E stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b21, if !(stack[-2] - stack[-1] i< 0x40) label_1B1A: // Incoming jump from 0x1B19, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B20 memory[0x00:0x00] } 1B1A 61 PUSH2 0x1b21 1B1D 60 PUSH1 0x00 1B1F 80 DUP1 1B20 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1B1A stack[0] = 0x1b21 // @1B20 revert(memory[0x00:0x00]); // } // Block terminates label_1B21: // Incoming jump from 0x1B19, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1B27 stack[-4] // @1B28 stack[-3] // } 1B21 5B JUMPDEST 1B22 60 PUSH1 0x00 1B24 61 PUSH2 0x1b2d 1B27 85 DUP6 1B28 85 DUP6 1B29 61 PUSH2 0x1724 1B2C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B22 stack[0] = 0x00 // @1B24 stack[1] = 0x1b2d // @1B27 stack[2] = stack[-4] // @1B28 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1724 1B2D 5B JUMPDEST 1B2E 92 SWAP3 1B2F 50 POP 1B30 50 POP 1B31 60 PUSH1 0x20 1B33 61 PUSH2 0x1762 1B36 85 DUP6 1B37 82 DUP3 1B38 86 DUP7 1B39 01 ADD 1B3A 61 PUSH2 0x1713 1B3D 56 *JUMP label_1B3E: // Incoming jump from 0x02DB // Incoming jump from 0x037D // Inputs[2] // { // @1B43 stack[-1] // @1B44 stack[-2] // } 1B3E 5B JUMPDEST 1B3F 60 PUSH1 0x00 1B41 60 PUSH1 0x20 1B43 82 DUP3 1B44 84 DUP5 1B45 03 SUB 1B46 12 SLT 1B47 15 ISZERO 1B48 61 PUSH2 0x1b53 1B4B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B3F stack[0] = 0x00 } // Block ends with conditional jump to 0x1b53, if !(stack[-2] - stack[-1] i< 0x20) label_1B4C: // Incoming jump from 0x1B4B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B52 memory[0x00:0x00] } 1B4C 61 PUSH2 0x1b53 1B4F 60 PUSH1 0x00 1B51 80 DUP1 1B52 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1B4C stack[0] = 0x1b53 // @1B52 revert(memory[0x00:0x00]); // } // Block terminates label_1B53: // Incoming jump from 0x1B4B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B59 stack[-3] // @1B5A stack[-2] // } 1B53 5B JUMPDEST 1B54 60 PUSH1 0x00 1B56 61 PUSH2 0x17be 1B59 84 DUP5 1B5A 84 DUP5 1B5B 61 PUSH2 0x1713 1B5E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B54 stack[0] = 0x00 // @1B56 stack[1] = 0x17be // @1B59 stack[2] = stack[-3] // @1B5A stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1713 label_1B5F: // Incoming jump from 0x02EE // Inputs[2] // { // @1B65 stack[-1] // @1B66 stack[-2] // } 1B5F 5B JUMPDEST 1B60 60 PUSH1 0x00 1B62 80 DUP1 1B63 60 PUSH1 0x40 1B65 83 DUP4 1B66 85 DUP6 1B67 03 SUB 1B68 12 SLT 1B69 15 ISZERO 1B6A 61 PUSH2 0x1b75 1B6D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B60 stack[0] = 0x00 // @1B62 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b75, if !(stack[-2] - stack[-1] i< 0x40) label_1B6E: // Incoming jump from 0x1B6D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B74 memory[0x00:0x00] } 1B6E 61 PUSH2 0x1b75 1B71 60 PUSH1 0x00 1B73 80 DUP1 1B74 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1B6E stack[0] = 0x1b75 // @1B74 revert(memory[0x00:0x00]); // } // Block terminates label_1B75: // Incoming jump from 0x1B6D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1B7B stack[-4] // @1B7C stack[-3] // } 1B75 5B JUMPDEST 1B76 60 PUSH1 0x00 1B78 61 PUSH2 0x1b81 1B7B 85 DUP6 1B7C 85 DUP6 1B7D 61 PUSH2 0x1724 1B80 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B76 stack[0] = 0x00 // @1B78 stack[1] = 0x1b81 // @1B7B stack[2] = stack[-4] // @1B7C stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1724 1B81 5B JUMPDEST 1B82 92 SWAP3 1B83 50 POP 1B84 50 POP 1B85 60 PUSH1 0x20 1B87 83 DUP4 1B88 01 ADD 1B89 35 CALLDATALOAD 1B8A 60 PUSH1 0x01 1B8C 60 PUSH1 0x01 1B8E 60 PUSH1 0x40 1B90 1B SHL 1B91 03 SUB 1B92 81 DUP2 1B93 11 GT 1B94 15 ISZERO 1B95 61 PUSH2 0x1ba0 1B98 57 *JUMPI 1B99 61 PUSH2 0x1ba0 1B9C 60 PUSH1 0x00 1B9E 80 DUP1 1B9F FD *REVERT 1BA0 5B JUMPDEST 1BA1 61 PUSH2 0x1762 1BA4 85 DUP6 1BA5 82 DUP3 1BA6 86 DUP7 1BA7 01 ADD 1BA8 61 PUSH2 0x1a21 1BAB 56 *JUMP label_1BAC: // Incoming call from 0x1C20, returns to 0x17BE // Inputs[1] { @1BB5 stack[-2] } 1BAC 5B JUMPDEST 1BAD 60 PUSH1 0x00 1BAF 61 PUSH2 0x1bba 1BB2 61 PUSH2 0x1941 1BB5 84 DUP5 1BB6 61 PUSH2 0x1910 1BB9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BAD stack[0] = 0x00 // @1BAF stack[1] = 0x1bba // @1BB2 stack[2] = 0x1941 // @1BB5 stack[3] = stack[-2] // } // Block ends with call to 0x1910, returns to 0x1941 label_1BBA: // Incoming return from call to 0x1941 at 0x1BB9 // Inputs[5] // { // @1BBB stack[-4] // @1BBC stack[-1] // @1BBE stack[-2] // @1BC8 stack[-3] // @1BCA stack[-5] // } 1BBA 5B JUMPDEST 1BBB 83 DUP4 1BBC 81 DUP2 1BBD 52 MSTORE 1BBE 90 SWAP1 1BBF 50 POP 1BC0 60 PUSH1 0x20 1BC2 80 DUP1 1BC3 82 DUP3 1BC4 01 ADD 1BC5 90 SWAP1 1BC6 84 DUP5 1BC7 02 MUL 1BC8 83 DUP4 1BC9 01 ADD 1BCA 85 DUP6 1BCB 81 DUP2 1BCC 11 GT 1BCD 15 ISZERO 1BCE 61 PUSH2 0x1bd9 1BD1 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1BBD memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1BBE stack[-2] = stack[-1] // @1BC5 stack[-1] = stack[-1] + 0x20 // @1BC9 stack[0] = stack[-3] + stack[-4] * 0x20 // } // Block ends with conditional jump to 0x1bd9, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) label_1BD2: // Incoming jump from 0x1BD1, if not !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @1BD8 memory[0x00:0x00] } 1BD2 61 PUSH2 0x1bd9 1BD5 60 PUSH1 0x00 1BD7 80 DUP1 1BD8 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1BD2 stack[0] = 0x1bd9 // @1BD8 revert(memory[0x00:0x00]); // } // Block terminates label_1BD9: // Incoming jump from 0x1BD1, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[2] // { // @1BDA stack[-4] // @1BDC stack[-1] // } 1BD9 5B JUMPDEST 1BDA 83 DUP4 1BDB 5B JUMPDEST 1BDC 81 DUP2 1BDD 81 DUP2 1BDE 10 LT 1BDF 15 ISZERO 1BE0 61 PUSH2 0x1989 1BE3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BDA stack[0] = stack[-4] } // Block ends with conditional jump to 0x1989, if !(stack[-4] < stack[-1]) label_1BE4: // Incoming jump from 0x1BE3, if not !(stack[-4] < stack[-1]) // Inputs[2] // { // @1BE4 stack[-1] // @1BE8 stack[-7] // } 1BE4 80 DUP1 1BE5 61 PUSH2 0x1bee 1BE8 88 DUP9 1BE9 82 DUP3 1BEA 61 PUSH2 0x1713 1BED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BE4 stack[0] = stack[-1] // @1BE5 stack[1] = 0x1bee // @1BE8 stack[2] = stack[-7] // @1BE9 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1713 1BEE 5B JUMPDEST 1BEF 84 DUP5 1BF0 52 MSTORE 1BF1 50 POP 1BF2 60 PUSH1 0x20 1BF4 92 SWAP3 1BF5 83 DUP4 1BF6 01 ADD 1BF7 92 SWAP3 1BF8 01 ADD 1BF9 61 PUSH2 0x1bdb 1BFC 56 *JUMP label_1BFD: // Incoming call from 0x1C5B, returns to 0x1C5C // Inputs[2] // { // @1C00 stack[-2] // @1C03 stack[-1] // } 1BFD 5B JUMPDEST 1BFE 60 PUSH1 0x00 1C00 82 DUP3 1C01 60 PUSH1 0x1f 1C03 83 DUP4 1C04 01 ADD 1C05 12 SLT 1C06 61 PUSH2 0x1c11 1C09 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BFE stack[0] = 0x00 } // Block ends with conditional jump to 0x1c11, if stack[-1] + 0x1f i< stack[-2] label_1C0A: // Incoming jump from 0x1C09, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1C10 memory[0x00:0x00] } 1C0A 61 PUSH2 0x1c11 1C0D 60 PUSH1 0x00 1C0F 80 DUP1 1C10 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C0A stack[0] = 0x1c11 // @1C10 revert(memory[0x00:0x00]); // } // Block terminates label_1C11: // Incoming jump from 0x1C09, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1C12 stack[-2] // @1C13 msg.data[stack[-2]:stack[-2] + 0x20] // @1C17 stack[-3] // } 1C11 5B JUMPDEST 1C12 81 DUP2 1C13 35 CALLDATALOAD 1C14 61 PUSH2 0x17be 1C17 84 DUP5 1C18 82 DUP3 1C19 60 PUSH1 0x20 1C1B 86 DUP7 1C1C 01 ADD 1C1D 61 PUSH2 0x1bac 1C20 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1C13 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1C14 stack[1] = 0x17be // @1C17 stack[2] = stack[-3] // @1C18 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1C1C stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x1bac, returns to 0x17BE label_1C21: // Incoming jump from 0x0309 // Inputs[2] // { // @1C27 stack[-1] // @1C28 stack[-2] // } 1C21 5B JUMPDEST 1C22 60 PUSH1 0x00 1C24 80 DUP1 1C25 60 PUSH1 0x40 1C27 83 DUP4 1C28 85 DUP6 1C29 03 SUB 1C2A 12 SLT 1C2B 15 ISZERO 1C2C 61 PUSH2 0x1c37 1C2F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C22 stack[0] = 0x00 // @1C24 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c37, if !(stack[-2] - stack[-1] i< 0x40) label_1C30: // Incoming jump from 0x1C2F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1C36 memory[0x00:0x00] } 1C30 61 PUSH2 0x1c37 1C33 60 PUSH1 0x00 1C35 80 DUP1 1C36 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C30 stack[0] = 0x1c37 // @1C36 revert(memory[0x00:0x00]); // } // Block terminates label_1C37: // Incoming jump from 0x1C2F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1C38 stack[-3] // @1C39 msg.data[stack[-3]:stack[-3] + 0x20] // } 1C37 5B JUMPDEST 1C38 82 DUP3 1C39 35 CALLDATALOAD 1C3A 60 PUSH1 0x01 1C3C 60 PUSH1 0x01 1C3E 60 PUSH1 0x40 1C40 1B SHL 1C41 03 SUB 1C42 81 DUP2 1C43 11 GT 1C44 15 ISZERO 1C45 61 PUSH2 0x1c50 1C48 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C39 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1c50, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_1C49: // Incoming jump from 0x1C48, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1C4F memory[0x00:0x00] } 1C49 61 PUSH2 0x1c50 1C4C 60 PUSH1 0x00 1C4E 80 DUP1 1C4F FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C49 stack[0] = 0x1c50 // @1C4F revert(memory[0x00:0x00]); // } // Block terminates label_1C50: // Incoming jump from 0x1C48, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1C54 stack[-5] // @1C55 stack[-1] // @1C56 stack[-4] // } 1C50 5B JUMPDEST 1C51 61 PUSH2 0x1c5c 1C54 85 DUP6 1C55 82 DUP3 1C56 86 DUP7 1C57 01 ADD 1C58 61 PUSH2 0x1bfd 1C5B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C51 stack[0] = 0x1c5c // @1C54 stack[1] = stack[-5] // @1C57 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1bfd, returns to 0x1C5C label_1C5C: // Incoming return from call to 0x1BFD at 0x1C5B // Inputs[4] // { // @1C5D stack[-1] // @1C5D stack[-4] // @1C62 stack[-5] // @1C64 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 1C5C 5B JUMPDEST 1C5D 92 SWAP3 1C5E 50 POP 1C5F 50 POP 1C60 60 PUSH1 0x20 1C62 83 DUP4 1C63 01 ADD 1C64 35 CALLDATALOAD 1C65 60 PUSH1 0x01 1C67 60 PUSH1 0x01 1C69 60 PUSH1 0x40 1C6B 1B SHL 1C6C 03 SUB 1C6D 81 DUP2 1C6E 11 GT 1C6F 15 ISZERO 1C70 61 PUSH2 0x1c7b 1C73 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1C5D stack[-4] = stack[-1] // @1C64 stack[-2] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1c7b, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_1C74: // Incoming jump from 0x1C73, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1C7A memory[0x00:0x00] } 1C74 61 PUSH2 0x1c7b 1C77 60 PUSH1 0x00 1C79 80 DUP1 1C7A FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C74 stack[0] = 0x1c7b // @1C7A revert(memory[0x00:0x00]); // } // Block terminates label_1C7B: // Incoming jump from 0x1C73, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1C7F stack[-5] // @1C80 stack[-1] // @1C81 stack[-4] // } 1C7B 5B JUMPDEST 1C7C 61 PUSH2 0x1762 1C7F 85 DUP6 1C80 82 DUP3 1C81 86 DUP7 1C82 01 ADD 1C83 61 PUSH2 0x1993 1C86 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C7C stack[0] = 0x1762 // @1C7F stack[1] = stack[-5] // @1C82 stack[2] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x1993 1C87 5B JUMPDEST 1C88 60 PUSH1 0x00 1C8A 61 PUSH2 0x1c93 1C8D 83 DUP4 1C8E 83 DUP4 1C8F 61 PUSH2 0x176c 1C92 56 *JUMP 1C93 5B JUMPDEST 1C94 50 POP 1C95 50 POP 1C96 60 PUSH1 0x20 1C98 01 ADD 1C99 90 SWAP1 1C9A 56 *JUMP 1C9B 5B JUMPDEST 1C9C 60 PUSH1 0x00 1C9E 61 PUSH2 0x1ca5 1CA1 82 DUP3 1CA2 51 MLOAD 1CA3 90 SWAP1 1CA4 56 *JUMP 1CA5 5B JUMPDEST 1CA6 80 DUP1 1CA7 84 DUP5 1CA8 52 MSTORE 1CA9 60 PUSH1 0x20 1CAB 93 SWAP4 1CAC 84 DUP5 1CAD 01 ADD 1CAE 93 SWAP4 1CAF 83 DUP4 1CB0 01 ADD 1CB1 80 DUP1 1CB2 60 PUSH1 0x00 1CB4 5B JUMPDEST 1CB5 83 DUP4 1CB6 81 DUP2 1CB7 10 LT 1CB8 15 ISZERO 1CB9 61 PUSH2 0x1cd9 1CBC 57 *JUMPI 1CBD 81 DUP2 1CBE 51 MLOAD 1CBF 61 PUSH2 0x1cc8 1CC2 88 DUP9 1CC3 82 DUP3 1CC4 61 PUSH2 0x1c87 1CC7 56 *JUMP 1CC8 5B JUMPDEST 1CC9 97 SWAP8 1CCA 50 POP 1CCB 60 PUSH1 0x20 1CCD 83 DUP4 1CCE 01 ADD 1CCF 92 SWAP3 1CD0 50 POP 1CD1 50 POP 1CD2 60 PUSH1 0x01 1CD4 01 ADD 1CD5 61 PUSH2 0x1cb4 1CD8 56 *JUMP 1CD9 5B JUMPDEST 1CDA 50 POP 1CDB 94 SWAP5 1CDC 95 SWAP6 1CDD 94 SWAP5 1CDE 50 POP 1CDF 50 POP 1CE0 50 POP 1CE1 50 POP 1CE2 50 POP 1CE3 56 *JUMP 1CE4 5B JUMPDEST 1CE5 60 PUSH1 0x20 1CE7 80 DUP1 1CE8 82 DUP3 1CE9 52 MSTORE 1CEA 81 DUP2 1CEB 01 ADD 1CEC 61 PUSH2 0x0cd4 1CEF 81 DUP2 1CF0 84 DUP5 1CF1 61 PUSH2 0x1c9b 1CF4 56 *JUMP label_1CF5: // Incoming jump from 0x0362 // Incoming jump from 0x0329 // Inputs[2] // { // @1CFA stack[-1] // @1CFB stack[-2] // } 1CF5 5B JUMPDEST 1CF6 60 PUSH1 0x00 1CF8 60 PUSH1 0x20 1CFA 82 DUP3 1CFB 84 DUP5 1CFC 03 SUB 1CFD 12 SLT 1CFE 15 ISZERO 1CFF 61 PUSH2 0x1d0a 1D02 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CF6 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d0a, if !(stack[-2] - stack[-1] i< 0x20) label_1D03: // Incoming jump from 0x1D02, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D09 memory[0x00:0x00] } 1D03 61 PUSH2 0x1d0a 1D06 60 PUSH1 0x00 1D08 80 DUP1 1D09 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1D03 stack[0] = 0x1d0a // @1D09 revert(memory[0x00:0x00]); // } // Block terminates label_1D0A: // Incoming jump from 0x1D02, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D0B stack[-2] // @1D0C msg.data[stack[-2]:stack[-2] + 0x20] // } 1D0A 5B JUMPDEST 1D0B 81 DUP2 1D0C 35 CALLDATALOAD 1D0D 60 PUSH1 0x01 1D0F 60 PUSH1 0x01 1D11 60 PUSH1 0x40 1D13 1B SHL 1D14 03 SUB 1D15 81 DUP2 1D16 11 GT 1D17 15 ISZERO 1D18 61 PUSH2 0x1d23 1D1B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D0C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1d23, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_1D1C: // Incoming jump from 0x1D1B, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1D22 memory[0x00:0x00] } 1D1C 61 PUSH2 0x1d23 1D1F 60 PUSH1 0x00 1D21 80 DUP1 1D22 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1D1C stack[0] = 0x1d23 // @1D22 revert(memory[0x00:0x00]); // } // Block terminates label_1D23: // Incoming jump from 0x1D1B, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1D27 stack[-4] // @1D28 stack[-1] // @1D29 stack[-3] // } 1D23 5B JUMPDEST 1D24 61 PUSH2 0x17be 1D27 84 DUP5 1D28 82 DUP3 1D29 85 DUP6 1D2A 01 ADD 1D2B 61 PUSH2 0x1a21 1D2E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D24 stack[0] = 0x17be // @1D27 stack[1] = stack[-4] // @1D2A stack[2] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x1a21 1D2F 5B JUMPDEST 1D30 80 DUP1 1D31 15 ISZERO 1D32 15 ISZERO 1D33 61 PUSH2 0x1708 1D36 56 *JUMP 1D37 5B JUMPDEST 1D38 80 DUP1 1D39 35 CALLDATALOAD 1D3A 61 PUSH2 0x04aa 1D3D 81 DUP2 1D3E 61 PUSH2 0x1d2f 1D41 56 *JUMP label_1D42: // Incoming jump from 0x0398 // Inputs[2] // { // @1D48 stack[-1] // @1D49 stack[-2] // } 1D42 5B JUMPDEST 1D43 60 PUSH1 0x00 1D45 80 DUP1 1D46 60 PUSH1 0x40 1D48 83 DUP4 1D49 85 DUP6 1D4A 03 SUB 1D4B 12 SLT 1D4C 15 ISZERO 1D4D 61 PUSH2 0x1d58 1D50 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D43 stack[0] = 0x00 // @1D45 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d58, if !(stack[-2] - stack[-1] i< 0x40) label_1D51: // Incoming jump from 0x1D50, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D57 memory[0x00:0x00] } 1D51 61 PUSH2 0x1d58 1D54 60 PUSH1 0x00 1D56 80 DUP1 1D57 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1D51 stack[0] = 0x1d58 // @1D57 revert(memory[0x00:0x00]); // } // Block terminates label_1D58: // Incoming jump from 0x1D50, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D5E stack[-4] // @1D5F stack[-3] // } 1D58 5B JUMPDEST 1D59 60 PUSH1 0x00 1D5B 61 PUSH2 0x1d64 1D5E 85 DUP6 1D5F 85 DUP6 1D60 61 PUSH2 0x1713 1D63 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D59 stack[0] = 0x00 // @1D5B stack[1] = 0x1d64 // @1D5E stack[2] = stack[-4] // @1D5F stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1713 1D64 5B JUMPDEST 1D65 92 SWAP3 1D66 50 POP 1D67 50 POP 1D68 60 PUSH1 0x20 1D6A 61 PUSH2 0x1762 1D6D 85 DUP6 1D6E 82 DUP3 1D6F 86 DUP7 1D70 01 ADD 1D71 61 PUSH2 0x1d37 1D74 56 *JUMP label_1D75: // Incoming jump from 0x03D1 // Inputs[2] // { // @1D7D stack[-1] // @1D7E stack[-2] // } 1D75 5B JUMPDEST 1D76 60 PUSH1 0x00 1D78 80 DUP1 1D79 60 PUSH1 0x00 1D7B 60 PUSH1 0x60 1D7D 84 DUP5 1D7E 86 DUP7 1D7F 03 SUB 1D80 12 SLT 1D81 15 ISZERO 1D82 61 PUSH2 0x1d8d 1D85 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D76 stack[0] = 0x00 // @1D78 stack[1] = 0x00 // @1D79 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1d8d, if !(stack[-2] - stack[-1] i< 0x60) label_1D86: // Incoming jump from 0x1D85, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1D8C memory[0x00:0x00] } 1D86 61 PUSH2 0x1d8d 1D89 60 PUSH1 0x00 1D8B 80 DUP1 1D8C FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1D86 stack[0] = 0x1d8d // @1D8C revert(memory[0x00:0x00]); // } // Block terminates label_1D8D: // Incoming jump from 0x1D85, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1D93 stack[-5] // @1D94 stack[-4] // } 1D8D 5B JUMPDEST 1D8E 60 PUSH1 0x00 1D90 61 PUSH2 0x1d99 1D93 86 DUP7 1D94 86 DUP7 1D95 61 PUSH2 0x1724 1D98 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D8E stack[0] = 0x00 // @1D90 stack[1] = 0x1d99 // @1D93 stack[2] = stack[-5] // @1D94 stack[3] = stack[-4] // } // Block ends with unconditional jump to 0x1724 1D99 5B JUMPDEST 1D9A 93 SWAP4 1D9B 50 POP 1D9C 50 POP 1D9D 60 PUSH1 0x20 1D9F 61 PUSH2 0x1daa 1DA2 86 DUP7 1DA3 82 DUP3 1DA4 87 DUP8 1DA5 01 ADD 1DA6 61 PUSH2 0x1724 1DA9 56 *JUMP 1DAA 5B JUMPDEST 1DAB 92 SWAP3 1DAC 50 POP 1DAD 50 POP 1DAE 60 PUSH1 0x40 1DB0 61 PUSH2 0x1dbb 1DB3 86 DUP7 1DB4 82 DUP3 1DB5 87 DUP8 1DB6 01 ADD 1DB7 61 PUSH2 0x1713 1DBA 56 *JUMP 1DBB 5B JUMPDEST 1DBC 91 SWAP2 1DBD 50 POP 1DBE 50 POP 1DBF 92 SWAP3 1DC0 50 POP 1DC1 92 SWAP3 1DC2 50 POP 1DC3 92 SWAP3 1DC4 56 *JUMP label_1DC5: // Incoming jump from 0x03EC // Inputs[2] // { // @1DCB stack[-1] // @1DCC stack[-2] // } 1DC5 5B JUMPDEST 1DC6 60 PUSH1 0x00 1DC8 80 DUP1 1DC9 60 PUSH1 0x40 1DCB 83 DUP4 1DCC 85 DUP6 1DCD 03 SUB 1DCE 12 SLT 1DCF 15 ISZERO 1DD0 61 PUSH2 0x1ddb 1DD3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DC6 stack[0] = 0x00 // @1DC8 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ddb, if !(stack[-2] - stack[-1] i< 0x40) label_1DD4: // Incoming jump from 0x1DD3, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1DDA memory[0x00:0x00] } 1DD4 61 PUSH2 0x1ddb 1DD7 60 PUSH1 0x00 1DD9 80 DUP1 1DDA FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1DD4 stack[0] = 0x1ddb // @1DDA revert(memory[0x00:0x00]); // } // Block terminates label_1DDB: // Incoming jump from 0x1DD3, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DE1 stack[-4] // @1DE2 stack[-3] // } 1DDB 5B JUMPDEST 1DDC 60 PUSH1 0x00 1DDE 61 PUSH2 0x1b2d 1DE1 85 DUP6 1DE2 85 DUP6 1DE3 61 PUSH2 0x1713 1DE6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DDC stack[0] = 0x00 // @1DDE stack[1] = 0x1b2d // @1DE1 stack[2] = stack[-4] // @1DE2 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1713 label_1DE7: // Incoming jump from 0x0428 // Inputs[2] // { // @1DF2 stack[-1] // @1DF3 stack[-2] // } 1DE7 5B JUMPDEST 1DE8 60 PUSH1 0x00 1DEA 80 DUP1 1DEB 60 PUSH1 0x00 1DED 80 DUP1 1DEE 60 PUSH1 0x00 1DF0 60 PUSH1 0xa0 1DF2 86 DUP7 1DF3 88 DUP9 1DF4 03 SUB 1DF5 12 SLT 1DF6 15 ISZERO 1DF7 61 PUSH2 0x1e02 1DFA 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1DE8 stack[0] = 0x00 // @1DEA stack[1] = 0x00 // @1DEB stack[2] = 0x00 // @1DED stack[3] = 0x00 // @1DEE stack[4] = 0x00 // } // Block ends with conditional jump to 0x1e02, if !(stack[-2] - stack[-1] i< 0xa0) label_1DFB: // Incoming jump from 0x1DFA, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1E01 memory[0x00:0x00] } 1DFB 61 PUSH2 0x1e02 1DFE 60 PUSH1 0x00 1E00 80 DUP1 1E01 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1DFB stack[0] = 0x1e02 // @1E01 revert(memory[0x00:0x00]); // } // Block terminates label_1E02: // Incoming jump from 0x1DFA, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1E08 stack[-7] // @1E09 stack[-6] // } 1E02 5B JUMPDEST 1E03 60 PUSH1 0x00 1E05 61 PUSH2 0x1e0e 1E08 88 DUP9 1E09 88 DUP9 1E0A 61 PUSH2 0x1713 1E0D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E03 stack[0] = 0x00 // @1E05 stack[1] = 0x1e0e // @1E08 stack[2] = stack[-7] // @1E09 stack[3] = stack[-6] // } // Block ends with unconditional jump to 0x1713 1E0E 5B JUMPDEST 1E0F 95 SWAP6 1E10 50 POP 1E11 50 POP 1E12 60 PUSH1 0x20 1E14 61 PUSH2 0x1e1f 1E17 88 DUP9 1E18 82 DUP3 1E19 89 DUP10 1E1A 01 ADD 1E1B 61 PUSH2 0x1713 1E1E 56 *JUMP 1E1F 5B JUMPDEST 1E20 94 SWAP5 1E21 50 POP 1E22 50 POP 1E23 60 PUSH1 0x40 1E25 61 PUSH2 0x1e30 1E28 88 DUP9 1E29 82 DUP3 1E2A 89 DUP10 1E2B 01 ADD 1E2C 61 PUSH2 0x1724 1E2F 56 *JUMP 1E30 5B JUMPDEST 1E31 93 SWAP4 1E32 50 POP 1E33 50 POP 1E34 60 PUSH1 0x60 1E36 61 PUSH2 0x1ad3 1E39 88 DUP9 1E3A 82 DUP3 1E3B 89 DUP10 1E3C 01 ADD 1E3D 61 PUSH2 0x1724 1E40 56 *JUMP label_1E41: // Incoming jump from 0x043B // Inputs[2] // { // @1E4A stack[-1] // @1E4B stack[-2] // } 1E41 5B JUMPDEST 1E42 60 PUSH1 0x00 1E44 80 DUP1 1E45 60 PUSH1 0x00 1E47 80 DUP1 1E48 60 PUSH1 0x80 1E4A 85 DUP6 1E4B 87 DUP8 1E4C 03 SUB 1E4D 12 SLT 1E4E 15 ISZERO 1E4F 61 PUSH2 0x1e5a 1E52 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1E42 stack[0] = 0x00 // @1E44 stack[1] = 0x00 // @1E45 stack[2] = 0x00 // @1E47 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1e5a, if !(stack[-2] - stack[-1] i< 0x80) label_1E53: // Incoming jump from 0x1E52, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1E59 memory[0x00:0x00] } 1E53 61 PUSH2 0x1e5a 1E56 60 PUSH1 0x00 1E58 80 DUP1 1E59 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1E53 stack[0] = 0x1e5a // @1E59 revert(memory[0x00:0x00]); // } // Block terminates label_1E5A: // Incoming jump from 0x1E52, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1E60 stack[-6] // @1E61 stack[-5] // } 1E5A 5B JUMPDEST 1E5B 60 PUSH1 0x00 1E5D 61 PUSH2 0x1e66 1E60 87 DUP8 1E61 87 DUP8 1E62 61 PUSH2 0x1724 1E65 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E5B stack[0] = 0x00 // @1E5D stack[1] = 0x1e66 // @1E60 stack[2] = stack[-6] // @1E61 stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1724 1E66 5B JUMPDEST 1E67 94 SWAP5 1E68 50 POP 1E69 50 POP 1E6A 60 PUSH1 0x20 1E6C 61 PUSH2 0x1e77 1E6F 87 DUP8 1E70 82 DUP3 1E71 88 DUP9 1E72 01 ADD 1E73 61 PUSH2 0x1724 1E76 56 *JUMP 1E77 5B JUMPDEST 1E78 93 SWAP4 1E79 50 POP 1E7A 50 POP 1E7B 60 PUSH1 0x40 1E7D 61 PUSH2 0x1e88 1E80 87 DUP8 1E81 82 DUP3 1E82 88 DUP9 1E83 01 ADD 1E84 61 PUSH2 0x1713 1E87 56 *JUMP 1E88 5B JUMPDEST 1E89 92 SWAP3 1E8A 50 POP 1E8B 50 POP 1E8C 60 PUSH1 0x60 1E8E 85 DUP6 1E8F 01 ADD 1E90 35 CALLDATALOAD 1E91 60 PUSH1 0x01 1E93 60 PUSH1 0x01 1E95 60 PUSH1 0x40 1E97 1B SHL 1E98 03 SUB 1E99 81 DUP2 1E9A 11 GT 1E9B 15 ISZERO 1E9C 61 PUSH2 0x1ea7 1E9F 57 *JUMPI 1EA0 61 PUSH2 0x1ea7 1EA3 60 PUSH1 0x00 1EA5 80 DUP1 1EA6 FD *REVERT 1EA7 5B JUMPDEST 1EA8 61 PUSH2 0x1eb3 1EAB 87 DUP8 1EAC 82 DUP3 1EAD 88 DUP9 1EAE 01 ADD 1EAF 61 PUSH2 0x1a21 1EB2 56 *JUMP 1EB3 5B JUMPDEST 1EB4 91 SWAP2 1EB5 50 POP 1EB6 50 POP 1EB7 92 SWAP3 1EB8 95 SWAP6 1EB9 91 SWAP2 1EBA 94 SWAP5 1EBB 50 POP 1EBC 92 SWAP3 1EBD 50 POP 1EBE 56 *JUMP 1EBF 5B JUMPDEST 1EC0 60 PUSH1 0x2b 1EC2 81 DUP2 1EC3 52 MSTORE 1EC4 60 PUSH1 0x00 1EC6 60 PUSH1 0x20 1EC8 82 DUP3 1EC9 01 ADD 1ECA 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 1EEB 81 DUP2 1EEC 52 MSTORE 1EED 6A PUSH11 0x65726f2061646472657373 1EF9 60 PUSH1 0xa8 1EFB 1B SHL 1EFC 60 PUSH1 0x20 1EFE 82 DUP3 1EFF 01 ADD 1F00 52 MSTORE 1F01 91 SWAP2 1F02 50 POP 1F03 5B JUMPDEST 1F04 50 POP 1F05 60 PUSH1 0x40 1F07 01 ADD 1F08 90 SWAP1 1F09 56 *JUMP 1F0A 5B JUMPDEST 1F0B 60 PUSH1 0x20 1F0D 80 DUP1 1F0E 82 DUP3 1F0F 52 MSTORE 1F10 81 DUP2 1F11 01 ADD 1F12 61 PUSH2 0x04aa 1F15 81 DUP2 1F16 61 PUSH2 0x1ebf 1F19 56 *JUMP label_1F1A: // Incoming jump from 0x1F56 // Inputs[1] { @1F2F memory[0x00:0x24] } 1F1A 5B JUMPDEST 1F1B 63 PUSH4 0x4e487b71 1F20 60 PUSH1 0xe0 1F22 1B SHL 1F23 60 PUSH1 0x00 1F25 52 MSTORE 1F26 60 PUSH1 0x22 1F28 60 PUSH1 0x04 1F2A 52 MSTORE 1F2B 60 PUSH1 0x24 1F2D 60 PUSH1 0x00 1F2F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1F25 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1F2A memory[0x04:0x24] = 0x22 // @1F2F revert(memory[0x00:0x24]); // } // Block terminates label_1F30: // Incoming call from 0x0A8F, returns to 0x0A90 // Incoming call from 0x04FC, returns to 0x04FD // Incoming call from 0x0528, returns to 0x0529 // Incoming call from 0x0A63, returns to 0x0A64 // Incoming call from 0x099C, returns to 0x04FD // Inputs[1] { @1F33 stack[-1] } 1F30 5B JUMPDEST 1F31 60 PUSH1 0x02 1F33 81 DUP2 1F34 04 DIV 1F35 60 PUSH1 0x01 1F37 82 DUP3 1F38 16 AND 1F39 80 DUP1 1F3A 61 PUSH2 0x1f44 1F3D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F34 stack[0] = stack[-1] / 0x02 // @1F38 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1f44, if stack[-1] & 0x01 label_1F3E: // Incoming jump from 0x1F3D, if not stack[-1] & 0x01 // Inputs[2] // { // @1F40 stack[-2] // @1F49 stack[-1] // } 1F3E 60 PUSH1 0x7f 1F40 82 DUP3 1F41 16 AND 1F42 91 SWAP2 1F43 50 POP 1F44 5B JUMPDEST 1F45 60 PUSH1 0x20 1F47 82 DUP3 1F48 10 LT 1F49 81 DUP2 1F4A 14 EQ 1F4B 15 ISZERO 1F4C 61 PUSH2 0x1f57 1F4F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1F42 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1f57, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1F50: // Incoming jump from 0x1F4F, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x1F4F, if not !(stack[-1] == (stack[-2] < 0x20)) 1F50 61 PUSH2 0x1f57 1F53 61 PUSH2 0x1f1a 1F56 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F50 stack[0] = 0x1f57 } // Block ends with unconditional jump to 0x1f1a label_1F57: // Incoming jump from 0x1F4F, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x1F4F, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @1F59 stack[-4] // @1F59 stack[-2] // @1F5A stack[-3] // } 1F57 5B JUMPDEST 1F58 50 POP 1F59 91 SWAP2 1F5A 90 SWAP1 1F5B 50 POP 1F5C 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F59 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] 1F5D 5B JUMPDEST 1F5E 63 PUSH4 0x4e487b71 1F63 60 PUSH1 0xe0 1F65 1B SHL 1F66 60 PUSH1 0x00 1F68 52 MSTORE 1F69 60 PUSH1 0x12 1F6B 60 PUSH1 0x04 1F6D 52 MSTORE 1F6E 60 PUSH1 0x24 1F70 60 PUSH1 0x00 1F72 FD *REVERT label_1F73: // Incoming jump from 0x1FB6 // Incoming jump from 0x2166 // Incoming jump from 0x217A // Inputs[1] { @1F88 memory[0x00:0x24] } 1F73 5B JUMPDEST 1F74 63 PUSH4 0x4e487b71 1F79 60 PUSH1 0xe0 1F7B 1B SHL 1F7C 60 PUSH1 0x00 1F7E 52 MSTORE 1F7F 60 PUSH1 0x11 1F81 60 PUSH1 0x04 1F83 52 MSTORE 1F84 60 PUSH1 0x24 1F86 60 PUSH1 0x00 1F88 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1F7E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1F83 memory[0x04:0x24] = 0x11 // @1F88 revert(memory[0x00:0x24]); // } // Block terminates 1F89 5B JUMPDEST 1F8A 60 PUSH1 0x00 1F8C 82 DUP3 1F8D 61 PUSH2 0x1f98 1F90 57 *JUMPI 1F91 61 PUSH2 0x1f98 1F94 61 PUSH2 0x1f5d 1F97 56 *JUMP 1F98 5B JUMPDEST 1F99 50 POP 1F9A 04 DIV 1F9B 90 SWAP1 1F9C 56 *JUMP label_1F9D: // Incoming call from 0x0B77, returns to 0x0B78 // Incoming call from 0x0C31, returns to 0x0C32 // Inputs[2] // { // @1FA0 stack[-1] // @1FA5 stack[-2] // } 1F9D 5B JUMPDEST 1F9E 60 PUSH1 0x00 1FA0 81 DUP2 1FA1 60 PUSH1 0x00 1FA3 19 NOT 1FA4 04 DIV 1FA5 83 DUP4 1FA6 11 GT 1FA7 82 DUP3 1FA8 15 ISZERO 1FA9 15 ISZERO 1FAA 16 AND 1FAB 15 ISZERO 1FAC 61 PUSH2 0x1fb7 1FAF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F9E stack[0] = 0x00 } // Block ends with conditional jump to 0x1fb7, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_1FB0: // Incoming jump from 0x1FAF, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 1FB0 61 PUSH2 0x1fb7 1FB3 61 PUSH2 0x1f73 1FB6 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FB0 stack[0] = 0x1fb7 } // Block ends with unconditional jump to 0x1f73 label_1FB7: // Incoming jump from 0x1FAF, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @1FB9 stack[-3] // @1FB9 stack[-2] // @1FBA stack[-4] // } 1FB7 5B JUMPDEST 1FB8 50 POP 1FB9 02 MUL 1FBA 90 SWAP1 1FBB 56 *JUMP // Stack delta = -3 // Outputs[1] { @1FBA stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] 1FBC 5B JUMPDEST 1FBD 60 PUSH1 0x32 1FBF 81 DUP2 1FC0 52 MSTORE 1FC1 60 PUSH1 0x00 1FC3 60 PUSH1 0x20 1FC5 82 DUP3 1FC6 01 ADD 1FC7 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 1FE8 81 DUP2 1FE9 52 MSTORE 1FEA 71 PUSH18 0x1bdddb995c881b9bdc88185c1c1c9bdd9959 1FFD 60 PUSH1 0x72 1FFF 1B SHL 2000 60 PUSH1 0x20 2002 82 DUP3 2003 01 ADD 2004 52 MSTORE 2005 91 SWAP2 2006 50 POP 2007 61 PUSH2 0x1f03 200A 56 *JUMP 200B 5B JUMPDEST 200C 60 PUSH1 0x20 200E 80 DUP1 200F 82 DUP3 2010 52 MSTORE 2011 81 DUP2 2012 01 ADD 2013 61 PUSH2 0x04aa 2016 81 DUP2 2017 61 PUSH2 0x1fbc 201A 56 *JUMP 201B 5B JUMPDEST 201C 60 PUSH1 0x2f 201E 81 DUP2 201F 52 MSTORE 2020 60 PUSH1 0x00 2022 60 PUSH1 0x20 2024 82 DUP3 2025 01 ADD 2026 7F PUSH32 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 2047 81 DUP2 2048 52 MSTORE 2049 6E PUSH15 0x103937b632b9903337b91039b2b633 2059 60 PUSH1 0x89 205B 1B SHL 205C 60 PUSH1 0x20 205E 82 DUP3 205F 01 ADD 2060 52 MSTORE 2061 91 SWAP2 2062 50 POP 2063 61 PUSH2 0x1f03 2066 56 *JUMP 2067 5B JUMPDEST 2068 60 PUSH1 0x20 206A 80 DUP1 206B 82 DUP3 206C 52 MSTORE 206D 81 DUP2 206E 01 ADD 206F 61 PUSH2 0x04aa 2072 81 DUP2 2073 61 PUSH2 0x201b 2076 56 *JUMP 2077 5B JUMPDEST 2078 60 PUSH1 0x29 207A 81 DUP2 207B 52 MSTORE 207C 60 PUSH1 0x00 207E 60 PUSH1 0x20 2080 82 DUP3 2081 01 ADD 2082 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 20A3 81 DUP2 20A4 52 MSTORE 20A5 68 PUSH9 0x040dad2e6dac2e8c6d 20AF 60 PUSH1 0xbb 20B1 1B SHL 20B2 60 PUSH1 0x20 20B4 82 DUP3 20B5 01 ADD 20B6 52 MSTORE 20B7 91 SWAP2 20B8 50 POP 20B9 61 PUSH2 0x1f03 20BC 56 *JUMP 20BD 5B JUMPDEST 20BE 60 PUSH1 0x20 20C0 80 DUP1 20C1 82 DUP3 20C2 52 MSTORE 20C3 81 DUP2 20C4 01 ADD 20C5 61 PUSH2 0x04aa 20C8 81 DUP2 20C9 61 PUSH2 0x2077 20CC 56 *JUMP label_20CD: // Incoming jump from 0x0C86 // Incoming jump from 0x0C0D // Incoming jump from 0x0C70 // Incoming jump from 0x0BDE // Inputs[1] { @20E2 memory[0x00:0x24] } 20CD 5B JUMPDEST 20CE 63 PUSH4 0x4e487b71 20D3 60 PUSH1 0xe0 20D5 1B SHL 20D6 60 PUSH1 0x00 20D8 52 MSTORE 20D9 60 PUSH1 0x32 20DB 60 PUSH1 0x04 20DD 52 MSTORE 20DE 60 PUSH1 0x24 20E0 60 PUSH1 0x00 20E2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @20D8 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @20DD memory[0x04:0x24] = 0x32 // @20E2 revert(memory[0x00:0x24]); // } // Block terminates 20E3 5B JUMPDEST 20E4 60 PUSH1 0x00 20E6 60 PUSH1 0x00 20E8 19 NOT 20E9 82 DUP3 20EA 14 EQ 20EB 15 ISZERO 20EC 61 PUSH2 0x20f7 20EF 57 *JUMPI 20F0 61 PUSH2 0x20f7 20F3 61 PUSH2 0x1f73 20F6 56 *JUMP 20F7 5B JUMPDEST 20F8 50 POP 20F9 60 PUSH1 0x01 20FB 01 ADD 20FC 90 SWAP1 20FD 56 *JUMP 20FE 5B JUMPDEST 20FF 60 PUSH1 0x29 2101 81 DUP2 2102 52 MSTORE 2103 60 PUSH1 0x00 2105 60 PUSH1 0x20 2107 82 DUP3 2108 01 ADD 2109 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 212A 81 DUP2 212B 52 MSTORE 212C 68 PUSH9 0x08185c1c1c9bdd9959 2136 60 PUSH1 0xba 2138 1B SHL 2139 60 PUSH1 0x20 213B 82 DUP3 213C 01 ADD 213D 52 MSTORE 213E 91 SWAP2 213F 50 POP 2140 61 PUSH2 0x1f03 2143 56 *JUMP 2144 5B JUMPDEST 2145 60 PUSH1 0x20 2147 80 DUP1 2148 82 DUP3 2149 52 MSTORE 214A 81 DUP2 214B 01 ADD 214C 61 PUSH2 0x04aa 214F 81 DUP2 2150 61 PUSH2 0x20fe 2153 56 *JUMP label_2154: // Incoming call from 0x0B82, returns to 0x0B83 // Incoming call from 0x0C3C, returns to 0x0C3D // Inputs[2] // { // @2157 stack[-2] // @2159 stack[-1] // } 2154 5B JUMPDEST 2155 60 PUSH1 0x00 2157 82 DUP3 2158 19 NOT 2159 82 DUP3 215A 11 GT 215B 15 ISZERO 215C 61 PUSH2 0x2167 215F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2155 stack[0] = 0x00 } // Block ends with conditional jump to 0x2167, if !(stack[-1] > ~stack[-2]) label_2160: // Incoming jump from 0x215F, if not !(stack[-1] > ~stack[-2]) 2160 61 PUSH2 0x2167 2163 61 PUSH2 0x1f73 2166 56 *JUMP // Stack delta = +1 // Outputs[1] { @2160 stack[0] = 0x2167 } // Block ends with unconditional jump to 0x1f73 label_2167: // Incoming jump from 0x215F, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2169 stack[-2] // @2169 stack[-3] // @216A stack[-4] // } 2167 5B JUMPDEST 2168 50 POP 2169 01 ADD 216A 90 SWAP1 216B 56 *JUMP // Stack delta = -3 // Outputs[1] { @216A stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_216C: // Incoming call from 0x0CAD, returns to 0x0CAE // Inputs[1] { @216F stack[-1] } 216C 5B JUMPDEST 216D 60 PUSH1 0x00 216F 81 DUP2 2170 61 PUSH2 0x217b 2173 57 *JUMPI // Stack delta = +1 // Outputs[1] { @216D stack[0] = 0x00 } // Block ends with conditional jump to 0x217b, if stack[-1] label_2174: // Incoming jump from 0x2173, if not stack[-1] 2174 61 PUSH2 0x217b 2177 61 PUSH2 0x1f73 217A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2174 stack[0] = 0x217b } // Block ends with unconditional jump to 0x1f73 label_217B: // Incoming jump from 0x2173, if stack[-1] // Inputs[2] // { // @2180 stack[-2] // @2181 stack[-3] // } 217B 5B JUMPDEST 217C 50 POP 217D 60 PUSH1 0x00 217F 19 NOT 2180 01 ADD 2181 90 SWAP1 2182 56 *JUMP // Stack delta = -2 // Outputs[1] { @2181 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2183: // Incoming call from 0x21C7, returns to 0x04AA // Inputs[2] // { // @2187 stack[-1] // @21B6 stack[-2] // } 2183 5B JUMPDEST 2184 60 PUSH1 0x20 2186 80 DUP1 2187 82 DUP3 2188 52 MSTORE 2189 7F PUSH32 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 21AA 91 SWAP2 21AB 01 ADD 21AC 90 SWAP1 21AD 81 DUP2 21AE 52 MSTORE 21AF 60 PUSH1 0x00 21B1 5B JUMPDEST 21B2 50 POP 21B3 60 PUSH1 0x20 21B5 01 ADD 21B6 90 SWAP1 21B7 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @2188 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @21AE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 // @21B6 stack[-2] = 0x20 + stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-2] label_21B8: // Incoming jump from 0x0CD3 // Inputs[1] { @21BC stack[-1] } 21B8 5B JUMPDEST 21B9 60 PUSH1 0x20 21BB 80 DUP1 21BC 82 DUP3 21BD 52 MSTORE 21BE 81 DUP2 21BF 01 ADD 21C0 61 PUSH2 0x04aa 21C3 81 DUP2 21C4 61 PUSH2 0x2183 21C7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @21BD memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @21BF stack[0] = stack[-1] + 0x20 // @21C0 stack[1] = 0x04aa // @21C3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2183, returns to 0x04AA 21C8 5B JUMPDEST 21C9 60 PUSH1 0x28 21CB 81 DUP2 21CC 52 MSTORE 21CD 60 PUSH1 0x00 21CF 60 PUSH1 0x20 21D1 82 DUP3 21D2 01 ADD 21D3 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 21F4 81 DUP2 21F5 52 MSTORE 21F6 67 PUSH8 0x0dad2e6dac2e8c6d 21FF 60 PUSH1 0xc3 2201 1B SHL 2202 60 PUSH1 0x20 2204 82 DUP3 2205 01 ADD 2206 52 MSTORE 2207 91 SWAP2 2208 50 POP 2209 61 PUSH2 0x1f03 220C 56 *JUMP 220D 5B JUMPDEST 220E 60 PUSH1 0x20 2210 80 DUP1 2211 82 DUP3 2212 52 MSTORE 2213 81 DUP2 2214 01 ADD 2215 61 PUSH2 0x04aa 2218 81 DUP2 2219 61 PUSH2 0x21c8 221C 56 *JUMP 221D 5B JUMPDEST 221E 60 PUSH1 0x25 2220 81 DUP2 2221 52 MSTORE 2222 60 PUSH1 0x00 2224 60 PUSH1 0x20 2226 82 DUP3 2227 01 ADD 2228 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 2249 81 DUP2 224A 52 MSTORE 224B 64 PUSH5 0x6472657373 2251 60 PUSH1 0xd8 2253 1B SHL 2254 60 PUSH1 0x20 2256 82 DUP3 2257 01 ADD 2258 52 MSTORE 2259 91 SWAP2 225A 50 POP 225B 61 PUSH2 0x1f03 225E 56 *JUMP 225F 5B JUMPDEST 2260 60 PUSH1 0x20 2262 80 DUP1 2263 82 DUP3 2264 52 MSTORE 2265 81 DUP2 2266 01 ADD 2267 61 PUSH2 0x04aa 226A 81 DUP2 226B 61 PUSH2 0x221d 226E 56 *JUMP 226F 5B JUMPDEST 2270 60 PUSH1 0x2a 2272 81 DUP2 2273 52 MSTORE 2274 60 PUSH1 0x00 2276 60 PUSH1 0x20 2278 82 DUP3 2279 01 ADD 227A 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 229B 81 DUP2 229C 52 MSTORE 229D 69 PUSH10 0x39103a3930b739b332b9 22A8 60 PUSH1 0xb1 22AA 1B SHL 22AB 60 PUSH1 0x20 22AD 82 DUP3 22AE 01 ADD 22AF 52 MSTORE 22B0 91 SWAP2 22B1 50 POP 22B2 61 PUSH2 0x1f03 22B5 56 *JUMP 22B6 5B JUMPDEST 22B7 60 PUSH1 0x20 22B9 80 DUP1 22BA 82 DUP3 22BB 52 MSTORE 22BC 81 DUP2 22BD 01 ADD 22BE 61 PUSH2 0x04aa 22C1 81 DUP2 22C2 61 PUSH2 0x226f 22C5 56 *JUMP 22C6 5B JUMPDEST 22C7 60 PUSH1 0x40 22C9 80 DUP1 22CA 82 DUP3 22CB 52 MSTORE 22CC 81 DUP2 22CD 01 ADD 22CE 61 PUSH2 0x22d7 22D1 81 DUP2 22D2 85 DUP6 22D3 61 PUSH2 0x1c9b 22D6 56 *JUMP 22D7 5B JUMPDEST 22D8 90 SWAP1 22D9 50 POP 22DA 81 DUP2 22DB 81 DUP2 22DC 03 SUB 22DD 60 PUSH1 0x20 22DF 83 DUP4 22E0 01 ADD 22E1 52 MSTORE 22E2 61 PUSH2 0x17be 22E5 81 DUP2 22E6 84 DUP5 22E7 61 PUSH2 0x1c9b 22EA 56 *JUMP 22EB 5B JUMPDEST 22EC 60 PUSH1 0x14 22EE 81 DUP2 22EF 52 MSTORE 22F0 60 PUSH1 0x00 22F2 60 PUSH1 0x20 22F4 82 DUP3 22F5 01 ADD 22F6 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 230B 60 PUSH1 0x62 230D 1B SHL 230E 81 DUP2 230F 52 MSTORE 2310 91 SWAP2 2311 50 POP 2312 61 PUSH2 0x21b1 2315 56 *JUMP 2316 5B JUMPDEST 2317 60 PUSH1 0x20 2319 80 DUP1 231A 82 DUP3 231B 52 MSTORE 231C 81 DUP2 231D 01 ADD 231E 61 PUSH2 0x04aa 2321 81 DUP2 2322 61 PUSH2 0x22eb 2325 56 *JUMP 2326 5B JUMPDEST 2327 60 PUSH1 0x20 2329 81 DUP2 232A 01 ADD 232B 61 PUSH2 0x04aa 232E 82 DUP3 232F 84 DUP5 2330 61 PUSH2 0x188e 2333 56 *JUMP 2334 5B JUMPDEST 2335 60 PUSH1 0x10 2337 81 DUP2 2338 52 MSTORE 2339 60 PUSH1 0x00 233B 60 PUSH1 0x20 233D 82 DUP3 233E 01 ADD 233F 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 2350 60 PUSH1 0x82 2352 1B SHL 2353 81 DUP2 2354 52 MSTORE 2355 91 SWAP2 2356 50 POP 2357 61 PUSH2 0x21b1 235A 56 *JUMP 235B 5B JUMPDEST 235C 60 PUSH1 0x20 235E 80 DUP1 235F 82 DUP3 2360 52 MSTORE 2361 81 DUP2 2362 01 ADD 2363 61 PUSH2 0x04aa 2366 81 DUP2 2367 61 PUSH2 0x2334 236A 56 *JUMP 236B 5B JUMPDEST 236C 60 PUSH1 0x29 236E 81 DUP2 236F 52 MSTORE 2370 60 PUSH1 0x00 2372 60 PUSH1 0x20 2374 82 DUP3 2375 01 ADD 2376 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 2397 81 DUP2 2398 52 MSTORE 2399 68 PUSH9 0x103337b91039b2b633 23A3 60 PUSH1 0xb9 23A5 1B SHL 23A6 60 PUSH1 0x20 23A8 82 DUP3 23A9 01 ADD 23AA 52 MSTORE 23AB 91 SWAP2 23AC 50 POP 23AD 61 PUSH2 0x1f03 23B0 56 *JUMP 23B1 5B JUMPDEST 23B2 60 PUSH1 0x20 23B4 80 DUP1 23B5 82 DUP3 23B6 52 MSTORE 23B7 81 DUP2 23B8 01 ADD 23B9 61 PUSH2 0x04aa 23BC 81 DUP2 23BD 61 PUSH2 0x236b 23C0 56 *JUMP 23C1 5B JUMPDEST 23C2 60 PUSH1 0x21 23C4 81 DUP2 23C5 52 MSTORE 23C6 60 PUSH1 0x00 23C8 60 PUSH1 0x20 23CA 82 DUP3 23CB 01 ADD 23CC 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 23ED 81 DUP2 23EE 52 MSTORE 23EF 60 PUSH1 0x73 23F1 60 PUSH1 0xf8 23F3 1B SHL 23F4 60 PUSH1 0x20 23F6 82 DUP3 23F7 01 ADD 23F8 52 MSTORE 23F9 91 SWAP2 23FA 50 POP 23FB 61 PUSH2 0x1f03 23FE 56 *JUMP 23FF 5B JUMPDEST 2400 60 PUSH1 0x20 2402 80 DUP1 2403 82 DUP3 2404 52 MSTORE 2405 81 DUP2 2406 01 ADD 2407 61 PUSH2 0x04aa 240A 81 DUP2 240B 61 PUSH2 0x23c1 240E 56 *JUMP 240F 5B JUMPDEST 2410 60 PUSH1 0x40 2412 81 DUP2 2413 01 ADD 2414 61 PUSH2 0x18a5 2417 82 DUP3 2418 85 DUP6 2419 61 PUSH2 0x176c 241C 56 *JUMP 241D 5B JUMPDEST 241E 60 PUSH1 0xa0 2420 81 DUP2 2421 01 ADD 2422 61 PUSH2 0x242b 2425 82 DUP3 2426 88 DUP9 2427 61 PUSH2 0x188e 242A 56 *JUMP 242B 5B JUMPDEST 242C 61 PUSH2 0x2438 242F 60 PUSH1 0x20 2431 83 DUP4 2432 01 ADD 2433 87 DUP8 2434 61 PUSH2 0x188e 2437 56 *JUMP 2438 5B JUMPDEST 2439 81 DUP2 243A 81 DUP2 243B 03 SUB 243C 60 PUSH1 0x40 243E 83 DUP4 243F 01 ADD 2440 52 MSTORE 2441 61 PUSH2 0x244a 2444 81 DUP2 2445 86 DUP7 2446 61 PUSH2 0x1c9b 2449 56 *JUMP 244A 5B JUMPDEST 244B 90 SWAP1 244C 50 POP 244D 81 DUP2 244E 81 DUP2 244F 03 SUB 2450 60 PUSH1 0x60 2452 83 DUP4 2453 01 ADD 2454 52 MSTORE 2455 61 PUSH2 0x245e 2458 81 DUP2 2459 85 DUP6 245A 61 PUSH2 0x1c9b 245D 56 *JUMP 245E 5B JUMPDEST 245F 90 SWAP1 2460 50 POP 2461 81 DUP2 2462 81 DUP2 2463 03 SUB 2464 60 PUSH1 0x80 2466 83 DUP4 2467 01 ADD 2468 52 MSTORE 2469 61 PUSH2 0x2472 246C 81 DUP2 246D 84 DUP5 246E 61 PUSH2 0x1808 2471 56 *JUMP 2472 5B JUMPDEST 2473 97 SWAP8 2474 96 SWAP7 2475 50 POP 2476 50 POP 2477 50 POP 2478 50 POP 2479 50 POP 247A 50 POP 247B 50 POP 247C 56 *JUMP 247D 5B JUMPDEST 247E 80 DUP1 247F 51 MLOAD 2480 61 PUSH2 0x04aa 2483 81 DUP2 2484 61 PUSH2 0x1782 2487 56 *JUMP 2488 5B JUMPDEST 2489 60 PUSH1 0x00 248B 60 PUSH1 0x20 248D 82 DUP3 248E 84 DUP5 248F 03 SUB 2490 12 SLT 2491 15 ISZERO 2492 61 PUSH2 0x249d 2495 57 *JUMPI 2496 61 PUSH2 0x249d 2499 60 PUSH1 0x00 249B 80 DUP1 249C FD *REVERT 249D 5B JUMPDEST 249E 60 PUSH1 0x00 24A0 61 PUSH2 0x17be 24A3 84 DUP5 24A4 84 DUP5 24A5 61 PUSH2 0x247d 24A8 56 *JUMP 24A9 5B JUMPDEST 24AA 60 PUSH1 0x00 24AC 60 PUSH1 0x03 24AE 3D RETURNDATASIZE 24AF 11 GT 24B0 15 ISZERO 24B1 61 PUSH2 0x24c2 24B4 57 *JUMPI 24B5 60 PUSH1 0x04 24B7 60 PUSH1 0x00 24B9 80 DUP1 24BA 3E RETURNDATACOPY 24BB 50 POP 24BC 60 PUSH1 0x00 24BE 51 MLOAD 24BF 60 PUSH1 0xe0 24C1 1C SHR 24C2 5B JUMPDEST 24C3 90 SWAP1 24C4 56 *JUMP 24C5 5B JUMPDEST 24C6 60 PUSH1 0x00 24C8 60 PUSH1 0x44 24CA 3D RETURNDATASIZE 24CB 10 LT 24CC 15 ISZERO 24CD 61 PUSH2 0x24d3 24D0 57 *JUMPI 24D1 90 SWAP1 24D2 56 *JUMP 24D3 5B JUMPDEST 24D4 60 PUSH1 0x40 24D6 51 MLOAD 24D7 60 PUSH1 0x04 24D9 3D RETURNDATASIZE 24DA 03 SUB 24DB 60 PUSH1 0x04 24DD 82 DUP3 24DE 3E RETURNDATACOPY 24DF 80 DUP1 24E0 51 MLOAD 24E1 3D RETURNDATASIZE 24E2 60 PUSH1 0x24 24E4 82 DUP3 24E5 01 ADD 24E6 11 GT 24E7 60 PUSH1 0x01 24E9 60 PUSH1 0x01 24EB 60 PUSH1 0x40 24ED 1B SHL 24EE 03 SUB 24EF 82 DUP3 24F0 11 GT 24F1 17 OR 24F2 15 ISZERO 24F3 61 PUSH2 0x24fb 24F6 57 *JUMPI 24F7 50 POP 24F8 50 POP 24F9 90 SWAP1 24FA 56 *JUMP 24FB 5B JUMPDEST 24FC 80 DUP1 24FD 82 DUP3 24FE 01 ADD 24FF 80 DUP1 2500 51 MLOAD 2501 60 PUSH1 0x01 2503 60 PUSH1 0x01 2505 60 PUSH1 0x40 2507 1B SHL 2508 03 SUB 2509 81 DUP2 250A 11 GT 250B 15 ISZERO 250C 61 PUSH2 0x2516 250F 57 *JUMPI 2510 50 POP 2511 50 POP 2512 50 POP 2513 50 POP 2514 90 SWAP1 2515 56 *JUMP 2516 5B JUMPDEST 2517 80 DUP1 2518 60 PUSH1 0x20 251A 83 DUP4 251B 01 ADD 251C 01 ADD 251D 60 PUSH1 0x04 251F 3D RETURNDATASIZE 2520 03 SUB 2521 85 DUP6 2522 01 ADD 2523 81 DUP2 2524 11 GT 2525 15 ISZERO 2526 61 PUSH2 0x2531 2529 57 *JUMPI 252A 50 POP 252B 50 POP 252C 50 POP 252D 50 POP 252E 50 POP 252F 90 SWAP1 2530 56 *JUMP 2531 5B JUMPDEST 2532 61 PUSH2 0x2540 2535 82 DUP3 2536 60 PUSH1 0x20 2538 01 ADD 2539 85 DUP6 253A 01 ADD 253B 86 DUP7 253C 61 PUSH2 0x18c8 253F 56 *JUMP 2540 5B JUMPDEST 2541 50 POP 2542 90 SWAP1 2543 94 SWAP5 2544 93 SWAP4 2545 50 POP 2546 50 POP 2547 50 POP 2548 50 POP 2549 56 *JUMP 254A 5B JUMPDEST 254B 60 PUSH1 0x34 254D 81 DUP2 254E 52 MSTORE 254F 60 PUSH1 0x00 2551 60 PUSH1 0x20 2553 82 DUP3 2554 01 ADD 2555 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 2576 81 DUP2 2577 52 MSTORE 2578 73 PUSH20 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 258D 60 PUSH1 0x61 258F 1B SHL 2590 60 PUSH1 0x20 2592 82 DUP3 2593 01 ADD 2594 52 MSTORE 2595 91 SWAP2 2596 50 POP 2597 61 PUSH2 0x1f03 259A 56 *JUMP 259B 5B JUMPDEST 259C 60 PUSH1 0x20 259E 80 DUP1 259F 82 DUP3 25A0 52 MSTORE 25A1 81 DUP2 25A2 01 ADD 25A3 61 PUSH2 0x04aa 25A6 81 DUP2 25A7 61 PUSH2 0x254a 25AA 56 *JUMP 25AB 5B JUMPDEST 25AC 60 PUSH1 0x28 25AE 81 DUP2 25AF 52 MSTORE 25B0 60 PUSH1 0x00 25B2 60 PUSH1 0x20 25B4 82 DUP3 25B5 01 ADD 25B6 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 25D7 81 DUP2 25D8 52 MSTORE 25D9 67 PUSH8 0x6420746f6b656e73 25E2 60 PUSH1 0xc0 25E4 1B SHL 25E5 60 PUSH1 0x20 25E7 82 DUP3 25E8 01 ADD 25E9 52 MSTORE 25EA 91 SWAP2 25EB 50 POP 25EC 61 PUSH2 0x1f03 25EF 56 *JUMP 25F0 5B JUMPDEST 25F1 60 PUSH1 0x20 25F3 80 DUP1 25F4 82 DUP3 25F5 52 MSTORE 25F6 81 DUP2 25F7 01 ADD 25F8 61 PUSH2 0x04aa 25FB 81 DUP2 25FC 61 PUSH2 0x25ab 25FF 56 *JUMP label_2600: // Incoming call from 0x2653, returns to 0x2654 // Incoming call from 0x2679, returns to 0x17BE // Inputs[2] // { // @2606 stack[-1] // @2607 memory[stack[-1]:stack[-1] + 0x20] // } 2600 5B JUMPDEST 2601 60 PUSH1 0x00 2603 61 PUSH2 0x260a 2606 82 DUP3 2607 51 MLOAD 2608 90 SWAP1 2609 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2601 stack[0] = 0x00 // @2608 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x260a label_260A: // Incoming jump from 0x2609 // Inputs[3] // { // @260E stack[-1] // @260F stack[-4] // @2612 stack[-3] // } 260A 5B JUMPDEST 260B 61 PUSH2 0x2618 260E 81 DUP2 260F 85 DUP6 2610 60 PUSH1 0x20 2612 86 DUP7 2613 01 ADD 2614 61 PUSH2 0x17dc 2617 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @260B stack[0] = 0x2618 // @260E stack[1] = stack[-1] // @260F stack[2] = stack[-4] // @2613 stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x17dc, returns to 0x2618 label_2618: // Incoming return from call to 0x17DC at 0x2617 // Inputs[4] // { // @2619 stack[-1] // @2619 stack[-4] // @261A stack[-2] // @261D stack[-5] // } 2618 5B JUMPDEST 2619 92 SWAP3 261A 90 SWAP1 261B 92 SWAP3 261C 01 ADD 261D 92 SWAP3 261E 91 SWAP2 261F 50 POP 2620 50 POP 2621 56 *JUMP // Stack delta = -4 // Outputs[1] { @261D stack[-5] = stack[-1] + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2622: // Incoming jump from 0x14F6 // Inputs[2] // { // @2644 stack[-1] // @264F stack[-3] // } 2622 5B JUMPDEST 2623 7F PUSH32 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 2644 81 DUP2 2645 52 MSTORE 2646 60 PUSH1 0x17 2648 01 ADD 2649 60 PUSH1 0x00 264B 61 PUSH2 0x2654 264E 82 DUP3 264F 85 DUP6 2650 61 PUSH2 0x2600 2653 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @2645 memory[stack[-1]:stack[-1] + 0x20] = 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 // @2648 stack[-1] = 0x17 + stack[-1] // @2649 stack[0] = 0x00 // @264B stack[1] = 0x2654 // @264E stack[2] = 0x17 + stack[-1] // @264F stack[3] = stack[-3] // } // Block ends with call to 0x2600, returns to 0x2654 label_2654: // Incoming return from call to 0x2600 at 0x2653 // Inputs[3] // { // @266A stack[-1] // @266F stack[-3] // @2675 stack[-4] // } 2654 5B JUMPDEST 2655 70 PUSH17 0x01034b99036b4b9b9b4b733903937b6329 2667 60 PUSH1 0x7d 2669 1B SHL 266A 81 DUP2 266B 52 MSTORE 266C 60 PUSH1 0x11 266E 01 ADD 266F 91 SWAP2 2670 50 POP 2671 61 PUSH2 0x17be 2674 82 DUP3 2675 84 DUP5 2676 61 PUSH2 0x2600 2679 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @266B memory[stack[-1]:stack[-1] + 0x20] = 0x01034b99036b4b9b9b4b733903937b6329 << 0x7d // @266F stack[-3] = 0x11 + stack[-1] // @2671 stack[-1] = 0x17be // @2674 stack[0] = 0x11 + stack[-1] // @2675 stack[1] = stack[-4] // } // Block ends with call to 0x2600, returns to 0x17BE 267A 5B JUMPDEST 267B 60 PUSH1 0xa0 267D 81 DUP2 267E 01 ADD 267F 61 PUSH2 0x2688 2682 82 DUP3 2683 88 DUP9 2684 61 PUSH2 0x188e 2687 56 *JUMP 2688 5B JUMPDEST 2689 61 PUSH2 0x2695 268C 60 PUSH1 0x20 268E 83 DUP4 268F 01 ADD 2690 87 DUP8 2691 61 PUSH2 0x188e 2694 56 *JUMP 2695 5B JUMPDEST 2696 61 PUSH2 0x26a2 2699 60 PUSH1 0x40 269B 83 DUP4 269C 01 ADD 269D 86 DUP7 269E 61 PUSH2 0x176c 26A1 56 *JUMP 26A2 5B JUMPDEST 26A3 61 PUSH2 0x26af 26A6 60 PUSH1 0x60 26A8 83 DUP4 26A9 01 ADD 26AA 85 DUP6 26AB 61 PUSH2 0x176c 26AE 56 *JUMP 26AF 5B JUMPDEST 26B0 81 DUP2 26B1 81 DUP2 26B2 03 SUB 26B3 60 PUSH1 0x80 26B5 83 DUP4 26B6 01 ADD 26B7 52 MSTORE 26B8 61 PUSH2 0x2472 26BB 81 DUP2 26BC 84 DUP5 26BD 61 PUSH2 0x1808 26C0 56 *JUMP 26C1 5B JUMPDEST 26C2 60 PUSH1 0x2c 26C4 81 DUP2 26C5 52 MSTORE 26C6 60 PUSH1 0x00 26C8 60 PUSH1 0x20 26CA 82 DUP3 26CB 01 ADD 26CC 7F PUSH32 0x455243313135355061757361626c653a20746f6b656e207472616e7366657220 26ED 81 DUP2 26EE 52 MSTORE 26EF 6B PUSH12 0x1dda1a5b19481c185d5cd959 26FC 60 PUSH1 0xa2 26FE 1B SHL 26FF 60 PUSH1 0x20 2701 82 DUP3 2702 01 ADD 2703 52 MSTORE 2704 91 SWAP2 2705 50 POP 2706 61 PUSH2 0x1f03 2709 56 *JUMP 270A 5B JUMPDEST 270B 60 PUSH1 0x20 270D 80 DUP1 270E 82 DUP3 270F 52 MSTORE 2710 81 DUP2 2711 01 ADD 2712 61 PUSH2 0x04aa 2715 81 DUP2 2716 61 PUSH2 0x26c1 2719 56 *JUMP 271A FE *ASSERT 271B F0 CREATE 271C 88 DUP9 271D 7B PUSH28 0xa65ee2024ea881d91b74c2450ef19e1557f03bed3ea9f16b037cbe2d 273A C9 C9 273B A2 LOG2 273C 64 PUSH5 0x6970667358 2742 22 22 2743 12 SLT 2744 20 SHA3 2745 45 GASLIMIT 2746 DC DC 2747 0A EXP 2748 DE DE 2749 3D RETURNDATASIZE 274A 80 DUP1 274B 17 OR 274C DB DB 274D D0 D0 274E 97 SWAP8 274F F3 *RETURN 2750 ED ED 2751 1D SAR 2752 27 27 2753 C5 C5 2754 B2 SWAP 2755 9B SWAP12 2756 F4 DELEGATECALL 2757 81 DUP2 2758 22 22 2759 B1 DUP 275A 66 PUSH7 0x9aaa8a2a4ab7e5 2762 10 LT 2763 9C SWAP13 2764 82 DUP3 2765 64 PUSH5 0x736f6c6343 276B 00 *STOP 276C 08 ADDMOD 276D 09 MULMOD 276E 00 *STOP 276F 33 CALLER