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 0x01fb 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01fb, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x715018a6 0026 11 GT 0027 61 PUSH2 0x011a 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x011a, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xb88d4fde 0031 11 GT 0032 61 PUSH2 0x00ad 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ad, if 0xb88d4fde > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe5c8b03d 003C 11 GT 003D 61 PUSH2 0x007c 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xe5c8b03d > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe5c8b03d > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe5c8b03d 0047 14 EQ 0048 61 PUSH2 0x042e 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042e, if 0xe5c8b03d == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe5c8b03d == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe8a3d485 0052 14 EQ 0053 61 PUSH2 0x0436 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0436, if 0xe8a3d485 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe985e9c5 005D 14 EQ 005E 61 PUSH2 0x043e 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043e, if 0xe985e9c5 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xeb12d61e 0068 14 EQ 0069 61 PUSH2 0x0451 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0451, if 0xeb12d61e == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xeb12d61e == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xf2fde38b 0073 14 EQ 0074 61 PUSH2 0x0464 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0464, if 0xf2fde38b == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xf2fde38b == stack[-1] 0078 61 PUSH2 0x01fb 007B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01fb label_007C: // Incoming jump from 0x0040, if 0xe5c8b03d > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0xb88d4fde 0083 14 EQ 0084 61 PUSH2 0x03e0 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e0, if 0xb88d4fde == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xb9c4d9fb 008E 14 EQ 008F 61 PUSH2 0x03f3 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f3, if 0xb9c4d9fb == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xb9c4d9fb == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xc0ac9983 0099 14 EQ 009A 61 PUSH2 0x0413 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0413, if 0xc0ac9983 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xc0ac9983 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xc87b56dd 00A4 14 EQ 00A5 61 PUSH2 0x041b 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041b, if 0xc87b56dd == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0xc87b56dd == stack[-1] 00A9 61 PUSH2 0x01fb 00AC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01fb label_00AD: // Incoming jump from 0x0035, if 0xb88d4fde > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AD 5B JUMPDEST 00AE 80 DUP1 00AF 63 PUSH4 0x938e3d7b 00B4 11 GT 00B5 61 PUSH2 0x00e9 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e9, if 0x938e3d7b > stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x938e3d7b > stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x938e3d7b 00BF 14 EQ 00C0 61 PUSH2 0x039f 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039f, if 0x938e3d7b == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x938e3d7b == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x95d89b41 00CA 14 EQ 00CB 61 PUSH2 0x03b2 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b2, if 0x95d89b41 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x99e0dd7c 00D5 14 EQ 00D6 61 PUSH2 0x03ba 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ba, if 0x99e0dd7c == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x99e0dd7c == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0xa22cb465 00E0 14 EQ 00E1 61 PUSH2 0x03cd 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cd, if 0xa22cb465 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0xa22cb465 == stack[-1] 00E5 61 PUSH2 0x01fb 00E8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01fb label_00E9: // Incoming jump from 0x00B8, if 0x938e3d7b > stack[-1] // Inputs[1] { @00EA stack[-1] } 00E9 5B JUMPDEST 00EA 80 DUP1 00EB 63 PUSH4 0x715018a6 00F0 14 EQ 00F1 61 PUSH2 0x0374 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0374, if 0x715018a6 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x715018a6 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x7df73e27 00FB 14 EQ 00FC 61 PUSH2 0x037c 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037c, if 0x7df73e27 == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x7df73e27 == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0x8da5cb5b 0106 14 EQ 0107 61 PUSH2 0x038f 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038f, if 0x8da5cb5b == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x8f32d59b 0111 14 EQ 0112 61 PUSH2 0x0397 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0397, if 0x8f32d59b == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x8f32d59b == stack[-1] 0116 61 PUSH2 0x01fb 0119 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01fb label_011A: // Incoming jump from 0x002A, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @011B stack[-1] } 011A 5B JUMPDEST 011B 80 DUP1 011C 63 PUSH4 0x2f745c59 0121 11 GT 0122 61 PUSH2 0x0192 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0192, if 0x2f745c59 > stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x2f745c59 > stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x6308f1cd 012C 11 GT 012D 61 PUSH2 0x0161 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0161, if 0x6308f1cd > stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x6308f1cd > stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x6308f1cd 0137 14 EQ 0138 61 PUSH2 0x031a 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031a, if 0x6308f1cd == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x6308f1cd == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x6352211e 0142 14 EQ 0143 61 PUSH2 0x033b 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033b, if 0x6352211e == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x6352211e == stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x672a9400 014D 14 EQ 014E 61 PUSH2 0x034e 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034e, if 0x672a9400 == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x672a9400 == stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0x70a08231 0158 14 EQ 0159 61 PUSH2 0x0361 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0361, if 0x70a08231 == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0x70a08231 == stack[-1] 015D 61 PUSH2 0x01fb 0160 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01fb label_0161: // Incoming jump from 0x0130, if 0x6308f1cd > stack[-1] // Inputs[1] { @0162 stack[-1] } 0161 5B JUMPDEST 0162 80 DUP1 0163 63 PUSH4 0x2f745c59 0168 14 EQ 0169 61 PUSH2 0x02ce 016C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ce, if 0x2f745c59 == stack[-1] label_016D: // Incoming jump from 0x016C, if not 0x2f745c59 == stack[-1] // Inputs[1] { @016D stack[-1] } 016D 80 DUP1 016E 63 PUSH4 0x42842e0e 0173 14 EQ 0174 61 PUSH2 0x02e1 0177 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e1, if 0x42842e0e == stack[-1] label_0178: // Incoming jump from 0x0177, if not 0x42842e0e == stack[-1] // Inputs[1] { @0178 stack[-1] } 0178 80 DUP1 0179 63 PUSH4 0x42966c68 017E 14 EQ 017F 61 PUSH2 0x02f4 0182 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f4, if 0x42966c68 == stack[-1] label_0183: // Incoming jump from 0x0182, if not 0x42966c68 == stack[-1] // Inputs[1] { @0183 stack[-1] } 0183 80 DUP1 0184 63 PUSH4 0x4f6ccce7 0189 14 EQ 018A 61 PUSH2 0x0307 018D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0307, if 0x4f6ccce7 == stack[-1] label_018E: // Incoming jump from 0x018D, if not 0x4f6ccce7 == stack[-1] 018E 61 PUSH2 0x01fb 0191 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01fb label_0192: // Incoming jump from 0x0125, if 0x2f745c59 > stack[-1] // Inputs[1] { @0193 stack[-1] } 0192 5B JUMPDEST 0193 80 DUP1 0194 63 PUSH4 0x0e316ab7 0199 11 GT 019A 61 PUSH2 0x01ce 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ce, if 0x0e316ab7 > stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x0e316ab7 > stack[-1] // Inputs[1] { @019E stack[-1] } 019E 80 DUP1 019F 63 PUSH4 0x0e316ab7 01A4 14 EQ 01A5 61 PUSH2 0x0273 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0273, if 0x0e316ab7 == stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x0e316ab7 == stack[-1] // Inputs[1] { @01A9 stack[-1] } 01A9 80 DUP1 01AA 63 PUSH4 0x0ebd4c7f 01AF 14 EQ 01B0 61 PUSH2 0x0286 01B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0286, if 0x0ebd4c7f == stack[-1] label_01B4: // Incoming jump from 0x01B3, if not 0x0ebd4c7f == stack[-1] // Inputs[1] { @01B4 stack[-1] } 01B4 80 DUP1 01B5 63 PUSH4 0x18160ddd 01BA 14 EQ 01BB 61 PUSH2 0x02a6 01BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a6, if 0x18160ddd == stack[-1] label_01BF: // Incoming jump from 0x01BE, if not 0x18160ddd == stack[-1] // Inputs[1] { @01BF stack[-1] } 01BF 80 DUP1 01C0 63 PUSH4 0x23b872dd 01C5 14 EQ 01C6 61 PUSH2 0x02bb 01C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bb, if 0x23b872dd == stack[-1] label_01CA: // Incoming jump from 0x01C9, if not 0x23b872dd == stack[-1] 01CA 61 PUSH2 0x01fb 01CD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01fb label_01CE: // Incoming jump from 0x019D, if 0x0e316ab7 > stack[-1] // Inputs[1] { @01CF stack[-1] } 01CE 5B JUMPDEST 01CF 80 DUP1 01D0 63 PUSH4 0x01ffc9a7 01D5 14 EQ 01D6 61 PUSH2 0x0200 01D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0200, if 0x01ffc9a7 == stack[-1] label_01DA: // Incoming jump from 0x01D9, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01DA stack[-1] } 01DA 80 DUP1 01DB 63 PUSH4 0x06fdde03 01E0 14 EQ 01E1 61 PUSH2 0x0229 01E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0229, if 0x06fdde03 == stack[-1] label_01E5: // Incoming jump from 0x01E4, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01E5 stack[-1] } 01E5 80 DUP1 01E6 63 PUSH4 0x081812fc 01EB 14 EQ 01EC 61 PUSH2 0x023e 01EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023e, if 0x081812fc == stack[-1] label_01F0: // Incoming jump from 0x01EF, if not 0x081812fc == stack[-1] // Inputs[1] { @01F0 stack[-1] } 01F0 80 DUP1 01F1 63 PUSH4 0x095ea7b3 01F6 14 EQ 01F7 61 PUSH2 0x025e 01FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025e, if 0x095ea7b3 == stack[-1] label_01FB: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x007B // Incoming jump from 0x01FA, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x0119 // Incoming jump from 0x0160 // Incoming jump from 0x00E8 // Incoming jump from 0x00AC // Incoming jump from 0x01CD // Incoming jump from 0x0191 // Inputs[1] { @01FF memory[0x00:0x00] } 01FB 5B JUMPDEST 01FC 60 PUSH1 0x00 01FE 80 DUP1 01FF FD *REVERT // Stack delta = +0 // Outputs[1] { @01FF revert(memory[0x00:0x00]); } // Block terminates label_0200: // Incoming jump from 0x01D9, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0207 msg.data.length } 0200 5B JUMPDEST 0201 61 PUSH2 0x0213 0204 61 PUSH2 0x020e 0207 36 CALLDATASIZE 0208 60 PUSH1 0x04 020A 61 PUSH2 0x2243 020D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0201 stack[0] = 0x0213 // @0204 stack[1] = 0x020e // @0207 stack[2] = msg.data.length // @0208 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2243 020E 5B JUMPDEST 020F 61 PUSH2 0x0477 0212 56 *JUMP label_0213: // Incoming return from call to 0x0ADC at 0x039E // Inputs[2] // { // @0216 memory[0x40:0x60] // @021A stack[-1] // } 0213 5B JUMPDEST 0214 60 PUSH1 0x40 0216 51 MLOAD 0217 61 PUSH2 0x0220 021A 91 SWAP2 021B 90 SWAP1 021C 61 PUSH2 0x2da8 021F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @021A stack[-1] = 0x0220 // @021B stack[1] = memory[0x40:0x60] // @021B stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2da8 label_0220: // Incoming return from call to 0x2DF4 at 0x023D // Inputs[3] // { // @0223 memory[0x40:0x60] // @0225 stack[-1] // @0228 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0220 5B JUMPDEST 0221 60 PUSH1 0x40 0223 51 MLOAD 0224 80 DUP1 0225 91 SWAP2 0226 03 SUB 0227 90 SWAP1 0228 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0228 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0229: // Incoming jump from 0x01E4, if 0x06fdde03 == stack[-1] 0229 5B JUMPDEST 022A 61 PUSH2 0x0231 022D 61 PUSH2 0x0496 0230 56 *JUMP // Stack delta = +1 // Outputs[1] { @022A stack[0] = 0x0231 } // Block ends with call to 0x0496, returns to 0x0231 label_0231: // Incoming return from call to 0x0E57 at 0x043D // Incoming return from call to 0x0B2D at 0x03B9 // Incoming return from call to 0x0DBA at 0x041A // Incoming return from call to 0x0496 at 0x0230 // Inputs[2] // { // @0234 memory[0x40:0x60] // @0238 stack[-1] // } 0231 5B JUMPDEST 0232 60 PUSH1 0x40 0234 51 MLOAD 0235 61 PUSH2 0x0220 0238 91 SWAP2 0239 90 SWAP1 023A 61 PUSH2 0x2df4 023D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0238 stack[-1] = 0x0220 // @0239 stack[1] = memory[0x40:0x60] // @0239 stack[0] = stack[-1] // } // Block ends with call to 0x2df4, returns to 0x0220 label_023E: // Incoming jump from 0x01EF, if 0x081812fc == stack[-1] // Inputs[1] { @0245 msg.data.length } 023E 5B JUMPDEST 023F 61 PUSH2 0x0251 0242 61 PUSH2 0x024c 0245 36 CALLDATASIZE 0246 60 PUSH1 0x04 0248 61 PUSH2 0x22b4 024B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023F stack[0] = 0x0251 // @0242 stack[1] = 0x024c // @0245 stack[2] = msg.data.length // @0246 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22b4 024C 5B JUMPDEST 024D 61 PUSH2 0x0524 0250 56 *JUMP label_0251: // Incoming return from call to 0x0ACD at 0x0396 // Inputs[2] // { // @0254 memory[0x40:0x60] // @0258 stack[-1] // } 0251 5B JUMPDEST 0252 60 PUSH1 0x40 0254 51 MLOAD 0255 61 PUSH2 0x0220 0258 91 SWAP2 0259 90 SWAP1 025A 61 PUSH2 0x2d19 025D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0258 stack[-1] = 0x0220 // @0259 stack[1] = memory[0x40:0x60] // @0259 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2d19 label_025E: // Incoming jump from 0x01FA, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0265 msg.data.length } 025E 5B JUMPDEST 025F 61 PUSH2 0x0271 0262 61 PUSH2 0x026c 0265 36 CALLDATASIZE 0266 60 PUSH1 0x04 0268 61 PUSH2 0x2213 026B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @025F stack[0] = 0x0271 // @0262 stack[1] = 0x026c // @0265 stack[2] = msg.data.length // @0266 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2213 026C 5B JUMPDEST 026D 61 PUSH2 0x0570 0270 56 *JUMP label_0271: // Incoming return from call to 0x0A4C at 0x037B // Incoming return from call to 0x0E45 at 0x0435 0271 5B JUMPDEST 0272 00 *STOP // Stack delta = +0 // Outputs[1] { @0272 stop(); } // Block terminates label_0273: // Incoming jump from 0x01A8, if 0x0e316ab7 == stack[-1] // Inputs[1] { @027A msg.data.length } 0273 5B JUMPDEST 0274 61 PUSH2 0x0271 0277 61 PUSH2 0x0281 027A 36 CALLDATASIZE 027B 60 PUSH1 0x04 027D 61 PUSH2 0x20c5 0280 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0274 stack[0] = 0x0271 // @0277 stack[1] = 0x0281 // @027A stack[2] = msg.data.length // @027B stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20c5 0281 5B JUMPDEST 0282 61 PUSH2 0x0655 0285 56 *JUMP label_0286: // Incoming jump from 0x01B3, if 0x0ebd4c7f == stack[-1] // Inputs[1] { @028D msg.data.length } 0286 5B JUMPDEST 0287 61 PUSH2 0x0299 028A 61 PUSH2 0x0294 028D 36 CALLDATASIZE 028E 60 PUSH1 0x04 0290 61 PUSH2 0x22b4 0293 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0287 stack[0] = 0x0299 // @028A stack[1] = 0x0294 // @028D stack[2] = msg.data.length // @028E stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22b4 0294 5B JUMPDEST 0295 61 PUSH2 0x0685 0298 56 *JUMP 0299 5B JUMPDEST 029A 60 PUSH1 0x40 029C 51 MLOAD 029D 61 PUSH2 0x0220 02A0 91 SWAP2 02A1 90 SWAP1 02A2 61 PUSH2 0x2d97 02A5 56 *JUMP label_02A6: // Incoming jump from 0x01BE, if 0x18160ddd == stack[-1] 02A6 5B JUMPDEST 02A7 61 PUSH2 0x02ae 02AA 61 PUSH2 0x0778 02AD 56 *JUMP // Stack delta = +1 // Outputs[1] { @02A7 stack[0] = 0x02ae } // Block ends with call to 0x0778, returns to 0x02AE label_02AE: // Incoming return from call to 0x0778 at 0x02AD // Inputs[2] // { // @02B1 memory[0x40:0x60] // @02B5 stack[-1] // } 02AE 5B JUMPDEST 02AF 60 PUSH1 0x40 02B1 51 MLOAD 02B2 61 PUSH2 0x0220 02B5 91 SWAP2 02B6 90 SWAP1 02B7 61 PUSH2 0x2fb5 02BA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02B5 stack[-1] = 0x0220 // @02B6 stack[1] = memory[0x40:0x60] // @02B6 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2fb5 label_02BB: // Incoming jump from 0x01C9, if 0x23b872dd == stack[-1] // Inputs[1] { @02C2 msg.data.length } 02BB 5B JUMPDEST 02BC 61 PUSH2 0x0271 02BF 61 PUSH2 0x02c9 02C2 36 CALLDATASIZE 02C3 60 PUSH1 0x04 02C5 61 PUSH2 0x211d 02C8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BC stack[0] = 0x0271 // @02BF stack[1] = 0x02c9 // @02C2 stack[2] = msg.data.length // @02C3 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x211d 02C9 5B JUMPDEST 02CA 61 PUSH2 0x077f 02CD 56 *JUMP label_02CE: // Incoming jump from 0x016C, if 0x2f745c59 == stack[-1] // Inputs[1] { @02D5 msg.data.length } 02CE 5B JUMPDEST 02CF 61 PUSH2 0x02ae 02D2 61 PUSH2 0x02dc 02D5 36 CALLDATASIZE 02D6 60 PUSH1 0x04 02D8 61 PUSH2 0x2213 02DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02CF stack[0] = 0x02ae // @02D2 stack[1] = 0x02dc // @02D5 stack[2] = msg.data.length // @02D6 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2213 02DC 5B JUMPDEST 02DD 61 PUSH2 0x07bc 02E0 56 *JUMP label_02E1: // Incoming jump from 0x0177, if 0x42842e0e == stack[-1] // Inputs[1] { @02E8 msg.data.length } 02E1 5B JUMPDEST 02E2 61 PUSH2 0x0271 02E5 61 PUSH2 0x02ef 02E8 36 CALLDATASIZE 02E9 60 PUSH1 0x04 02EB 61 PUSH2 0x211d 02EE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E2 stack[0] = 0x0271 // @02E5 stack[1] = 0x02ef // @02E8 stack[2] = msg.data.length // @02E9 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x211d 02EF 5B JUMPDEST 02F0 61 PUSH2 0x081d 02F3 56 *JUMP label_02F4: // Incoming jump from 0x0182, if 0x42966c68 == stack[-1] // Inputs[1] { @02FB msg.data.length } 02F4 5B JUMPDEST 02F5 61 PUSH2 0x0271 02F8 61 PUSH2 0x0302 02FB 36 CALLDATASIZE 02FC 60 PUSH1 0x04 02FE 61 PUSH2 0x22b4 0301 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F5 stack[0] = 0x0271 // @02F8 stack[1] = 0x0302 // @02FB stack[2] = msg.data.length // @02FC stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22b4 0302 5B JUMPDEST 0303 61 PUSH2 0x0838 0306 56 *JUMP label_0307: // Incoming jump from 0x018D, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @030E msg.data.length } 0307 5B JUMPDEST 0308 61 PUSH2 0x02ae 030B 61 PUSH2 0x0315 030E 36 CALLDATASIZE 030F 60 PUSH1 0x04 0311 61 PUSH2 0x22b4 0314 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0308 stack[0] = 0x02ae // @030B stack[1] = 0x0315 // @030E stack[2] = msg.data.length // @030F stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22b4 0315 5B JUMPDEST 0316 61 PUSH2 0x0868 0319 56 *JUMP label_031A: // Incoming jump from 0x013B, if 0x6308f1cd == stack[-1] // Inputs[1] { @0321 msg.data.length } 031A 5B JUMPDEST 031B 61 PUSH2 0x032d 031E 61 PUSH2 0x0328 0321 36 CALLDATASIZE 0322 60 PUSH1 0x04 0324 61 PUSH2 0x22d2 0327 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @031B stack[0] = 0x032d // @031E stack[1] = 0x0328 // @0321 stack[2] = msg.data.length // @0322 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22d2 0328 5B JUMPDEST 0329 61 PUSH2 0x08af 032C 56 *JUMP 032D 5B JUMPDEST 032E 60 PUSH1 0x40 0330 51 MLOAD 0331 61 PUSH2 0x0220 0334 92 SWAP3 0335 91 SWAP2 0336 90 SWAP1 0337 61 PUSH2 0x2d6b 033A 56 *JUMP label_033B: // Incoming jump from 0x0146, if 0x6352211e == stack[-1] // Inputs[1] { @0342 msg.data.length } 033B 5B JUMPDEST 033C 61 PUSH2 0x0251 033F 61 PUSH2 0x0349 0342 36 CALLDATASIZE 0343 60 PUSH1 0x04 0345 61 PUSH2 0x22b4 0348 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @033C stack[0] = 0x0251 // @033F stack[1] = 0x0349 // @0342 stack[2] = msg.data.length // @0343 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22b4 0349 5B JUMPDEST 034A 61 PUSH2 0x08f2 034D 56 *JUMP label_034E: // Incoming jump from 0x0151, if 0x672a9400 == stack[-1] // Inputs[1] { @0355 msg.data.length } 034E 5B JUMPDEST 034F 61 PUSH2 0x0271 0352 61 PUSH2 0x035c 0355 36 CALLDATASIZE 0356 60 PUSH1 0x04 0358 61 PUSH2 0x22f1 035B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @034F stack[0] = 0x0271 // @0352 stack[1] = 0x035c // @0355 stack[2] = msg.data.length // @0356 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22f1 035C 5B JUMPDEST 035D 61 PUSH2 0x0927 0360 56 *JUMP label_0361: // Incoming jump from 0x015C, if 0x70a08231 == stack[-1] // Inputs[1] { @0368 msg.data.length } 0361 5B JUMPDEST 0362 61 PUSH2 0x02ae 0365 61 PUSH2 0x036f 0368 36 CALLDATASIZE 0369 60 PUSH1 0x04 036B 61 PUSH2 0x20c5 036E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0362 stack[0] = 0x02ae // @0365 stack[1] = 0x036f // @0368 stack[2] = msg.data.length // @0369 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20c5 036F 5B JUMPDEST 0370 61 PUSH2 0x0a03 0373 56 *JUMP label_0374: // Incoming jump from 0x00F4, if 0x715018a6 == stack[-1] 0374 5B JUMPDEST 0375 61 PUSH2 0x0271 0378 61 PUSH2 0x0a4c 037B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0375 stack[0] = 0x0271 } // Block ends with call to 0x0a4c, returns to 0x0271 label_037C: // Incoming jump from 0x00FF, if 0x7df73e27 == stack[-1] // Inputs[1] { @0383 msg.data.length } 037C 5B JUMPDEST 037D 61 PUSH2 0x0213 0380 61 PUSH2 0x038a 0383 36 CALLDATASIZE 0384 60 PUSH1 0x04 0386 61 PUSH2 0x20c5 0389 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @037D stack[0] = 0x0213 // @0380 stack[1] = 0x038a // @0383 stack[2] = msg.data.length // @0384 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20c5 038A 5B JUMPDEST 038B 61 PUSH2 0x0aba 038E 56 *JUMP label_038F: // Incoming jump from 0x010A, if 0x8da5cb5b == stack[-1] 038F 5B JUMPDEST 0390 61 PUSH2 0x0251 0393 61 PUSH2 0x0acd 0396 56 *JUMP // Stack delta = +1 // Outputs[1] { @0390 stack[0] = 0x0251 } // Block ends with call to 0x0acd, returns to 0x0251 label_0397: // Incoming jump from 0x0115, if 0x8f32d59b == stack[-1] 0397 5B JUMPDEST 0398 61 PUSH2 0x0213 039B 61 PUSH2 0x0adc 039E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0398 stack[0] = 0x0213 } // Block ends with call to 0x0adc, returns to 0x0213 label_039F: // Incoming jump from 0x00C3, if 0x938e3d7b == stack[-1] // Inputs[1] { @03A6 msg.data.length } 039F 5B JUMPDEST 03A0 61 PUSH2 0x0271 03A3 61 PUSH2 0x03ad 03A6 36 CALLDATASIZE 03A7 60 PUSH1 0x04 03A9 61 PUSH2 0x227f 03AC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03A0 stack[0] = 0x0271 // @03A3 stack[1] = 0x03ad // @03A6 stack[2] = msg.data.length // @03A7 stack[3] = 0x04 // } // Block ends with call to 0x227f, returns to 0x03AD label_03AD: // Incoming return from call to 0x227F at 0x03AC 03AD 5B JUMPDEST 03AE 61 PUSH2 0x0b00 03B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b00 label_03B2: // Incoming jump from 0x00CE, if 0x95d89b41 == stack[-1] 03B2 5B JUMPDEST 03B3 61 PUSH2 0x0231 03B6 61 PUSH2 0x0b2d 03B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @03B3 stack[0] = 0x0231 } // Block ends with call to 0x0b2d, returns to 0x0231 label_03BA: // Incoming jump from 0x00D9, if 0x99e0dd7c == stack[-1] // Inputs[1] { @03C1 msg.data.length } 03BA 5B JUMPDEST 03BB 61 PUSH2 0x0271 03BE 61 PUSH2 0x03c8 03C1 36 CALLDATASIZE 03C2 60 PUSH1 0x04 03C4 61 PUSH2 0x227f 03C7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03BB stack[0] = 0x0271 // @03BE stack[1] = 0x03c8 // @03C1 stack[2] = msg.data.length // @03C2 stack[3] = 0x04 // } // Block ends with call to 0x227f, returns to 0x03C8 label_03C8: // Incoming return from call to 0x227F at 0x03C7 03C8 5B JUMPDEST 03C9 61 PUSH2 0x0b88 03CC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b88 label_03CD: // Incoming jump from 0x00E4, if 0xa22cb465 == stack[-1] // Inputs[1] { @03D4 msg.data.length } 03CD 5B JUMPDEST 03CE 61 PUSH2 0x0271 03D1 61 PUSH2 0x03db 03D4 36 CALLDATASIZE 03D5 60 PUSH1 0x04 03D7 61 PUSH2 0x21e3 03DA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03CE stack[0] = 0x0271 // @03D1 stack[1] = 0x03db // @03D4 stack[2] = msg.data.length // @03D5 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x21e3 03DB 5B JUMPDEST 03DC 61 PUSH2 0x0bb5 03DF 56 *JUMP label_03E0: // Incoming jump from 0x0087, if 0xb88d4fde == stack[-1] // Inputs[1] { @03E7 msg.data.length } 03E0 5B JUMPDEST 03E1 61 PUSH2 0x0271 03E4 61 PUSH2 0x03ee 03E7 36 CALLDATASIZE 03E8 60 PUSH1 0x04 03EA 61 PUSH2 0x216a 03ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03E1 stack[0] = 0x0271 // @03E4 stack[1] = 0x03ee // @03E7 stack[2] = msg.data.length // @03E8 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x216a 03EE 5B JUMPDEST 03EF 61 PUSH2 0x0c83 03F2 56 *JUMP label_03F3: // Incoming jump from 0x0092, if 0xb9c4d9fb == stack[-1] // Inputs[1] { @03FA msg.data.length } 03F3 5B JUMPDEST 03F4 61 PUSH2 0x0406 03F7 61 PUSH2 0x0401 03FA 36 CALLDATASIZE 03FB 60 PUSH1 0x04 03FD 61 PUSH2 0x22b4 0400 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03F4 stack[0] = 0x0406 // @03F7 stack[1] = 0x0401 // @03FA stack[2] = msg.data.length // @03FB stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22b4 0401 5B JUMPDEST 0402 61 PUSH2 0x0cc2 0405 56 *JUMP 0406 5B JUMPDEST 0407 60 PUSH1 0x40 0409 51 MLOAD 040A 61 PUSH2 0x0220 040D 91 SWAP2 040E 90 SWAP1 040F 61 PUSH2 0x2d86 0412 56 *JUMP label_0413: // Incoming jump from 0x009D, if 0xc0ac9983 == stack[-1] 0413 5B JUMPDEST 0414 61 PUSH2 0x0231 0417 61 PUSH2 0x0dba 041A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0414 stack[0] = 0x0231 } // Block ends with call to 0x0dba, returns to 0x0231 label_041B: // Incoming jump from 0x00A8, if 0xc87b56dd == stack[-1] // Inputs[1] { @0422 msg.data.length } 041B 5B JUMPDEST 041C 61 PUSH2 0x0231 041F 61 PUSH2 0x0429 0422 36 CALLDATASIZE 0423 60 PUSH1 0x04 0425 61 PUSH2 0x22b4 0428 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @041C stack[0] = 0x0231 // @041F stack[1] = 0x0429 // @0422 stack[2] = msg.data.length // @0423 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x22b4 0429 5B JUMPDEST 042A 61 PUSH2 0x0e15 042D 56 *JUMP label_042E: // Incoming jump from 0x004B, if 0xe5c8b03d == stack[-1] 042E 5B JUMPDEST 042F 61 PUSH2 0x0271 0432 61 PUSH2 0x0e45 0435 56 *JUMP // Stack delta = +1 // Outputs[1] { @042F stack[0] = 0x0271 } // Block ends with call to 0x0e45, returns to 0x0271 label_0436: // Incoming jump from 0x0056, if 0xe8a3d485 == stack[-1] 0436 5B JUMPDEST 0437 61 PUSH2 0x0231 043A 61 PUSH2 0x0e57 043D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0437 stack[0] = 0x0231 } // Block ends with call to 0x0e57, returns to 0x0231 label_043E: // Incoming jump from 0x0061, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0445 msg.data.length } 043E 5B JUMPDEST 043F 61 PUSH2 0x0213 0442 61 PUSH2 0x044c 0445 36 CALLDATASIZE 0446 60 PUSH1 0x04 0448 61 PUSH2 0x20e3 044B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @043F stack[0] = 0x0213 // @0442 stack[1] = 0x044c // @0445 stack[2] = msg.data.length // @0446 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20e3 044C 5B JUMPDEST 044D 61 PUSH2 0x0eb2 0450 56 *JUMP label_0451: // Incoming jump from 0x006C, if 0xeb12d61e == stack[-1] // Inputs[1] { @0458 msg.data.length } 0451 5B JUMPDEST 0452 61 PUSH2 0x0271 0455 61 PUSH2 0x045f 0458 36 CALLDATASIZE 0459 60 PUSH1 0x04 045B 61 PUSH2 0x20c5 045E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0452 stack[0] = 0x0271 // @0455 stack[1] = 0x045f // @0458 stack[2] = msg.data.length // @0459 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20c5 045F 5B JUMPDEST 0460 61 PUSH2 0x0ee0 0463 56 *JUMP label_0464: // Incoming jump from 0x0077, if 0xf2fde38b == stack[-1] // Inputs[1] { @046B msg.data.length } 0464 5B JUMPDEST 0465 61 PUSH2 0x0271 0468 61 PUSH2 0x0472 046B 36 CALLDATASIZE 046C 60 PUSH1 0x04 046E 61 PUSH2 0x20c5 0471 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0465 stack[0] = 0x0271 // @0468 stack[1] = 0x0472 // @046B stack[2] = msg.data.length // @046C stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20c5 0472 5B JUMPDEST 0473 61 PUSH2 0x0f0d 0476 56 *JUMP 0477 5B JUMPDEST 0478 60 PUSH1 0x01 047A 60 PUSH1 0x01 047C 60 PUSH1 0xe0 047E 1B SHL 047F 03 SUB 0480 19 NOT 0481 16 AND 0482 60 PUSH1 0x00 0484 90 SWAP1 0485 81 DUP2 0486 52 MSTORE 0487 60 PUSH1 0x01 0489 60 PUSH1 0x20 048B 52 MSTORE 048C 60 PUSH1 0x40 048E 90 SWAP1 048F 20 SHA3 0490 54 SLOAD 0491 60 PUSH1 0xff 0493 16 AND 0494 90 SWAP1 0495 56 *JUMP label_0496: // Incoming call from 0x0230, returns to 0x0231 // Inputs[2] // { // @049A storage[0x0d] // @049E memory[0x40:0x60] // } 0496 5B JUMPDEST 0497 60 PUSH1 0x0d 0499 80 DUP1 049A 54 SLOAD 049B 60 PUSH1 0x40 049D 80 DUP1 049E 51 MLOAD 049F 60 PUSH1 0x20 04A1 60 PUSH1 0x02 04A3 60 PUSH1 0x01 04A5 85 DUP6 04A6 16 AND 04A7 15 ISZERO 04A8 61 PUSH2 0x0100 04AB 02 MUL 04AC 60 PUSH1 0x00 04AE 19 NOT 04AF 01 ADD 04B0 90 SWAP1 04B1 94 SWAP5 04B2 16 AND 04B3 93 SWAP4 04B4 90 SWAP1 04B5 93 SWAP4 04B6 04 DIV 04B7 60 PUSH1 0x1f 04B9 81 DUP2 04BA 01 ADD 04BB 84 DUP5 04BC 90 SWAP1 04BD 04 DIV 04BE 84 DUP5 04BF 02 MUL 04C0 82 DUP3 04C1 01 ADD 04C2 84 DUP5 04C3 01 ADD 04C4 90 SWAP1 04C5 92 SWAP3 04C6 52 MSTORE 04C7 81 DUP2 04C8 81 DUP2 04C9 52 MSTORE 04CA 92 SWAP3 04CB 91 SWAP2 04CC 83 DUP4 04CD 01 ADD 04CE 82 DUP3 04CF 82 DUP3 04D0 80 DUP1 04D1 15 ISZERO 04D2 61 PUSH2 0x051c 04D5 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @04C5 stack[2] = (storage[0x0d] & ~0x00 + 0x0100 * !(storage[0x0d] & 0x01)) / 0x02 // @04C6 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x0d] & ~0x00 + 0x0100 * !(storage[0x0d] & 0x01)) / 0x02 + 0x1f) / 0x20) // @04C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x0d] & ~0x00 + 0x0100 * !(storage[0x0d] & 0x01)) / 0x02 // @04CA stack[0] = memory[0x40:0x60] // @04CB stack[1] = 0x0d // @04CD stack[3] = memory[0x40:0x60] + 0x20 // @04CE stack[4] = 0x0d // @04CF stack[5] = (storage[0x0d] & ~0x00 + 0x0100 * !(storage[0x0d] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x051c, if !((storage[0x0d] & ~0x00 + 0x0100 * !(storage[0x0d] & 0x01)) / 0x02) label_04D6: // Incoming jump from 0x04D5, if not !((storage[0x0d] & ~0x00 + 0x0100 * !(storage[0x0d] & 0x01)) / 0x02) // Inputs[1] { @04D6 stack[-1] } 04D6 80 DUP1 04D7 60 PUSH1 0x1f 04D9 10 LT 04DA 61 PUSH2 0x04f1 04DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f1, if 0x1f < stack[-1] label_04DE: // Incoming jump from 0x04DD, if not 0x1f < stack[-1] // Inputs[4] // { // @04E2 stack[-2] // @04E3 storage[stack[-2]] // @04E6 stack[-3] // @04E8 stack[-1] // } 04DE 61 PUSH2 0x0100 04E1 80 DUP1 04E2 83 DUP4 04E3 54 SLOAD 04E4 04 DIV 04E5 02 MUL 04E6 83 DUP4 04E7 52 MSTORE 04E8 91 SWAP2 04E9 60 PUSH1 0x20 04EB 01 ADD 04EC 91 SWAP2 04ED 61 PUSH2 0x051c 04F0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04E7 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @04EC stack[-1] = stack[-1] // @04EC stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x051c label_04F1: // Incoming jump from 0x04DD, if 0x1f < stack[-1] // Incoming jump from 0x0B74, if 0x1f < stack[-1] // Incoming jump from 0x0E01, if 0x1f < stack[-1] // Incoming jump from 0x0E9E, if 0x1f < stack[-1] // Inputs[5] // { // @04F2 stack[-3] // @04F3 stack[-1] // @04F5 stack[-2] // @04FD memory[0x00:0x20] // @0501 storage[keccak256(memory[0x00:0x20])] // } 04F1 5B JUMPDEST 04F2 82 DUP3 04F3 01 ADD 04F4 91 SWAP2 04F5 90 SWAP1 04F6 60 PUSH1 0x00 04F8 52 MSTORE 04F9 60 PUSH1 0x20 04FB 60 PUSH1 0x00 04FD 20 SHA3 04FE 90 SWAP1 04FF 5B JUMPDEST 0500 81 DUP2 0501 54 SLOAD 0502 81 DUP2 0503 52 MSTORE 0504 90 SWAP1 0505 60 PUSH1 0x01 0507 01 ADD 0508 90 SWAP1 0509 60 PUSH1 0x20 050B 01 ADD 050C 80 DUP1 050D 83 DUP4 050E 11 GT 050F 61 PUSH2 0x04ff 0512 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @04F4 stack[-3] = stack[-3] + stack[-1] // @04F8 memory[0x00:0x20] = stack[-2] // @0503 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0508 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @050B stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04ff, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0513: // Incoming jump from 0x0512, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0512, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0513 stack[-3] // @0514 stack[-1] // } 0513 82 DUP3 0514 90 SWAP1 0515 03 SUB 0516 60 PUSH1 0x1f 0518 16 AND 0519 82 DUP3 051A 01 ADD 051B 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @051B stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @051B stack[-1] = stack[-3] // } // Block continues label_051C: // Incoming jump from 0x04D5, if !((storage[0x0d] & ~0x00 + 0x0100 * !(storage[0x0d] & 0x01)) / 0x02) // Incoming jump from 0x0E96, if !((storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02) // Incoming jump from 0x0E14 // Incoming jump from 0x0B6C, if !((storage[0x0e] & ~0x00 + 0x0100 * !(storage[0x0e] & 0x01)) / 0x02) // Incoming jump from 0x051B // Incoming jump from 0x0EB1 // Incoming jump from 0x04F0 // Incoming jump from 0x0DF9, if !((storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02) // Incoming jump from 0x0B87 // Inputs[1] { @0522 stack[-7] } 051C 5B JUMPDEST 051D 50 POP 051E 50 POP 051F 50 POP 0520 50 POP 0521 50 POP 0522 81 DUP2 0523 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] 0524 5B JUMPDEST 0525 60 PUSH1 0x00 0527 61 PUSH2 0x052f 052A 82 DUP3 052B 61 PUSH2 0x0f3a 052E 56 *JUMP 052F 5B JUMPDEST 0530 61 PUSH2 0x0554 0533 57 *JUMPI 0534 60 PUSH1 0x40 0536 51 MLOAD 0537 62 PUSH3 0x461bcd 053B 60 PUSH1 0xe5 053D 1B SHL 053E 81 DUP2 053F 52 MSTORE 0540 60 PUSH1 0x04 0542 01 ADD 0543 61 PUSH2 0x054b 0546 90 SWAP1 0547 61 PUSH2 0x2ee5 054A 56 *JUMP 054B 5B JUMPDEST 054C 60 PUSH1 0x40 054E 51 MLOAD 054F 80 DUP1 0550 91 SWAP2 0551 03 SUB 0552 90 SWAP1 0553 FD *REVERT 0554 5B JUMPDEST 0555 50 POP 0556 60 PUSH1 0x00 0558 90 SWAP1 0559 81 DUP2 055A 52 MSTORE 055B 60 PUSH1 0x03 055D 60 PUSH1 0x20 055F 52 MSTORE 0560 60 PUSH1 0x40 0562 90 SWAP1 0563 20 SHA3 0564 54 SLOAD 0565 60 PUSH1 0x01 0567 60 PUSH1 0x01 0569 60 PUSH1 0xa0 056B 1B SHL 056C 03 SUB 056D 16 AND 056E 90 SWAP1 056F 56 *JUMP 0570 5B JUMPDEST 0571 60 PUSH1 0x00 0573 61 PUSH2 0x057b 0576 82 DUP3 0577 61 PUSH2 0x08f2 057A 56 *JUMP 057B 5B JUMPDEST 057C 90 SWAP1 057D 50 POP 057E 80 DUP1 057F 60 PUSH1 0x01 0581 60 PUSH1 0x01 0583 60 PUSH1 0xa0 0585 1B SHL 0586 03 SUB 0587 16 AND 0588 83 DUP4 0589 60 PUSH1 0x01 058B 60 PUSH1 0x01 058D 60 PUSH1 0xa0 058F 1B SHL 0590 03 SUB 0591 16 AND 0592 14 EQ 0593 15 ISZERO 0594 61 PUSH2 0x05af 0597 57 *JUMPI 0598 60 PUSH1 0x40 059A 51 MLOAD 059B 62 PUSH3 0x461bcd 059F 60 PUSH1 0xe5 05A1 1B SHL 05A2 81 DUP2 05A3 52 MSTORE 05A4 60 PUSH1 0x04 05A6 01 ADD 05A7 61 PUSH2 0x054b 05AA 90 SWAP1 05AB 61 PUSH2 0x2f45 05AE 56 *JUMP 05AF 5B JUMPDEST 05B0 80 DUP1 05B1 60 PUSH1 0x01 05B3 60 PUSH1 0x01 05B5 60 PUSH1 0xa0 05B7 1B SHL 05B8 03 SUB 05B9 16 AND 05BA 61 PUSH2 0x05c1 05BD 61 PUSH2 0x0f57 05C0 56 *JUMP 05C1 5B JUMPDEST 05C2 60 PUSH1 0x01 05C4 60 PUSH1 0x01 05C6 60 PUSH1 0xa0 05C8 1B SHL 05C9 03 SUB 05CA 16 AND 05CB 14 EQ 05CC 80 DUP1 05CD 61 PUSH2 0x05dd 05D0 57 *JUMPI 05D1 50 POP 05D2 61 PUSH2 0x05dd 05D5 81 DUP2 05D6 61 PUSH2 0x044c 05D9 61 PUSH2 0x0f57 05DC 56 *JUMP 05DD 5B JUMPDEST 05DE 61 PUSH2 0x05f9 05E1 57 *JUMPI 05E2 60 PUSH1 0x40 05E4 51 MLOAD 05E5 62 PUSH3 0x461bcd 05E9 60 PUSH1 0xe5 05EB 1B SHL 05EC 81 DUP2 05ED 52 MSTORE 05EE 60 PUSH1 0x04 05F0 01 ADD 05F1 61 PUSH2 0x054b 05F4 90 SWAP1 05F5 61 PUSH2 0x2e95 05F8 56 *JUMP 05F9 5B JUMPDEST 05FA 60 PUSH1 0x00 05FC 82 DUP3 05FD 81 DUP2 05FE 52 MSTORE 05FF 60 PUSH1 0x03 0601 60 PUSH1 0x20 0603 52 MSTORE 0604 60 PUSH1 0x40 0606 80 DUP1 0607 82 DUP3 0608 20 SHA3 0609 80 DUP1 060A 54 SLOAD 060B 60 PUSH1 0x01 060D 60 PUSH1 0x01 060F 60 PUSH1 0xa0 0611 1B SHL 0612 03 SUB 0613 19 NOT 0614 16 AND 0615 60 PUSH1 0x01 0617 60 PUSH1 0x01 0619 60 PUSH1 0xa0 061B 1B SHL 061C 03 SUB 061D 87 DUP8 061E 81 DUP2 061F 16 AND 0620 91 SWAP2 0621 82 DUP3 0622 17 OR 0623 90 SWAP1 0624 92 SWAP3 0625 55 SSTORE 0626 91 SWAP2 0627 51 MLOAD 0628 85 DUP6 0629 93 SWAP4 062A 91 SWAP2 062B 85 DUP6 062C 16 AND 062D 91 SWAP2 062E 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 064F 91 SWAP2 0650 A4 LOG4 0651 50 POP 0652 50 POP 0653 50 POP 0654 56 *JUMP 0655 5B JUMPDEST 0656 61 PUSH2 0x065d 0659 61 PUSH2 0x0adc 065C 56 *JUMP 065D 5B JUMPDEST 065E 61 PUSH2 0x0679 0661 57 *JUMPI 0662 60 PUSH1 0x40 0664 51 MLOAD 0665 62 PUSH3 0x461bcd 0669 60 PUSH1 0xe5 066B 1B SHL 066C 81 DUP2 066D 52 MSTORE 066E 60 PUSH1 0x04 0670 01 ADD 0671 61 PUSH2 0x054b 0674 90 SWAP1 0675 61 PUSH2 0x2f05 0678 56 *JUMP 0679 5B JUMPDEST 067A 61 PUSH2 0x0682 067D 81 DUP2 067E 61 PUSH2 0x0f5b 0681 56 *JUMP label_0682: // Incoming jump from 0x3121, if stack[-2] == stack[-1] // Inputs[1] { @0684 stack[-2] } 0682 5B JUMPDEST 0683 50 POP 0684 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 0685 5B JUMPDEST 0686 60 PUSH1 0x00 0688 81 DUP2 0689 81 DUP2 068A 52 MSTORE 068B 60 PUSH1 0x0f 068D 60 PUSH1 0x20 068F 90 SWAP1 0690 81 DUP2 0691 52 MSTORE 0692 60 PUSH1 0x40 0694 80 DUP1 0695 83 DUP4 0696 20 SHA3 0697 80 DUP1 0698 54 SLOAD 0699 82 DUP3 069A 51 MLOAD 069B 81 DUP2 069C 85 DUP6 069D 02 MUL 069E 81 DUP2 069F 01 ADD 06A0 85 DUP6 06A1 01 ADD 06A2 90 SWAP1 06A3 93 SWAP4 06A4 52 MSTORE 06A5 80 DUP1 06A6 83 DUP4 06A7 52 MSTORE 06A8 60 PUSH1 0x60 06AA 94 SWAP5 06AB 85 DUP6 06AC 94 SWAP5 06AD 84 DUP5 06AE 01 ADD 06AF 5B JUMPDEST 06B0 82 DUP3 06B1 82 DUP3 06B2 10 LT 06B3 15 ISZERO 06B4 61 PUSH2 0x06f7 06B7 57 *JUMPI 06B8 60 PUSH1 0x00 06BA 84 DUP5 06BB 81 DUP2 06BC 52 MSTORE 06BD 60 PUSH1 0x20 06BF 90 SWAP1 06C0 81 DUP2 06C1 90 SWAP1 06C2 20 SHA3 06C3 60 PUSH1 0x40 06C5 80 DUP1 06C6 51 MLOAD 06C7 80 DUP1 06C8 82 DUP3 06C9 01 ADD 06CA 90 SWAP1 06CB 91 SWAP2 06CC 52 MSTORE 06CD 60 PUSH1 0x02 06CF 85 DUP6 06D0 02 MUL 06D1 90 SWAP1 06D2 91 SWAP2 06D3 01 ADD 06D4 80 DUP1 06D5 54 SLOAD 06D6 60 PUSH1 0x01 06D8 60 PUSH1 0x01 06DA 60 PUSH1 0xa0 06DC 1B SHL 06DD 03 SUB 06DE 16 AND 06DF 82 DUP3 06E0 52 MSTORE 06E1 60 PUSH1 0x01 06E3 90 SWAP1 06E4 81 DUP2 06E5 01 ADD 06E6 54 SLOAD 06E7 82 DUP3 06E8 84 DUP5 06E9 01 ADD 06EA 52 MSTORE 06EB 90 SWAP1 06EC 83 DUP4 06ED 52 MSTORE 06EE 90 SWAP1 06EF 92 SWAP3 06F0 01 ADD 06F1 91 SWAP2 06F2 01 ADD 06F3 61 PUSH2 0x06af 06F6 56 *JUMP 06F7 5B JUMPDEST 06F8 50 POP 06F9 50 POP 06FA 50 POP 06FB 50 POP 06FC 90 SWAP1 06FD 50 POP 06FE 60 PUSH1 0x60 0700 81 DUP2 0701 51 MLOAD 0702 60 PUSH1 0x40 0704 51 MLOAD 0705 90 SWAP1 0706 80 DUP1 0707 82 DUP3 0708 52 MSTORE 0709 80 DUP1 070A 60 PUSH1 0x20 070C 02 MUL 070D 60 PUSH1 0x20 070F 01 ADD 0710 82 DUP3 0711 01 ADD 0712 60 PUSH1 0x40 0714 52 MSTORE 0715 80 DUP1 0716 15 ISZERO 0717 61 PUSH2 0x072a 071A 57 *JUMPI 071B 81 DUP2 071C 60 PUSH1 0x20 071E 01 ADD 071F 60 PUSH1 0x20 0721 82 DUP3 0722 02 MUL 0723 80 DUP1 0724 38 CODESIZE 0725 83 DUP4 0726 39 CODECOPY 0727 01 ADD 0728 90 SWAP1 0729 50 POP 072A 5B JUMPDEST 072B 50 POP 072C 90 SWAP1 072D 50 POP 072E 60 PUSH1 0x00 0730 5B JUMPDEST 0731 82 DUP3 0732 51 MLOAD 0733 81 DUP2 0734 10 LT 0735 15 ISZERO 0736 61 PUSH2 0x0770 0739 57 *JUMPI 073A 82 DUP3 073B 81 DUP2 073C 81 DUP2 073D 51 MLOAD 073E 81 DUP2 073F 10 LT 0740 61 PUSH2 0x0745 0743 57 *JUMPI 0744 FE *ASSERT 0745 5B JUMPDEST 0746 60 PUSH1 0x20 0748 02 MUL 0749 60 PUSH1 0x20 074B 01 ADD 074C 01 ADD 074D 51 MLOAD 074E 60 PUSH1 0x20 0750 01 ADD 0751 51 MLOAD 0752 82 DUP3 0753 82 DUP3 0754 81 DUP2 0755 51 MLOAD 0756 81 DUP2 0757 10 LT 0758 61 PUSH2 0x075d 075B 57 *JUMPI 075C FE *ASSERT 075D 5B JUMPDEST 075E 60 PUSH1 0x20 0760 90 SWAP1 0761 81 DUP2 0762 02 MUL 0763 91 SWAP2 0764 90 SWAP1 0765 91 SWAP2 0766 01 ADD 0767 01 ADD 0768 52 MSTORE 0769 60 PUSH1 0x01 076B 01 ADD 076C 61 PUSH2 0x0730 076F 56 *JUMP 0770 5B JUMPDEST 0771 50 POP 0772 93 SWAP4 0773 92 SWAP3 0774 50 POP 0775 50 POP 0776 50 POP 0777 56 *JUMP label_0778: // Incoming call from 0x02AD, returns to 0x02AE // Inputs[2] // { // @077B storage[0x0b] // @077D stack[-1] // } 0778 5B JUMPDEST 0779 60 PUSH1 0x0b 077B 54 SLOAD 077C 5B JUMPDEST 077D 90 SWAP1 077E 56 *JUMP // Stack delta = +0 // Outputs[1] { @077D stack[-1] = storage[0x0b] } // Block ends with unconditional jump to stack[-1] 077F 5B JUMPDEST 0780 61 PUSH2 0x0790 0783 61 PUSH2 0x078a 0786 61 PUSH2 0x0f57 0789 56 *JUMP 078A 5B JUMPDEST 078B 82 DUP3 078C 61 PUSH2 0x0fa3 078F 56 *JUMP 0790 5B JUMPDEST 0791 61 PUSH2 0x07ac 0794 57 *JUMPI 0795 60 PUSH1 0x40 0797 51 MLOAD 0798 62 PUSH3 0x461bcd 079C 60 PUSH1 0xe5 079E 1B SHL 079F 81 DUP2 07A0 52 MSTORE 07A1 60 PUSH1 0x04 07A3 01 ADD 07A4 61 PUSH2 0x054b 07A7 90 SWAP1 07A8 61 PUSH2 0x2f55 07AB 56 *JUMP 07AC 5B JUMPDEST 07AD 61 PUSH2 0x07b7 07B0 83 DUP4 07B1 83 DUP4 07B2 83 DUP4 07B3 61 PUSH2 0x1028 07B6 56 *JUMP 07B7 5B JUMPDEST 07B8 50 POP 07B9 50 POP 07BA 50 POP 07BB 56 *JUMP 07BC 5B JUMPDEST 07BD 60 PUSH1 0x00 07BF 61 PUSH2 0x07c7 07C2 83 DUP4 07C3 61 PUSH2 0x0a03 07C6 56 *JUMP 07C7 5B JUMPDEST 07C8 82 DUP3 07C9 10 LT 07CA 61 PUSH2 0x07e5 07CD 57 *JUMPI 07CE 60 PUSH1 0x40 07D0 51 MLOAD 07D1 62 PUSH3 0x461bcd 07D5 60 PUSH1 0xe5 07D7 1B SHL 07D8 81 DUP2 07D9 52 MSTORE 07DA 60 PUSH1 0x04 07DC 01 ADD 07DD 61 PUSH2 0x054b 07E0 90 SWAP1 07E1 61 PUSH2 0x2e25 07E4 56 *JUMP 07E5 5B JUMPDEST 07E6 60 PUSH1 0x01 07E8 60 PUSH1 0x01 07EA 60 PUSH1 0xa0 07EC 1B SHL 07ED 03 SUB 07EE 83 DUP4 07EF 16 AND 07F0 60 PUSH1 0x00 07F2 90 SWAP1 07F3 81 DUP2 07F4 52 MSTORE 07F5 60 PUSH1 0x09 07F7 60 PUSH1 0x20 07F9 52 MSTORE 07FA 60 PUSH1 0x40 07FC 90 SWAP1 07FD 20 SHA3 07FE 80 DUP1 07FF 54 SLOAD 0800 83 DUP4 0801 90 SWAP1 0802 81 DUP2 0803 10 LT 0804 61 PUSH2 0x0809 0807 57 *JUMPI 0808 FE *ASSERT 0809 5B JUMPDEST 080A 90 SWAP1 080B 60 PUSH1 0x00 080D 52 MSTORE 080E 60 PUSH1 0x20 0810 60 PUSH1 0x00 0812 20 SHA3 0813 01 ADD 0814 54 SLOAD 0815 90 SWAP1 0816 50 POP label_0817: // Incoming return from call to 0x28AD at 0x2ED4 // Incoming return from call to 0x23C8 at 0x2D26 // Incoming return from call to 0x29FE at 0x2F24 // Incoming return from call to 0x309C at 0x3089 // Incoming return from call to 0x3138 at 0x2018 // Incoming return from call to 0x24D5 at 0x2FC2 // Incoming return from call to 0x312F at 0x200D // Incoming return from call to 0x29C5 at 0x2F14 // Inputs[3] // { // @0818 stack[-4] // @0818 stack[-1] // @0819 stack[-3] // } 0817 5B JUMPDEST 0818 92 SWAP3 0819 91 SWAP2 081A 50 POP 081B 50 POP 081C 56 *JUMP // Stack delta = -3 // Outputs[1] { @0818 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 081D 5B JUMPDEST 081E 61 PUSH2 0x07b7 0821 83 DUP4 0822 83 DUP4 0823 83 DUP4 0824 60 PUSH1 0x40 0826 51 MLOAD 0827 80 DUP1 0828 60 PUSH1 0x20 082A 01 ADD 082B 60 PUSH1 0x40 082D 52 MSTORE 082E 80 DUP1 082F 60 PUSH1 0x00 0831 81 DUP2 0832 52 MSTORE 0833 50 POP 0834 61 PUSH2 0x0c83 0837 56 *JUMP 0838 5B JUMPDEST 0839 61 PUSH2 0x0843 083C 61 PUSH2 0x078a 083F 61 PUSH2 0x0f57 0842 56 *JUMP 0843 5B JUMPDEST 0844 61 PUSH2 0x085f 0847 57 *JUMPI 0848 60 PUSH1 0x40 084A 51 MLOAD 084B 62 PUSH3 0x461bcd 084F 60 PUSH1 0xe5 0851 1B SHL 0852 81 DUP2 0853 52 MSTORE 0854 60 PUSH1 0x04 0856 01 ADD 0857 61 PUSH2 0x054b 085A 90 SWAP1 085B 61 PUSH2 0x2f95 085E 56 *JUMP 085F 5B JUMPDEST 0860 61 PUSH2 0x0682 0863 81 DUP2 0864 61 PUSH2 0x1047 0867 56 *JUMP 0868 5B JUMPDEST 0869 60 PUSH1 0x00 086B 61 PUSH2 0x0872 086E 61 PUSH2 0x0778 0871 56 *JUMP 0872 5B JUMPDEST 0873 82 DUP3 0874 10 LT 0875 61 PUSH2 0x0890 0878 57 *JUMPI 0879 60 PUSH1 0x40 087B 51 MLOAD 087C 62 PUSH3 0x461bcd 0880 60 PUSH1 0xe5 0882 1B SHL 0883 81 DUP2 0884 52 MSTORE 0885 60 PUSH1 0x04 0887 01 ADD 0888 61 PUSH2 0x054b 088B 90 SWAP1 088C 61 PUSH2 0x2f65 088F 56 *JUMP 0890 5B JUMPDEST 0891 60 PUSH1 0x0b 0893 82 DUP3 0894 81 DUP2 0895 54 SLOAD 0896 81 DUP2 0897 10 LT 0898 61 PUSH2 0x089d 089B 57 *JUMPI 089C FE *ASSERT 089D 5B JUMPDEST 089E 90 SWAP1 089F 60 PUSH1 0x00 08A1 52 MSTORE 08A2 60 PUSH1 0x20 08A4 60 PUSH1 0x00 08A6 20 SHA3 08A7 01 ADD 08A8 54 SLOAD 08A9 90 SWAP1 08AA 50 POP 08AB 91 SWAP2 08AC 90 SWAP1 08AD 50 POP 08AE 56 *JUMP 08AF 5B JUMPDEST 08B0 60 PUSH1 0x0f 08B2 60 PUSH1 0x20 08B4 52 MSTORE 08B5 81 DUP2 08B6 60 PUSH1 0x00 08B8 52 MSTORE 08B9 60 PUSH1 0x40 08BB 60 PUSH1 0x00 08BD 20 SHA3 08BE 81 DUP2 08BF 81 DUP2 08C0 54 SLOAD 08C1 81 DUP2 08C2 10 LT 08C3 61 PUSH2 0x08c8 08C6 57 *JUMPI 08C7 FE *ASSERT 08C8 5B JUMPDEST 08C9 60 PUSH1 0x00 08CB 91 SWAP2 08CC 82 DUP3 08CD 52 MSTORE 08CE 60 PUSH1 0x20 08D0 90 SWAP1 08D1 91 SWAP2 08D2 20 SHA3 08D3 60 PUSH1 0x02 08D5 90 SWAP1 08D6 91 SWAP2 08D7 02 MUL 08D8 01 ADD 08D9 80 DUP1 08DA 54 SLOAD 08DB 60 PUSH1 0x01 08DD 90 SWAP1 08DE 91 SWAP2 08DF 01 ADD 08E0 54 SLOAD 08E1 60 PUSH1 0x01 08E3 60 PUSH1 0x01 08E5 60 PUSH1 0xa0 08E7 1B SHL 08E8 03 SUB 08E9 90 SWAP1 08EA 91 SWAP2 08EB 16 AND 08EC 92 SWAP3 08ED 50 POP 08EE 90 SWAP1 08EF 50 POP 08F0 82 DUP3 08F1 56 *JUMP 08F2 5B JUMPDEST 08F3 60 PUSH1 0x00 08F5 81 DUP2 08F6 81 DUP2 08F7 52 MSTORE 08F8 60 PUSH1 0x02 08FA 60 PUSH1 0x20 08FC 52 MSTORE 08FD 60 PUSH1 0x40 08FF 81 DUP2 0900 20 SHA3 0901 54 SLOAD 0902 60 PUSH1 0x01 0904 60 PUSH1 0x01 0906 60 PUSH1 0xa0 0908 1B SHL 0909 03 SUB 090A 16 AND 090B 80 DUP1 090C 61 PUSH2 0x0817 090F 57 *JUMPI 0910 60 PUSH1 0x40 0912 51 MLOAD 0913 62 PUSH3 0x461bcd 0917 60 PUSH1 0xe5 0919 1B SHL 091A 81 DUP2 091B 52 MSTORE 091C 60 PUSH1 0x04 091E 01 ADD 091F 61 PUSH2 0x054b 0922 90 SWAP1 0923 61 PUSH2 0x2eb5 0926 56 *JUMP 0927 5B JUMPDEST 0928 61 PUSH2 0x092f 092B 61 PUSH2 0x0adc 092E 56 *JUMP 092F 5B JUMPDEST 0930 61 PUSH2 0x094b 0933 57 *JUMPI 0934 60 PUSH1 0x40 0936 51 MLOAD 0937 62 PUSH3 0x461bcd 093B 60 PUSH1 0xe5 093D 1B SHL 093E 81 DUP2 093F 52 MSTORE 0940 60 PUSH1 0x04 0942 01 ADD 0943 61 PUSH2 0x054b 0946 90 SWAP1 0947 61 PUSH2 0x2f05 094A 56 *JUMP 094B 5B JUMPDEST 094C 61 PUSH2 0x09ca 094F 60 PUSH1 0x01 0951 30 ADDRESS 0952 88 DUP9 0953 60 PUSH1 0x40 0955 51 MLOAD 0956 60 PUSH1 0x20 0958 01 ADD 0959 61 PUSH2 0x0963 095C 92 SWAP3 095D 91 SWAP2 095E 90 SWAP1 095F 61 PUSH2 0x2cf3 0962 56 *JUMP 0963 5B JUMPDEST 0964 60 PUSH1 0x40 0966 51 MLOAD 0967 60 PUSH1 0x20 0969 81 DUP2 096A 83 DUP4 096B 03 SUB 096C 03 SUB 096D 81 DUP2 096E 52 MSTORE 096F 90 SWAP1 0970 60 PUSH1 0x40 0972 52 MSTORE 0973 80 DUP1 0974 51 MLOAD 0975 90 SWAP1 0976 60 PUSH1 0x20 0978 01 ADD 0979 20 SHA3 097A 87 DUP8 097B 87 DUP8 097C 87 DUP8 097D 60 PUSH1 0x40 097F 51 MLOAD 0980 60 PUSH1 0x00 0982 81 DUP2 0983 52 MSTORE 0984 60 PUSH1 0x20 0986 01 ADD 0987 60 PUSH1 0x40 0989 52 MSTORE 098A 60 PUSH1 0x40 098C 51 MLOAD 098D 61 PUSH2 0x0999 0990 94 SWAP5 0991 93 SWAP4 0992 92 SWAP3 0993 91 SWAP2 0994 90 SWAP1 0995 61 PUSH2 0x2db6 0998 56 *JUMP 0999 5B JUMPDEST 099A 60 PUSH1 0x20 099C 60 PUSH1 0x40 099E 51 MLOAD 099F 60 PUSH1 0x20 09A1 81 DUP2 09A2 03 SUB 09A3 90 SWAP1 09A4 80 DUP1 09A5 84 DUP5 09A6 03 SUB 09A7 90 SWAP1 09A8 85 DUP6 09A9 5A GAS 09AA FA STATICCALL 09AB 15 ISZERO 09AC 80 DUP1 09AD 15 ISZERO 09AE 61 PUSH2 0x09bb 09B1 57 *JUMPI 09B2 3D RETURNDATASIZE 09B3 60 PUSH1 0x00 09B5 80 DUP1 09B6 3E RETURNDATACOPY 09B7 3D RETURNDATASIZE 09B8 60 PUSH1 0x00 09BA FD *REVERT 09BB 5B JUMPDEST 09BC 50 POP 09BD 50 POP 09BE 50 POP 09BF 60 PUSH1 0x20 09C1 60 PUSH1 0x40 09C3 51 MLOAD 09C4 03 SUB 09C5 51 MLOAD 09C6 61 PUSH2 0x0aba 09C9 56 *JUMP 09CA 5B JUMPDEST 09CB 61 PUSH2 0x09e6 09CE 57 *JUMPI 09CF 60 PUSH1 0x40 09D1 51 MLOAD 09D2 62 PUSH3 0x461bcd 09D6 60 PUSH1 0xe5 09D8 1B SHL 09D9 81 DUP2 09DA 52 MSTORE 09DB 60 PUSH1 0x04 09DD 01 ADD 09DE 61 PUSH2 0x054b 09E1 90 SWAP1 09E2 61 PUSH2 0x2fa5 09E5 56 *JUMP 09E6 5B JUMPDEST 09E7 61 PUSH2 0x09f1 09EA 33 CALLER 09EB 87 DUP8 09EC 84 DUP5 09ED 61 PUSH2 0x1059 09F0 56 *JUMP 09F1 5B JUMPDEST 09F2 61 PUSH2 0x09fb 09F5 86 DUP7 09F6 82 DUP3 09F7 61 PUSH2 0x127e 09FA 56 *JUMP 09FB 5B JUMPDEST 09FC 50 POP 09FD 50 POP 09FE 50 POP 09FF 50 POP 0A00 50 POP 0A01 50 POP 0A02 56 *JUMP 0A03 5B JUMPDEST 0A04 60 PUSH1 0x00 0A06 60 PUSH1 0x01 0A08 60 PUSH1 0x01 0A0A 60 PUSH1 0xa0 0A0C 1B SHL 0A0D 03 SUB 0A0E 82 DUP3 0A0F 16 AND 0A10 61 PUSH2 0x0a2b 0A13 57 *JUMPI 0A14 60 PUSH1 0x40 0A16 51 MLOAD 0A17 62 PUSH3 0x461bcd 0A1B 60 PUSH1 0xe5 0A1D 1B SHL 0A1E 81 DUP2 0A1F 52 MSTORE 0A20 60 PUSH1 0x04 0A22 01 ADD 0A23 61 PUSH2 0x054b 0A26 90 SWAP1 0A27 61 PUSH2 0x2ea5 0A2A 56 *JUMP 0A2B 5B JUMPDEST 0A2C 60 PUSH1 0x01 0A2E 60 PUSH1 0x01 0A30 60 PUSH1 0xa0 0A32 1B SHL 0A33 03 SUB 0A34 82 DUP3 0A35 16 AND 0A36 60 PUSH1 0x00 0A38 90 SWAP1 0A39 81 DUP2 0A3A 52 MSTORE 0A3B 60 PUSH1 0x04 0A3D 60 PUSH1 0x20 0A3F 52 MSTORE 0A40 60 PUSH1 0x40 0A42 90 SWAP1 0A43 20 SHA3 0A44 61 PUSH2 0x0817 0A47 90 SWAP1 0A48 61 PUSH2 0x12b1 0A4B 56 *JUMP label_0A4C: // Incoming call from 0x037B, returns to 0x0271 0A4C 5B JUMPDEST 0A4D 61 PUSH2 0x0a54 0A50 61 PUSH2 0x0adc 0A53 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A4D stack[0] = 0x0a54 } // Block ends with call to 0x0adc, returns to 0x0A54 label_0A54: // Incoming return from call to 0x0ADC at 0x0A53 // Inputs[1] { @0A58 stack[-1] } 0A54 5B JUMPDEST 0A55 61 PUSH2 0x0a70 0A58 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a70, if stack[-1] label_0A59: // Incoming jump from 0x0A58, if not stack[-1] // Inputs[1] { @0A5B memory[0x40:0x60] } 0A59 60 PUSH1 0x40 0A5B 51 MLOAD 0A5C 62 PUSH3 0x461bcd 0A60 60 PUSH1 0xe5 0A62 1B SHL 0A63 81 DUP2 0A64 52 MSTORE 0A65 60 PUSH1 0x04 0A67 01 ADD 0A68 61 PUSH2 0x054b 0A6B 90 SWAP1 0A6C 61 PUSH2 0x2f05 0A6F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A6B stack[0] = 0x054b // @0A6B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2f05 label_0A70: // Incoming jump from 0x0A58, if stack[-1] // Inputs[5] // { // @0A74 storage[0x00] // @0A77 memory[0x40:0x60] // @0AA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0AAC storage[0x00] // @0AB9 stack[-1] // } 0A70 5B JUMPDEST 0A71 60 PUSH1 0x00 0A73 80 DUP1 0A74 54 SLOAD 0A75 60 PUSH1 0x40 0A77 51 MLOAD 0A78 60 PUSH1 0x01 0A7A 60 PUSH1 0x01 0A7C 60 PUSH1 0xa0 0A7E 1B SHL 0A7F 03 SUB 0A80 90 SWAP1 0A81 91 SWAP2 0A82 16 AND 0A83 90 SWAP1 0A84 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0AA5 90 SWAP1 0AA6 83 DUP4 0AA7 90 SWAP1 0AA8 A3 LOG3 0AA9 60 PUSH1 0x00 0AAB 80 DUP1 0AAC 54 SLOAD 0AAD 60 PUSH1 0x01 0AAF 60 PUSH1 0x01 0AB1 60 PUSH1 0xa0 0AB3 1B SHL 0AB4 03 SUB 0AB5 19 NOT 0AB6 16 AND 0AB7 90 SWAP1 0AB8 55 SSTORE 0AB9 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0AA8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, 0x00]); // @0AB8 storage[0x00] = ~((0x01 << 0xa0) - 0x01) & storage[0x00] // } // Block ends with unconditional jump to stack[-1] 0ABA 5B JUMPDEST 0ABB 60 PUSH1 0x00 0ABD 61 PUSH2 0x0817 0AC0 60 PUSH1 0x10 0AC2 83 DUP4 0AC3 63 PUSH4 0xffffffff 0AC8 61 PUSH2 0x12b5 0ACB 16 AND 0ACC 56 *JUMP label_0ACD: // Incoming call from 0x0396, returns to 0x0251 // Inputs[2] // { // @0AD0 storage[0x00] // @0ADA stack[-1] // } 0ACD 5B JUMPDEST 0ACE 60 PUSH1 0x00 0AD0 54 SLOAD 0AD1 60 PUSH1 0x01 0AD3 60 PUSH1 0x01 0AD5 60 PUSH1 0xa0 0AD7 1B SHL 0AD8 03 SUB 0AD9 16 AND 0ADA 90 SWAP1 0ADB 56 *JUMP // Stack delta = +0 // Outputs[1] { @0ADA stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to stack[-1] label_0ADC: // Incoming call from 0x0B8F, returns to 0x0B90 // Incoming call from 0x0B07, returns to 0x0B08 // Incoming call from 0x0A53, returns to 0x0A54 // Incoming call from 0x039E, returns to 0x0213 // Inputs[1] { @0AE0 storage[0x00] } 0ADC 5B JUMPDEST 0ADD 60 PUSH1 0x00 0ADF 80 DUP1 0AE0 54 SLOAD 0AE1 60 PUSH1 0x01 0AE3 60 PUSH1 0x01 0AE5 60 PUSH1 0xa0 0AE7 1B SHL 0AE8 03 SUB 0AE9 16 AND 0AEA 61 PUSH2 0x0af1 0AED 61 PUSH2 0x0f57 0AF0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0ADD stack[0] = 0x00 // @0AE9 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x00] // @0AEA stack[2] = 0x0af1 // } // Block ends with call to 0x0f57, returns to 0x0AF1 label_0AF1: // Incoming return from call to 0x0F57 at 0x0AF0 // Inputs[4] // { // @0AFA stack[-1] // @0AFB stack[-2] // @0AFC stack[-3] // @0AFE stack[-4] // } 0AF1 5B JUMPDEST 0AF2 60 PUSH1 0x01 0AF4 60 PUSH1 0x01 0AF6 60 PUSH1 0xa0 0AF8 1B SHL 0AF9 03 SUB 0AFA 16 AND 0AFB 14 EQ 0AFC 90 SWAP1 0AFD 50 POP 0AFE 90 SWAP1 0AFF 56 *JUMP // Stack delta = -3 // Outputs[1] { @0AFE stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-4] label_0B00: // Incoming jump from 0x03B1 0B00 5B JUMPDEST 0B01 61 PUSH2 0x0b08 0B04 61 PUSH2 0x0adc 0B07 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B01 stack[0] = 0x0b08 } // Block ends with call to 0x0adc, returns to 0x0B08 label_0B08: // Incoming return from call to 0x0ADC at 0x0B07 // Inputs[1] { @0B0C stack[-1] } 0B08 5B JUMPDEST 0B09 61 PUSH2 0x0b24 0B0C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b24, if stack[-1] label_0B0D: // Incoming jump from 0x0B0C, if not stack[-1] // Inputs[1] { @0B0F memory[0x40:0x60] } 0B0D 60 PUSH1 0x40 0B0F 51 MLOAD 0B10 62 PUSH3 0x461bcd 0B14 60 PUSH1 0xe5 0B16 1B SHL 0B17 81 DUP2 0B18 52 MSTORE 0B19 60 PUSH1 0x04 0B1B 01 ADD 0B1C 61 PUSH2 0x054b 0B1F 90 SWAP1 0B20 61 PUSH2 0x2f05 0B23 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B1F stack[0] = 0x054b // @0B1F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2f05 label_0B24: // Incoming jump from 0x0B0C, if stack[-1] // Inputs[1] { @0B28 stack[-1] } 0B24 5B JUMPDEST 0B25 61 PUSH2 0x0682 0B28 81 DUP2 0B29 61 PUSH2 0x12fd 0B2C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B25 stack[0] = 0x0682 // @0B28 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x12fd label_0B2D: // Incoming call from 0x03B9, returns to 0x0231 // Inputs[2] // { // @0B31 storage[0x0e] // @0B35 memory[0x40:0x60] // } 0B2D 5B JUMPDEST 0B2E 60 PUSH1 0x0e 0B30 80 DUP1 0B31 54 SLOAD 0B32 60 PUSH1 0x40 0B34 80 DUP1 0B35 51 MLOAD 0B36 60 PUSH1 0x20 0B38 60 PUSH1 0x02 0B3A 60 PUSH1 0x01 0B3C 85 DUP6 0B3D 16 AND 0B3E 15 ISZERO 0B3F 61 PUSH2 0x0100 0B42 02 MUL 0B43 60 PUSH1 0x00 0B45 19 NOT 0B46 01 ADD 0B47 90 SWAP1 0B48 94 SWAP5 0B49 16 AND 0B4A 93 SWAP4 0B4B 90 SWAP1 0B4C 93 SWAP4 0B4D 04 DIV 0B4E 60 PUSH1 0x1f 0B50 81 DUP2 0B51 01 ADD 0B52 84 DUP5 0B53 90 SWAP1 0B54 04 DIV 0B55 84 DUP5 0B56 02 MUL 0B57 82 DUP3 0B58 01 ADD 0B59 84 DUP5 0B5A 01 ADD 0B5B 90 SWAP1 0B5C 92 SWAP3 0B5D 52 MSTORE 0B5E 81 DUP2 0B5F 81 DUP2 0B60 52 MSTORE 0B61 92 SWAP3 0B62 91 SWAP2 0B63 83 DUP4 0B64 01 ADD 0B65 82 DUP3 0B66 82 DUP3 0B67 80 DUP1 0B68 15 ISZERO 0B69 61 PUSH2 0x051c 0B6C 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0B5C stack[2] = (storage[0x0e] & ~0x00 + 0x0100 * !(storage[0x0e] & 0x01)) / 0x02 // @0B5D memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x0e] & ~0x00 + 0x0100 * !(storage[0x0e] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0B60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x0e] & ~0x00 + 0x0100 * !(storage[0x0e] & 0x01)) / 0x02 // @0B61 stack[0] = memory[0x40:0x60] // @0B62 stack[1] = 0x0e // @0B64 stack[3] = memory[0x40:0x60] + 0x20 // @0B65 stack[4] = 0x0e // @0B66 stack[5] = (storage[0x0e] & ~0x00 + 0x0100 * !(storage[0x0e] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x051c, if !((storage[0x0e] & ~0x00 + 0x0100 * !(storage[0x0e] & 0x01)) / 0x02) label_0B6D: // Incoming jump from 0x0B6C, if not !((storage[0x0e] & ~0x00 + 0x0100 * !(storage[0x0e] & 0x01)) / 0x02) // Inputs[1] { @0B6D stack[-1] } 0B6D 80 DUP1 0B6E 60 PUSH1 0x1f 0B70 10 LT 0B71 61 PUSH2 0x04f1 0B74 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f1, if 0x1f < stack[-1] label_0B75: // Incoming jump from 0x0B74, if not 0x1f < stack[-1] // Inputs[4] // { // @0B79 stack[-2] // @0B7A storage[stack[-2]] // @0B7D stack[-3] // @0B7F stack[-1] // } 0B75 61 PUSH2 0x0100 0B78 80 DUP1 0B79 83 DUP4 0B7A 54 SLOAD 0B7B 04 DIV 0B7C 02 MUL 0B7D 83 DUP4 0B7E 52 MSTORE 0B7F 91 SWAP2 0B80 60 PUSH1 0x20 0B82 01 ADD 0B83 91 SWAP2 0B84 61 PUSH2 0x051c 0B87 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B7E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0B83 stack[-1] = stack[-1] // @0B83 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x051c label_0B88: // Incoming jump from 0x03CC 0B88 5B JUMPDEST 0B89 61 PUSH2 0x0b90 0B8C 61 PUSH2 0x0adc 0B8F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B89 stack[0] = 0x0b90 } // Block ends with call to 0x0adc, returns to 0x0B90 label_0B90: // Incoming return from call to 0x0ADC at 0x0B8F // Inputs[1] { @0B94 stack[-1] } 0B90 5B JUMPDEST 0B91 61 PUSH2 0x0bac 0B94 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bac, if stack[-1] label_0B95: // Incoming jump from 0x0B94, if not stack[-1] // Inputs[1] { @0B97 memory[0x40:0x60] } 0B95 60 PUSH1 0x40 0B97 51 MLOAD 0B98 62 PUSH3 0x461bcd 0B9C 60 PUSH1 0xe5 0B9E 1B SHL 0B9F 81 DUP2 0BA0 52 MSTORE 0BA1 60 PUSH1 0x04 0BA3 01 ADD 0BA4 61 PUSH2 0x054b 0BA7 90 SWAP1 0BA8 61 PUSH2 0x2f05 0BAB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BA7 stack[0] = 0x054b // @0BA7 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2f05 label_0BAC: // Incoming jump from 0x0B94, if stack[-1] // Inputs[1] { @0BB0 stack[-1] } 0BAC 5B JUMPDEST 0BAD 61 PUSH2 0x0682 0BB0 81 DUP2 0BB1 61 PUSH2 0x1310 0BB4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BAD stack[0] = 0x0682 // @0BB0 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1310 0BB5 5B JUMPDEST 0BB6 61 PUSH2 0x0bbd 0BB9 61 PUSH2 0x0f57 0BBC 56 *JUMP 0BBD 5B JUMPDEST 0BBE 60 PUSH1 0x01 0BC0 60 PUSH1 0x01 0BC2 60 PUSH1 0xa0 0BC4 1B SHL 0BC5 03 SUB 0BC6 16 AND 0BC7 82 DUP3 0BC8 60 PUSH1 0x01 0BCA 60 PUSH1 0x01 0BCC 60 PUSH1 0xa0 0BCE 1B SHL 0BCF 03 SUB 0BD0 16 AND 0BD1 14 EQ 0BD2 15 ISZERO 0BD3 61 PUSH2 0x0bee 0BD6 57 *JUMPI 0BD7 60 PUSH1 0x40 0BD9 51 MLOAD 0BDA 62 PUSH3 0x461bcd 0BDE 60 PUSH1 0xe5 0BE0 1B SHL 0BE1 81 DUP2 0BE2 52 MSTORE 0BE3 60 PUSH1 0x04 0BE5 01 ADD 0BE6 61 PUSH2 0x054b 0BE9 90 SWAP1 0BEA 61 PUSH2 0x2e75 0BED 56 *JUMP 0BEE 5B JUMPDEST 0BEF 80 DUP1 0BF0 60 PUSH1 0x05 0BF2 60 PUSH1 0x00 0BF4 61 PUSH2 0x0bfb 0BF7 61 PUSH2 0x0f57 0BFA 56 *JUMP 0BFB 5B JUMPDEST 0BFC 60 PUSH1 0x01 0BFE 60 PUSH1 0x01 0C00 60 PUSH1 0xa0 0C02 1B SHL 0C03 03 SUB 0C04 90 SWAP1 0C05 81 DUP2 0C06 16 AND 0C07 82 DUP3 0C08 52 MSTORE 0C09 60 PUSH1 0x20 0C0B 80 DUP1 0C0C 83 DUP4 0C0D 01 ADD 0C0E 93 SWAP4 0C0F 90 SWAP1 0C10 93 SWAP4 0C11 52 MSTORE 0C12 60 PUSH1 0x40 0C14 91 SWAP2 0C15 82 DUP3 0C16 01 ADD 0C17 60 PUSH1 0x00 0C19 90 SWAP1 0C1A 81 DUP2 0C1B 20 SHA3 0C1C 91 SWAP2 0C1D 87 DUP8 0C1E 16 AND 0C1F 80 DUP1 0C20 82 DUP3 0C21 52 MSTORE 0C22 91 SWAP2 0C23 90 SWAP1 0C24 93 SWAP4 0C25 52 MSTORE 0C26 91 SWAP2 0C27 20 SHA3 0C28 80 DUP1 0C29 54 SLOAD 0C2A 60 PUSH1 0xff 0C2C 19 NOT 0C2D 16 AND 0C2E 92 SWAP3 0C2F 15 ISZERO 0C30 15 ISZERO 0C31 92 SWAP3 0C32 90 SWAP1 0C33 92 SWAP3 0C34 17 OR 0C35 90 SWAP1 0C36 91 SWAP2 0C37 55 SSTORE 0C38 61 PUSH2 0x0c3f 0C3B 61 PUSH2 0x0f57 0C3E 56 *JUMP 0C3F 5B JUMPDEST 0C40 60 PUSH1 0x01 0C42 60 PUSH1 0x01 0C44 60 PUSH1 0xa0 0C46 1B SHL 0C47 03 SUB 0C48 16 AND 0C49 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0C6A 83 DUP4 0C6B 60 PUSH1 0x40 0C6D 51 MLOAD 0C6E 61 PUSH2 0x0c77 0C71 91 SWAP2 0C72 90 SWAP1 0C73 61 PUSH2 0x2da8 0C76 56 *JUMP 0C77 5B JUMPDEST 0C78 60 PUSH1 0x40 0C7A 51 MLOAD 0C7B 80 DUP1 0C7C 91 SWAP2 0C7D 03 SUB 0C7E 90 SWAP1 0C7F A3 LOG3 0C80 50 POP 0C81 50 POP 0C82 56 *JUMP 0C83 5B JUMPDEST 0C84 61 PUSH2 0x0c94 0C87 61 PUSH2 0x0c8e 0C8A 61 PUSH2 0x0f57 0C8D 56 *JUMP 0C8E 5B JUMPDEST 0C8F 83 DUP4 0C90 61 PUSH2 0x0fa3 0C93 56 *JUMP 0C94 5B JUMPDEST 0C95 61 PUSH2 0x0cb0 0C98 57 *JUMPI 0C99 60 PUSH1 0x40 0C9B 51 MLOAD 0C9C 62 PUSH3 0x461bcd 0CA0 60 PUSH1 0xe5 0CA2 1B SHL 0CA3 81 DUP2 0CA4 52 MSTORE 0CA5 60 PUSH1 0x04 0CA7 01 ADD 0CA8 61 PUSH2 0x054b 0CAB 90 SWAP1 0CAC 61 PUSH2 0x2f55 0CAF 56 *JUMP 0CB0 5B JUMPDEST 0CB1 61 PUSH2 0x0cbc 0CB4 84 DUP5 0CB5 84 DUP5 0CB6 84 DUP5 0CB7 84 DUP5 0CB8 61 PUSH2 0x1323 0CBB 56 *JUMP label_0CBC: // Incoming jump from 0x30E8, if !(stack[-1] > stack[-4]) // Inputs[1] { @0CC1 stack[-5] } 0CBC 5B JUMPDEST 0CBD 50 POP 0CBE 50 POP 0CBF 50 POP 0CC0 50 POP 0CC1 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] 0CC2 5B JUMPDEST 0CC3 60 PUSH1 0x00 0CC5 81 DUP2 0CC6 81 DUP2 0CC7 52 MSTORE 0CC8 60 PUSH1 0x0f 0CCA 60 PUSH1 0x20 0CCC 90 SWAP1 0CCD 81 DUP2 0CCE 52 MSTORE 0CCF 60 PUSH1 0x40 0CD1 80 DUP1 0CD2 83 DUP4 0CD3 20 SHA3 0CD4 80 DUP1 0CD5 54 SLOAD 0CD6 82 DUP3 0CD7 51 MLOAD 0CD8 81 DUP2 0CD9 85 DUP6 0CDA 02 MUL 0CDB 81 DUP2 0CDC 01 ADD 0CDD 85 DUP6 0CDE 01 ADD 0CDF 90 SWAP1 0CE0 93 SWAP4 0CE1 52 MSTORE 0CE2 80 DUP1 0CE3 83 DUP4 0CE4 52 MSTORE 0CE5 60 PUSH1 0x60 0CE7 94 SWAP5 0CE8 85 DUP6 0CE9 94 SWAP5 0CEA 84 DUP5 0CEB 01 ADD 0CEC 5B JUMPDEST 0CED 82 DUP3 0CEE 82 DUP3 0CEF 10 LT 0CF0 15 ISZERO 0CF1 61 PUSH2 0x0d34 0CF4 57 *JUMPI 0CF5 60 PUSH1 0x00 0CF7 84 DUP5 0CF8 81 DUP2 0CF9 52 MSTORE 0CFA 60 PUSH1 0x20 0CFC 90 SWAP1 0CFD 81 DUP2 0CFE 90 SWAP1 0CFF 20 SHA3 0D00 60 PUSH1 0x40 0D02 80 DUP1 0D03 51 MLOAD 0D04 80 DUP1 0D05 82 DUP3 0D06 01 ADD 0D07 90 SWAP1 0D08 91 SWAP2 0D09 52 MSTORE 0D0A 60 PUSH1 0x02 0D0C 85 DUP6 0D0D 02 MUL 0D0E 90 SWAP1 0D0F 91 SWAP2 0D10 01 ADD 0D11 80 DUP1 0D12 54 SLOAD 0D13 60 PUSH1 0x01 0D15 60 PUSH1 0x01 0D17 60 PUSH1 0xa0 0D19 1B SHL 0D1A 03 SUB 0D1B 16 AND 0D1C 82 DUP3 0D1D 52 MSTORE 0D1E 60 PUSH1 0x01 0D20 90 SWAP1 0D21 81 DUP2 0D22 01 ADD 0D23 54 SLOAD 0D24 82 DUP3 0D25 84 DUP5 0D26 01 ADD 0D27 52 MSTORE 0D28 90 SWAP1 0D29 83 DUP4 0D2A 52 MSTORE 0D2B 90 SWAP1 0D2C 92 SWAP3 0D2D 01 ADD 0D2E 91 SWAP2 0D2F 01 ADD 0D30 61 PUSH2 0x0cec 0D33 56 *JUMP 0D34 5B JUMPDEST 0D35 50 POP 0D36 50 POP 0D37 50 POP 0D38 50 POP 0D39 90 SWAP1 0D3A 50 POP 0D3B 60 PUSH1 0x60 0D3D 81 DUP2 0D3E 51 MLOAD 0D3F 60 PUSH1 0x40 0D41 51 MLOAD 0D42 90 SWAP1 0D43 80 DUP1 0D44 82 DUP3 0D45 52 MSTORE 0D46 80 DUP1 0D47 60 PUSH1 0x20 0D49 02 MUL 0D4A 60 PUSH1 0x20 0D4C 01 ADD 0D4D 82 DUP3 0D4E 01 ADD 0D4F 60 PUSH1 0x40 0D51 52 MSTORE 0D52 80 DUP1 0D53 15 ISZERO 0D54 61 PUSH2 0x0d67 0D57 57 *JUMPI 0D58 81 DUP2 0D59 60 PUSH1 0x20 0D5B 01 ADD 0D5C 60 PUSH1 0x20 0D5E 82 DUP3 0D5F 02 MUL 0D60 80 DUP1 0D61 38 CODESIZE 0D62 83 DUP4 0D63 39 CODECOPY 0D64 01 ADD 0D65 90 SWAP1 0D66 50 POP 0D67 5B JUMPDEST 0D68 50 POP 0D69 90 SWAP1 0D6A 50 POP 0D6B 60 PUSH1 0x00 0D6D 5B JUMPDEST 0D6E 82 DUP3 0D6F 51 MLOAD 0D70 81 DUP2 0D71 10 LT 0D72 15 ISZERO 0D73 61 PUSH2 0x0770 0D76 57 *JUMPI 0D77 82 DUP3 0D78 81 DUP2 0D79 81 DUP2 0D7A 51 MLOAD 0D7B 81 DUP2 0D7C 10 LT 0D7D 61 PUSH2 0x0d82 0D80 57 *JUMPI 0D81 FE *ASSERT 0D82 5B JUMPDEST 0D83 60 PUSH1 0x20 0D85 02 MUL 0D86 60 PUSH1 0x20 0D88 01 ADD 0D89 01 ADD 0D8A 51 MLOAD 0D8B 60 PUSH1 0x00 0D8D 01 ADD 0D8E 51 MLOAD 0D8F 82 DUP3 0D90 82 DUP3 0D91 81 DUP2 0D92 51 MLOAD 0D93 81 DUP2 0D94 10 LT 0D95 61 PUSH2 0x0d9a 0D98 57 *JUMPI 0D99 FE *ASSERT 0D9A 5B JUMPDEST 0D9B 60 PUSH1 0x01 0D9D 60 PUSH1 0x01 0D9F 60 PUSH1 0xa0 0DA1 1B SHL 0DA2 03 SUB 0DA3 90 SWAP1 0DA4 92 SWAP3 0DA5 16 AND 0DA6 60 PUSH1 0x20 0DA8 92 SWAP3 0DA9 83 DUP4 0DAA 02 MUL 0DAB 91 SWAP2 0DAC 90 SWAP1 0DAD 91 SWAP2 0DAE 01 ADD 0DAF 90 SWAP1 0DB0 91 SWAP2 0DB1 01 ADD 0DB2 52 MSTORE 0DB3 60 PUSH1 0x01 0DB5 01 ADD 0DB6 61 PUSH2 0x0d6d 0DB9 56 *JUMP label_0DBA: // Incoming call from 0x041A, returns to 0x0231 // Inputs[2] // { // @0DBE storage[0x07] // @0DC2 memory[0x40:0x60] // } 0DBA 5B JUMPDEST 0DBB 60 PUSH1 0x07 0DBD 80 DUP1 0DBE 54 SLOAD 0DBF 60 PUSH1 0x40 0DC1 80 DUP1 0DC2 51 MLOAD 0DC3 60 PUSH1 0x20 0DC5 60 PUSH1 0x02 0DC7 60 PUSH1 0x01 0DC9 85 DUP6 0DCA 16 AND 0DCB 15 ISZERO 0DCC 61 PUSH2 0x0100 0DCF 02 MUL 0DD0 60 PUSH1 0x00 0DD2 19 NOT 0DD3 01 ADD 0DD4 90 SWAP1 0DD5 94 SWAP5 0DD6 16 AND 0DD7 93 SWAP4 0DD8 90 SWAP1 0DD9 93 SWAP4 0DDA 04 DIV 0DDB 60 PUSH1 0x1f 0DDD 81 DUP2 0DDE 01 ADD 0DDF 84 DUP5 0DE0 90 SWAP1 0DE1 04 DIV 0DE2 84 DUP5 0DE3 02 MUL 0DE4 82 DUP3 0DE5 01 ADD 0DE6 84 DUP5 0DE7 01 ADD 0DE8 90 SWAP1 0DE9 92 SWAP3 0DEA 52 MSTORE 0DEB 81 DUP2 0DEC 81 DUP2 0DED 52 MSTORE 0DEE 92 SWAP3 0DEF 91 SWAP2 0DF0 83 DUP4 0DF1 01 ADD 0DF2 82 DUP3 0DF3 82 DUP3 0DF4 80 DUP1 0DF5 15 ISZERO 0DF6 61 PUSH2 0x051c 0DF9 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0DE9 stack[2] = (storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02 // @0DEA memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0DED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02 // @0DEE stack[0] = memory[0x40:0x60] // @0DEF stack[1] = 0x07 // @0DF1 stack[3] = memory[0x40:0x60] + 0x20 // @0DF2 stack[4] = 0x07 // @0DF3 stack[5] = (storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x051c, if !((storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02) label_0DFA: // Incoming jump from 0x0DF9, if not !((storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02) // Inputs[1] { @0DFA stack[-1] } 0DFA 80 DUP1 0DFB 60 PUSH1 0x1f 0DFD 10 LT 0DFE 61 PUSH2 0x04f1 0E01 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f1, if 0x1f < stack[-1] label_0E02: // Incoming jump from 0x0E01, if not 0x1f < stack[-1] // Inputs[4] // { // @0E06 stack[-2] // @0E07 storage[stack[-2]] // @0E0A stack[-3] // @0E0C stack[-1] // } 0E02 61 PUSH2 0x0100 0E05 80 DUP1 0E06 83 DUP4 0E07 54 SLOAD 0E08 04 DIV 0E09 02 MUL 0E0A 83 DUP4 0E0B 52 MSTORE 0E0C 91 SWAP2 0E0D 60 PUSH1 0x20 0E0F 01 ADD 0E10 91 SWAP2 0E11 61 PUSH2 0x051c 0E14 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E0B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0E10 stack[-1] = stack[-1] // @0E10 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x051c 0E15 5B JUMPDEST 0E16 60 PUSH1 0x60 0E18 61 PUSH2 0x0e20 0E1B 82 DUP3 0E1C 61 PUSH2 0x0f3a 0E1F 56 *JUMP 0E20 5B JUMPDEST 0E21 61 PUSH2 0x0e3c 0E24 57 *JUMPI 0E25 60 PUSH1 0x40 0E27 51 MLOAD 0E28 62 PUSH3 0x461bcd 0E2C 60 PUSH1 0xe5 0E2E 1B SHL 0E2F 81 DUP2 0E30 52 MSTORE 0E31 60 PUSH1 0x04 0E33 01 ADD 0E34 61 PUSH2 0x054b 0E37 90 SWAP1 0E38 61 PUSH2 0x2f35 0E3B 56 *JUMP 0E3C 5B JUMPDEST 0E3D 61 PUSH2 0x0817 0E40 82 DUP3 0E41 61 PUSH2 0x1356 0E44 56 *JUMP label_0E45: // Incoming call from 0x0435, returns to 0x0271 0E45 5B JUMPDEST 0E46 61 PUSH2 0x0e55 0E49 61 PUSH2 0x0e50 0E4C 61 PUSH2 0x0f57 0E4F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E46 stack[0] = 0x0e55 // @0E49 stack[1] = 0x0e50 // } // Block ends with call to 0x0f57, returns to 0x0E50 label_0E50: // Incoming return from call to 0x0F57 at 0x0E4F 0E50 5B JUMPDEST 0E51 61 PUSH2 0x0f5b 0E54 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f5b label_0E55: // Incoming return from call to 0x0E50 at 0x0E4F // Inputs[1] { @0E56 stack[-1] } 0E55 5B JUMPDEST 0E56 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0E57: // Incoming call from 0x043D, returns to 0x0231 // Inputs[2] // { // @0E5B storage[0x06] // @0E5F memory[0x40:0x60] // } 0E57 5B JUMPDEST 0E58 60 PUSH1 0x06 0E5A 80 DUP1 0E5B 54 SLOAD 0E5C 60 PUSH1 0x40 0E5E 80 DUP1 0E5F 51 MLOAD 0E60 60 PUSH1 0x20 0E62 60 PUSH1 0x02 0E64 60 PUSH1 0x01 0E66 85 DUP6 0E67 16 AND 0E68 15 ISZERO 0E69 61 PUSH2 0x0100 0E6C 02 MUL 0E6D 60 PUSH1 0x00 0E6F 19 NOT 0E70 01 ADD 0E71 90 SWAP1 0E72 94 SWAP5 0E73 16 AND 0E74 93 SWAP4 0E75 90 SWAP1 0E76 93 SWAP4 0E77 04 DIV 0E78 60 PUSH1 0x1f 0E7A 81 DUP2 0E7B 01 ADD 0E7C 84 DUP5 0E7D 90 SWAP1 0E7E 04 DIV 0E7F 84 DUP5 0E80 02 MUL 0E81 82 DUP3 0E82 01 ADD 0E83 84 DUP5 0E84 01 ADD 0E85 90 SWAP1 0E86 92 SWAP3 0E87 52 MSTORE 0E88 81 DUP2 0E89 81 DUP2 0E8A 52 MSTORE 0E8B 92 SWAP3 0E8C 91 SWAP2 0E8D 83 DUP4 0E8E 01 ADD 0E8F 82 DUP3 0E90 82 DUP3 0E91 80 DUP1 0E92 15 ISZERO 0E93 61 PUSH2 0x051c 0E96 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0E86 stack[2] = (storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02 // @0E87 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0E8A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02 // @0E8B stack[0] = memory[0x40:0x60] // @0E8C stack[1] = 0x06 // @0E8E stack[3] = memory[0x40:0x60] + 0x20 // @0E8F stack[4] = 0x06 // @0E90 stack[5] = (storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x051c, if !((storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02) label_0E97: // Incoming jump from 0x0E96, if not !((storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02) // Inputs[1] { @0E97 stack[-1] } 0E97 80 DUP1 0E98 60 PUSH1 0x1f 0E9A 10 LT 0E9B 61 PUSH2 0x04f1 0E9E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f1, if 0x1f < stack[-1] label_0E9F: // Incoming jump from 0x0E9E, if not 0x1f < stack[-1] // Inputs[4] // { // @0EA3 stack[-2] // @0EA4 storage[stack[-2]] // @0EA7 stack[-3] // @0EA9 stack[-1] // } 0E9F 61 PUSH2 0x0100 0EA2 80 DUP1 0EA3 83 DUP4 0EA4 54 SLOAD 0EA5 04 DIV 0EA6 02 MUL 0EA7 83 DUP4 0EA8 52 MSTORE 0EA9 91 SWAP2 0EAA 60 PUSH1 0x20 0EAC 01 ADD 0EAD 91 SWAP2 0EAE 61 PUSH2 0x051c 0EB1 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0EA8 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0EAD stack[-1] = stack[-1] // @0EAD stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x051c 0EB2 5B JUMPDEST 0EB3 60 PUSH1 0x01 0EB5 60 PUSH1 0x01 0EB7 60 PUSH1 0xa0 0EB9 1B SHL 0EBA 03 SUB 0EBB 91 SWAP2 0EBC 82 DUP3 0EBD 16 AND 0EBE 60 PUSH1 0x00 0EC0 90 SWAP1 0EC1 81 DUP2 0EC2 52 MSTORE 0EC3 60 PUSH1 0x05 0EC5 60 PUSH1 0x20 0EC7 90 SWAP1 0EC8 81 DUP2 0EC9 52 MSTORE 0ECA 60 PUSH1 0x40 0ECC 80 DUP1 0ECD 83 DUP4 0ECE 20 SHA3 0ECF 93 SWAP4 0ED0 90 SWAP1 0ED1 94 SWAP5 0ED2 16 AND 0ED3 82 DUP3 0ED4 52 MSTORE 0ED5 91 SWAP2 0ED6 90 SWAP1 0ED7 91 SWAP2 0ED8 52 MSTORE 0ED9 20 SHA3 0EDA 54 SLOAD 0EDB 60 PUSH1 0xff 0EDD 16 AND 0EDE 90 SWAP1 0EDF 56 *JUMP 0EE0 5B JUMPDEST 0EE1 61 PUSH2 0x0ee8 0EE4 61 PUSH2 0x0adc 0EE7 56 *JUMP 0EE8 5B JUMPDEST 0EE9 61 PUSH2 0x0f04 0EEC 57 *JUMPI 0EED 60 PUSH1 0x40 0EEF 51 MLOAD 0EF0 62 PUSH3 0x461bcd 0EF4 60 PUSH1 0xe5 0EF6 1B SHL 0EF7 81 DUP2 0EF8 52 MSTORE 0EF9 60 PUSH1 0x04 0EFB 01 ADD 0EFC 61 PUSH2 0x054b 0EFF 90 SWAP1 0F00 61 PUSH2 0x2f05 0F03 56 *JUMP 0F04 5B JUMPDEST 0F05 61 PUSH2 0x0682 0F08 81 DUP2 0F09 61 PUSH2 0x1491 0F0C 56 *JUMP 0F0D 5B JUMPDEST 0F0E 61 PUSH2 0x0f15 0F11 61 PUSH2 0x0adc 0F14 56 *JUMP 0F15 5B JUMPDEST 0F16 61 PUSH2 0x0f31 0F19 57 *JUMPI 0F1A 60 PUSH1 0x40 0F1C 51 MLOAD 0F1D 62 PUSH3 0x461bcd 0F21 60 PUSH1 0xe5 0F23 1B SHL 0F24 81 DUP2 0F25 52 MSTORE 0F26 60 PUSH1 0x04 0F28 01 ADD 0F29 61 PUSH2 0x054b 0F2C 90 SWAP1 0F2D 61 PUSH2 0x2f05 0F30 56 *JUMP 0F31 5B JUMPDEST 0F32 61 PUSH2 0x0682 0F35 81 DUP2 0F36 61 PUSH2 0x14d9 0F39 56 *JUMP 0F3A 5B JUMPDEST 0F3B 60 PUSH1 0x00 0F3D 90 SWAP1 0F3E 81 DUP2 0F3F 52 MSTORE 0F40 60 PUSH1 0x02 0F42 60 PUSH1 0x20 0F44 52 MSTORE 0F45 60 PUSH1 0x40 0F47 90 SWAP1 0F48 20 SHA3 0F49 54 SLOAD 0F4A 60 PUSH1 0x01 0F4C 60 PUSH1 0x01 0F4E 60 PUSH1 0xa0 0F50 1B SHL 0F51 03 SUB 0F52 16 AND 0F53 15 ISZERO 0F54 15 ISZERO 0F55 90 SWAP1 0F56 56 *JUMP label_0F57: // Incoming call from 0x0AF0, returns to 0x0AF1 // Incoming call from 0x0E4F, returns to 0x0E50 // Inputs[2] // { // @0F58 msg.sender // @0F59 stack[-1] // } 0F57 5B JUMPDEST 0F58 33 CALLER 0F59 90 SWAP1 0F5A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0F59 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_0F5B: // Incoming jump from 0x0E54 // Inputs[1] { @0F61 stack[-1] } 0F5B 5B JUMPDEST 0F5C 61 PUSH2 0x0f6c 0F5F 60 PUSH1 0x10 0F61 82 DUP3 0F62 63 PUSH4 0xffffffff 0F67 61 PUSH2 0x155a 0F6A 16 AND 0F6B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F5C stack[0] = 0x0f6c // @0F5F stack[1] = 0x10 // @0F61 stack[2] = stack[-1] // } // Block ends with call to 0x155a & 0xffffffff, returns to 0x0F6C label_0F6C: // Incoming return from call to 0x155A at 0x0F6B // Inputs[4] // { // @0F6F memory[0x40:0x60] // @0F78 stack[-1] // @0FA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0FA2 stack[-2] // } 0F6C 5B JUMPDEST 0F6D 60 PUSH1 0x40 0F6F 51 MLOAD 0F70 60 PUSH1 0x01 0F72 60 PUSH1 0x01 0F74 60 PUSH1 0xa0 0F76 1B SHL 0F77 03 SUB 0F78 82 DUP3 0F79 16 AND 0F7A 90 SWAP1 0F7B 7F PUSH32 0x3525e22824a8a7df2c9a6029941c824cf95b6447f1e13d5128fd3826d35afe8b 0F9C 90 SWAP1 0F9D 60 PUSH1 0x00 0F9F 90 SWAP1 0FA0 A2 LOG2 0FA1 50 POP 0FA2 56 *JUMP // Stack delta = -2 // Outputs[1] { @0FA0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x3525e22824a8a7df2c9a6029941c824cf95b6447f1e13d5128fd3826d35afe8b, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] 0FA3 5B JUMPDEST 0FA4 60 PUSH1 0x00 0FA6 61 PUSH2 0x0fae 0FA9 82 DUP3 0FAA 61 PUSH2 0x0f3a 0FAD 56 *JUMP 0FAE 5B JUMPDEST 0FAF 61 PUSH2 0x0fca 0FB2 57 *JUMPI 0FB3 60 PUSH1 0x40 0FB5 51 MLOAD 0FB6 62 PUSH3 0x461bcd 0FBA 60 PUSH1 0xe5 0FBC 1B SHL 0FBD 81 DUP2 0FBE 52 MSTORE 0FBF 60 PUSH1 0x04 0FC1 01 ADD 0FC2 61 PUSH2 0x054b 0FC5 90 SWAP1 0FC6 61 PUSH2 0x2e85 0FC9 56 *JUMP 0FCA 5B JUMPDEST 0FCB 60 PUSH1 0x00 0FCD 61 PUSH2 0x0fd5 0FD0 83 DUP4 0FD1 61 PUSH2 0x08f2 0FD4 56 *JUMP 0FD5 5B JUMPDEST 0FD6 90 SWAP1 0FD7 50 POP 0FD8 80 DUP1 0FD9 60 PUSH1 0x01 0FDB 60 PUSH1 0x01 0FDD 60 PUSH1 0xa0 0FDF 1B SHL 0FE0 03 SUB 0FE1 16 AND 0FE2 84 DUP5 0FE3 60 PUSH1 0x01 0FE5 60 PUSH1 0x01 0FE7 60 PUSH1 0xa0 0FE9 1B SHL 0FEA 03 SUB 0FEB 16 AND 0FEC 14 EQ 0FED 80 DUP1 0FEE 61 PUSH2 0x1010 0FF1 57 *JUMPI 0FF2 50 POP 0FF3 83 DUP4 0FF4 60 PUSH1 0x01 0FF6 60 PUSH1 0x01 0FF8 60 PUSH1 0xa0 0FFA 1B SHL 0FFB 03 SUB 0FFC 16 AND 0FFD 61 PUSH2 0x1005 1000 84 DUP5 1001 61 PUSH2 0x0524 1004 56 *JUMP 1005 5B JUMPDEST 1006 60 PUSH1 0x01 1008 60 PUSH1 0x01 100A 60 PUSH1 0xa0 100C 1B SHL 100D 03 SUB 100E 16 AND 100F 14 EQ 1010 5B JUMPDEST 1011 80 DUP1 1012 61 PUSH2 0x1020 1015 57 *JUMPI 1016 50 POP 1017 61 PUSH2 0x1020 101A 81 DUP2 101B 85 DUP6 101C 61 PUSH2 0x0eb2 101F 56 *JUMP label_1020: // Incoming return from call to 0x2024 at 0x22B3 // Inputs[3] // { // @1021 stack[-6] // @1021 stack[-1] // @1022 stack[-5] // } 1020 5B JUMPDEST 1021 94 SWAP5 1022 93 SWAP4 1023 50 POP 1024 50 POP 1025 50 POP 1026 50 POP 1027 56 *JUMP // Stack delta = -5 // Outputs[1] { @1021 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 1028 5B JUMPDEST 1029 61 PUSH2 0x1033 102C 83 DUP4 102D 83 DUP4 102E 83 DUP4 102F 61 PUSH2 0x15a2 1032 56 *JUMP 1033 5B JUMPDEST 1034 61 PUSH2 0x103d 1037 83 DUP4 1038 82 DUP3 1039 61 PUSH2 0x16a8 103C 56 *JUMP 103D 5B JUMPDEST 103E 61 PUSH2 0x07b7 1041 82 DUP3 1042 82 DUP3 1043 61 PUSH2 0x1796 1046 56 *JUMP 1047 5B JUMPDEST 1048 61 PUSH2 0x0682 104B 61 PUSH2 0x1053 104E 82 DUP3 104F 61 PUSH2 0x08f2 1052 56 *JUMP 1053 5B JUMPDEST 1054 82 DUP3 1055 61 PUSH2 0x17d4 1058 56 *JUMP 1059 5B JUMPDEST 105A 61 PUSH2 0x1063 105D 83 DUP4 105E 83 DUP4 105F 61 PUSH2 0x17e7 1062 56 *JUMP 1063 5B JUMPDEST 1064 60 PUSH1 0x60 1066 81 DUP2 1067 51 MLOAD 1068 60 PUSH1 0x40 106A 51 MLOAD 106B 90 SWAP1 106C 80 DUP1 106D 82 DUP3 106E 52 MSTORE 106F 80 DUP1 1070 60 PUSH1 0x20 1072 02 MUL 1073 60 PUSH1 0x20 1075 01 ADD 1076 82 DUP3 1077 01 ADD 1078 60 PUSH1 0x40 107A 52 MSTORE 107B 80 DUP1 107C 15 ISZERO 107D 61 PUSH2 0x1090 1080 57 *JUMPI 1081 81 DUP2 1082 60 PUSH1 0x20 1084 01 ADD 1085 60 PUSH1 0x20 1087 82 DUP3 1088 02 MUL 1089 80 DUP1 108A 38 CODESIZE 108B 83 DUP4 108C 39 CODECOPY 108D 01 ADD 108E 90 SWAP1 108F 50 POP 1090 5B JUMPDEST 1091 50 POP 1092 90 SWAP1 1093 50 POP 1094 60 PUSH1 0x60 1096 82 DUP3 1097 51 MLOAD 1098 60 PUSH1 0x40 109A 51 MLOAD 109B 90 SWAP1 109C 80 DUP1 109D 82 DUP3 109E 52 MSTORE 109F 80 DUP1 10A0 60 PUSH1 0x20 10A2 02 MUL 10A3 60 PUSH1 0x20 10A5 01 ADD 10A6 82 DUP3 10A7 01 ADD 10A8 60 PUSH1 0x40 10AA 52 MSTORE 10AB 80 DUP1 10AC 15 ISZERO 10AD 61 PUSH2 0x10c0 10B0 57 *JUMPI 10B1 81 DUP2 10B2 60 PUSH1 0x20 10B4 01 ADD 10B5 60 PUSH1 0x20 10B7 82 DUP3 10B8 02 MUL 10B9 80 DUP1 10BA 38 CODESIZE 10BB 83 DUP4 10BC 39 CODECOPY 10BD 01 ADD 10BE 90 SWAP1 10BF 50 POP 10C0 5B JUMPDEST 10C1 50 POP 10C2 90 SWAP1 10C3 50 POP 10C4 60 PUSH1 0x00 10C6 5B JUMPDEST 10C7 83 DUP4 10C8 51 MLOAD 10C9 81 DUP2 10CA 10 LT 10CB 15 ISZERO 10CC 61 PUSH2 0x1233 10CF 57 *JUMPI 10D0 60 PUSH1 0x00 10D2 60 PUSH1 0x01 10D4 60 PUSH1 0x01 10D6 60 PUSH1 0xa0 10D8 1B SHL 10D9 03 SUB 10DA 16 AND 10DB 84 DUP5 10DC 82 DUP3 10DD 81 DUP2 10DE 51 MLOAD 10DF 81 DUP2 10E0 10 LT 10E1 61 PUSH2 0x10e6 10E4 57 *JUMPI 10E5 FE *ASSERT 10E6 5B JUMPDEST 10E7 60 PUSH1 0x20 10E9 02 MUL 10EA 60 PUSH1 0x20 10EC 01 ADD 10ED 01 ADD 10EE 51 MLOAD 10EF 60 PUSH1 0x00 10F1 01 ADD 10F2 51 MLOAD 10F3 60 PUSH1 0x01 10F5 60 PUSH1 0x01 10F7 60 PUSH1 0xa0 10F9 1B SHL 10FA 03 SUB 10FB 16 AND 10FC 14 EQ 10FD 15 ISZERO 10FE 61 PUSH2 0x1119 1101 57 *JUMPI 1102 60 PUSH1 0x40 1104 51 MLOAD 1105 62 PUSH3 0x461bcd 1109 60 PUSH1 0xe5 110B 1B SHL 110C 81 DUP2 110D 52 MSTORE 110E 60 PUSH1 0x04 1110 01 ADD 1111 61 PUSH2 0x054b 1114 90 SWAP1 1115 61 PUSH2 0x2f85 1118 56 *JUMP 1119 5B JUMPDEST 111A 83 DUP4 111B 81 DUP2 111C 81 DUP2 111D 51 MLOAD 111E 81 DUP2 111F 10 LT 1120 61 PUSH2 0x1125 1123 57 *JUMPI 1124 FE *ASSERT 1125 5B JUMPDEST 1126 60 PUSH1 0x20 1128 02 MUL 1129 60 PUSH1 0x20 112B 01 ADD 112C 01 ADD 112D 51 MLOAD 112E 60 PUSH1 0x20 1130 01 ADD 1131 51 MLOAD 1132 60 PUSH1 0x00 1134 14 EQ 1135 15 ISZERO 1136 61 PUSH2 0x1151 1139 57 *JUMPI 113A 60 PUSH1 0x40 113C 51 MLOAD 113D 62 PUSH3 0x461bcd 1141 60 PUSH1 0xe5 1143 1B SHL 1144 81 DUP2 1145 52 MSTORE 1146 60 PUSH1 0x04 1148 01 ADD 1149 61 PUSH2 0x054b 114C 90 SWAP1 114D 61 PUSH2 0x2e05 1150 56 *JUMP 1151 5B JUMPDEST 1152 60 PUSH1 0x00 1154 85 DUP6 1155 81 DUP2 1156 52 MSTORE 1157 60 PUSH1 0x0f 1159 60 PUSH1 0x20 115B 52 MSTORE 115C 60 PUSH1 0x40 115E 90 SWAP1 115F 20 SHA3 1160 84 DUP5 1161 51 MLOAD 1162 85 DUP6 1163 90 SWAP1 1164 83 DUP4 1165 90 SWAP1 1166 81 DUP2 1167 10 LT 1168 61 PUSH2 0x116d 116B 57 *JUMPI 116C FE *ASSERT 116D 5B JUMPDEST 116E 60 PUSH1 0x20 1170 90 SWAP1 1171 81 DUP2 1172 02 MUL 1173 91 SWAP2 1174 90 SWAP1 1175 91 SWAP2 1176 01 ADD 1177 81 DUP2 1178 01 ADD 1179 51 MLOAD 117A 82 DUP3 117B 54 SLOAD 117C 60 PUSH1 0x01 117E 80 DUP1 117F 82 DUP3 1180 01 ADD 1181 85 DUP6 1182 55 SSTORE 1183 60 PUSH1 0x00 1185 94 SWAP5 1186 85 DUP6 1187 52 MSTORE 1188 93 SWAP4 1189 83 DUP4 118A 90 SWAP1 118B 20 SHA3 118C 82 DUP3 118D 51 MLOAD 118E 60 PUSH1 0x02 1190 90 SWAP1 1191 92 SWAP3 1192 02 MUL 1193 01 ADD 1194 80 DUP1 1195 54 SLOAD 1196 60 PUSH1 0x01 1198 60 PUSH1 0x01 119A 60 PUSH1 0xa0 119C 1B SHL 119D 03 SUB 119E 19 NOT 119F 16 AND 11A0 60 PUSH1 0x01 11A2 60 PUSH1 0x01 11A4 60 PUSH1 0xa0 11A6 1B SHL 11A7 03 SUB 11A8 90 SWAP1 11A9 92 SWAP3 11AA 16 AND 11AB 91 SWAP2 11AC 90 SWAP1 11AD 91 SWAP2 11AE 17 OR 11AF 81 DUP2 11B0 55 SSTORE 11B1 91 SWAP2 11B2 01 ADD 11B3 51 MLOAD 11B4 91 SWAP2 11B5 01 ADD 11B6 55 SSTORE 11B7 83 DUP4 11B8 51 MLOAD 11B9 84 DUP5 11BA 90 SWAP1 11BB 82 DUP3 11BC 90 SWAP1 11BD 81 DUP2 11BE 10 LT 11BF 61 PUSH2 0x11c4 11C2 57 *JUMPI 11C3 FE *ASSERT 11C4 5B JUMPDEST 11C5 60 PUSH1 0x20 11C7 02 MUL 11C8 60 PUSH1 0x20 11CA 01 ADD 11CB 01 ADD 11CC 51 MLOAD 11CD 60 PUSH1 0x00 11CF 01 ADD 11D0 51 MLOAD 11D1 83 DUP4 11D2 82 DUP3 11D3 81 DUP2 11D4 51 MLOAD 11D5 81 DUP2 11D6 10 LT 11D7 61 PUSH2 0x11dc 11DA 57 *JUMPI 11DB FE *ASSERT 11DC 5B JUMPDEST 11DD 60 PUSH1 0x20 11DF 02 MUL 11E0 60 PUSH1 0x20 11E2 01 ADD 11E3 01 ADD 11E4 90 SWAP1 11E5 60 PUSH1 0x01 11E7 60 PUSH1 0x01 11E9 60 PUSH1 0xa0 11EB 1B SHL 11EC 03 SUB 11ED 16 AND 11EE 90 SWAP1 11EF 81 DUP2 11F0 60 PUSH1 0x01 11F2 60 PUSH1 0x01 11F4 60 PUSH1 0xa0 11F6 1B SHL 11F7 03 SUB 11F8 16 AND 11F9 81 DUP2 11FA 52 MSTORE 11FB 50 POP 11FC 50 POP 11FD 83 DUP4 11FE 81 DUP2 11FF 81 DUP2 1200 51 MLOAD 1201 81 DUP2 1202 10 LT 1203 61 PUSH2 0x1208 1206 57 *JUMPI 1207 FE *ASSERT 1208 5B JUMPDEST 1209 60 PUSH1 0x20 120B 02 MUL 120C 60 PUSH1 0x20 120E 01 ADD 120F 01 ADD 1210 51 MLOAD 1211 60 PUSH1 0x20 1213 01 ADD 1214 51 MLOAD 1215 82 DUP3 1216 82 DUP3 1217 81 DUP2 1218 51 MLOAD 1219 81 DUP2 121A 10 LT 121B 61 PUSH2 0x1220 121E 57 *JUMPI 121F FE *ASSERT 1220 5B JUMPDEST 1221 60 PUSH1 0x20 1223 90 SWAP1 1224 81 DUP2 1225 02 MUL 1226 91 SWAP2 1227 90 SWAP1 1228 91 SWAP2 1229 01 ADD 122A 01 ADD 122B 52 MSTORE 122C 60 PUSH1 0x01 122E 01 ADD 122F 61 PUSH2 0x10c6 1232 56 *JUMP 1233 5B JUMPDEST 1234 50 POP 1235 82 DUP3 1236 51 MLOAD 1237 15 ISZERO 1238 61 PUSH2 0x1277 123B 57 *JUMPI 123C 7F PUSH32 0x99aba1d63749cfd5ad1afda7c4663840924d54eb5f005bbbeadedc6ec13674b2 125D 84 DUP5 125E 83 DUP4 125F 83 DUP4 1260 60 PUSH1 0x40 1262 51 MLOAD 1263 61 PUSH2 0x126e 1266 93 SWAP4 1267 92 SWAP3 1268 91 SWAP2 1269 90 SWAP1 126A 61 PUSH2 0x2fc3 126D 56 *JUMP 126E 5B JUMPDEST 126F 60 PUSH1 0x40 1271 51 MLOAD 1272 80 DUP1 1273 91 SWAP2 1274 03 SUB 1275 90 SWAP1 1276 A1 LOG1 1277 5B JUMPDEST 1278 50 POP 1279 50 POP 127A 50 POP 127B 50 POP 127C 50 POP 127D 56 *JUMP 127E 5B JUMPDEST 127F 61 PUSH2 0x1287 1282 82 DUP3 1283 61 PUSH2 0x0f3a 1286 56 *JUMP 1287 5B JUMPDEST 1288 61 PUSH2 0x12a3 128B 57 *JUMPI 128C 60 PUSH1 0x40 128E 51 MLOAD 128F 62 PUSH3 0x461bcd 1293 60 PUSH1 0xe5 1295 1B SHL 1296 81 DUP2 1297 52 MSTORE 1298 60 PUSH1 0x04 129A 01 ADD 129B 61 PUSH2 0x054b 129E 90 SWAP1 129F 61 PUSH2 0x2ef5 12A2 56 *JUMP 12A3 5B JUMPDEST 12A4 61 PUSH2 0x12ad 12A7 82 DUP3 12A8 82 DUP3 12A9 61 PUSH2 0x1804 12AC 56 *JUMP 12AD 5B JUMPDEST 12AE 50 POP 12AF 50 POP 12B0 56 *JUMP 12B1 5B JUMPDEST 12B2 54 SLOAD 12B3 90 SWAP1 12B4 56 *JUMP label_12B5: // Incoming call from 0x1563, returns to 0x1564 // Inputs[1] { @12C0 stack[-1] } 12B5 5B JUMPDEST 12B6 60 PUSH1 0x00 12B8 60 PUSH1 0x01 12BA 60 PUSH1 0x01 12BC 60 PUSH1 0xa0 12BE 1B SHL 12BF 03 SUB 12C0 82 DUP3 12C1 16 AND 12C2 61 PUSH2 0x12dd 12C5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12B6 stack[0] = 0x00 } // Block ends with conditional jump to 0x12dd, if stack[-1] & (0x01 << 0xa0) - 0x01 label_12C6: // Incoming jump from 0x12C5, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12C8 memory[0x40:0x60] } 12C6 60 PUSH1 0x40 12C8 51 MLOAD 12C9 62 PUSH3 0x461bcd 12CD 60 PUSH1 0xe5 12CF 1B SHL 12D0 81 DUP2 12D1 52 MSTORE 12D2 60 PUSH1 0x04 12D4 01 ADD 12D5 61 PUSH2 0x054b 12D8 90 SWAP1 12D9 61 PUSH2 0x2f15 12DC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12D8 stack[0] = 0x054b // @12D8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2f15 label_12DD: // Incoming jump from 0x12C5, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @12E7 stack[-2] // @12EF stack[-3] // @12F6 memory[0x00:0x40] // @12F7 storage[keccak256(memory[0x00:0x40])] // @12FB stack[-4] // } 12DD 5B JUMPDEST 12DE 50 POP 12DF 60 PUSH1 0x01 12E1 60 PUSH1 0x01 12E3 60 PUSH1 0xa0 12E5 1B SHL 12E6 03 SUB 12E7 16 AND 12E8 60 PUSH1 0x00 12EA 90 SWAP1 12EB 81 DUP2 12EC 52 MSTORE 12ED 60 PUSH1 0x20 12EF 91 SWAP2 12F0 90 SWAP1 12F1 91 SWAP2 12F2 52 MSTORE 12F3 60 PUSH1 0x40 12F5 90 SWAP1 12F6 20 SHA3 12F7 54 SLOAD 12F8 60 PUSH1 0xff 12FA 16 AND 12FB 90 SWAP1 12FC 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @12EC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @12F2 memory[0x20:0x40] = stack[-3] // @12FB stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_12FD: // Incoming jump from 0x0B2C // Inputs[2] // { // @12FE stack[-1] // @12FF memory[stack[-1]:stack[-1] + 0x20] // } 12FD 5B JUMPDEST 12FE 80 DUP1 12FF 51 MLOAD 1300 61 PUSH2 0x12ad 1303 90 SWAP1 1304 60 PUSH1 0x06 1306 90 SWAP1 1307 60 PUSH1 0x20 1309 84 DUP5 130A 01 ADD 130B 90 SWAP1 130C 61 PUSH2 0x1e70 130F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1303 stack[0] = 0x12ad // @1306 stack[1] = 0x06 // @130B stack[2] = stack[-1] + 0x20 // @130B stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1e70 label_1310: // Incoming jump from 0x0BB4 // Inputs[2] // { // @1311 stack[-1] // @1312 memory[stack[-1]:stack[-1] + 0x20] // } 1310 5B JUMPDEST 1311 80 DUP1 1312 51 MLOAD 1313 61 PUSH2 0x12ad 1316 90 SWAP1 1317 60 PUSH1 0x07 1319 90 SWAP1 131A 60 PUSH1 0x20 131C 84 DUP5 131D 01 ADD 131E 90 SWAP1 131F 61 PUSH2 0x1e70 1322 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1316 stack[0] = 0x12ad // @1319 stack[1] = 0x07 // @131E stack[2] = stack[-1] + 0x20 // @131E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1e70 1323 5B JUMPDEST 1324 61 PUSH2 0x132e 1327 84 DUP5 1328 84 DUP5 1329 84 DUP5 132A 61 PUSH2 0x1028 132D 56 *JUMP 132E 5B JUMPDEST 132F 61 PUSH2 0x133a 1332 84 DUP5 1333 84 DUP5 1334 84 DUP5 1335 84 DUP5 1336 61 PUSH2 0x1823 1339 56 *JUMP 133A 5B JUMPDEST 133B 61 PUSH2 0x0cbc 133E 57 *JUMPI 133F 60 PUSH1 0x40 1341 51 MLOAD 1342 62 PUSH3 0x461bcd 1346 60 PUSH1 0xe5 1348 1B SHL 1349 81 DUP2 134A 52 MSTORE 134B 60 PUSH1 0x04 134D 01 ADD 134E 61 PUSH2 0x054b 1351 90 SWAP1 1352 61 PUSH2 0x2e35 1355 56 *JUMP 1356 5B JUMPDEST 1357 60 PUSH1 0x00 1359 81 DUP2 135A 81 DUP2 135B 52 MSTORE 135C 60 PUSH1 0x08 135E 60 PUSH1 0x20 1360 90 SWAP1 1361 81 DUP2 1362 52 MSTORE 1363 60 PUSH1 0x40 1365 91 SWAP2 1366 82 DUP3 1367 90 SWAP1 1368 20 SHA3 1369 80 DUP1 136A 54 SLOAD 136B 83 DUP4 136C 51 MLOAD 136D 60 PUSH1 0x02 136F 60 PUSH1 0x01 1371 83 DUP4 1372 16 AND 1373 15 ISZERO 1374 61 PUSH2 0x0100 1377 02 MUL 1378 60 PUSH1 0x00 137A 19 NOT 137B 01 ADD 137C 90 SWAP1 137D 92 SWAP3 137E 16 AND 137F 91 SWAP2 1380 90 SWAP1 1381 91 SWAP2 1382 04 DIV 1383 60 PUSH1 0x1f 1385 81 DUP2 1386 01 ADD 1387 84 DUP5 1388 90 SWAP1 1389 04 DIV 138A 84 DUP5 138B 02 MUL 138C 82 DUP3 138D 01 ADD 138E 84 DUP5 138F 01 ADD 1390 90 SWAP1 1391 94 SWAP5 1392 52 MSTORE 1393 83 DUP4 1394 81 DUP2 1395 52 MSTORE 1396 60 PUSH1 0x60 1398 93 SWAP4 1399 61 PUSH2 0x0817 139C 93 SWAP4 139D 91 SWAP2 139E 92 SWAP3 139F 91 SWAP2 13A0 83 DUP4 13A1 01 ADD 13A2 82 DUP3 13A3 82 DUP3 13A4 80 DUP1 13A5 15 ISZERO 13A6 61 PUSH2 0x13f0 13A9 57 *JUMPI 13AA 80 DUP1 13AB 60 PUSH1 0x1f 13AD 10 LT 13AE 61 PUSH2 0x13c5 13B1 57 *JUMPI 13B2 61 PUSH2 0x0100 13B5 80 DUP1 13B6 83 DUP4 13B7 54 SLOAD 13B8 04 DIV 13B9 02 MUL 13BA 83 DUP4 13BB 52 MSTORE 13BC 91 SWAP2 13BD 60 PUSH1 0x20 13BF 01 ADD 13C0 91 SWAP2 13C1 61 PUSH2 0x13f0 13C4 56 *JUMP 13C5 5B JUMPDEST 13C6 82 DUP3 13C7 01 ADD 13C8 91 SWAP2 13C9 90 SWAP1 13CA 60 PUSH1 0x00 13CC 52 MSTORE 13CD 60 PUSH1 0x20 13CF 60 PUSH1 0x00 13D1 20 SHA3 13D2 90 SWAP1 13D3 5B JUMPDEST 13D4 81 DUP2 13D5 54 SLOAD 13D6 81 DUP2 13D7 52 MSTORE 13D8 90 SWAP1 13D9 60 PUSH1 0x01 13DB 01 ADD 13DC 90 SWAP1 13DD 60 PUSH1 0x20 13DF 01 ADD 13E0 80 DUP1 13E1 83 DUP4 13E2 11 GT 13E3 61 PUSH2 0x13d3 13E6 57 *JUMPI 13E7 82 DUP3 13E8 90 SWAP1 13E9 03 SUB 13EA 60 PUSH1 0x1f 13EC 16 AND 13ED 82 DUP3 13EE 01 ADD 13EF 91 SWAP2 13F0 5B JUMPDEST 13F1 50 POP 13F2 50 POP 13F3 60 PUSH1 0x07 13F5 80 DUP1 13F6 54 SLOAD 13F7 60 PUSH1 0x40 13F9 80 DUP1 13FA 51 MLOAD 13FB 60 PUSH1 0x20 13FD 60 PUSH1 0x1f 13FF 60 PUSH1 0x02 1401 60 PUSH1 0x00 1403 19 NOT 1404 61 PUSH2 0x0100 1407 60 PUSH1 0x01 1409 88 DUP9 140A 16 AND 140B 15 ISZERO 140C 02 MUL 140D 01 ADD 140E 90 SWAP1 140F 95 SWAP6 1410 16 AND 1411 94 SWAP5 1412 90 SWAP1 1413 94 SWAP5 1414 04 DIV 1415 93 SWAP4 1416 84 DUP5 1417 01 ADD 1418 81 DUP2 1419 90 SWAP1 141A 04 DIV 141B 81 DUP2 141C 02 MUL 141D 82 DUP3 141E 01 ADD 141F 81 DUP2 1420 01 ADD 1421 90 SWAP1 1422 92 SWAP3 1423 52 MSTORE 1424 82 DUP3 1425 81 DUP2 1426 52 MSTORE 1427 95 SWAP6 1428 50 POP 1429 91 SWAP2 142A 93 SWAP4 142B 50 POP 142C 91 SWAP2 142D 50 POP 142E 83 DUP4 142F 01 ADD 1430 82 DUP3 1431 82 DUP3 1432 80 DUP1 1433 15 ISZERO 1434 61 PUSH2 0x147e 1437 57 *JUMPI 1438 80 DUP1 1439 60 PUSH1 0x1f 143B 10 LT 143C 61 PUSH2 0x1453 143F 57 *JUMPI 1440 61 PUSH2 0x0100 1443 80 DUP1 1444 83 DUP4 1445 54 SLOAD 1446 04 DIV 1447 02 MUL 1448 83 DUP4 1449 52 MSTORE 144A 91 SWAP2 144B 60 PUSH1 0x20 144D 01 ADD 144E 91 SWAP2 144F 61 PUSH2 0x147e 1452 56 *JUMP 1453 5B JUMPDEST 1454 82 DUP3 1455 01 ADD 1456 91 SWAP2 1457 90 SWAP1 1458 60 PUSH1 0x00 145A 52 MSTORE 145B 60 PUSH1 0x20 145D 60 PUSH1 0x00 145F 20 SHA3 1460 90 SWAP1 1461 5B JUMPDEST 1462 81 DUP2 1463 54 SLOAD 1464 81 DUP2 1465 52 MSTORE 1466 90 SWAP1 1467 60 PUSH1 0x01 1469 01 ADD 146A 90 SWAP1 146B 60 PUSH1 0x20 146D 01 ADD 146E 80 DUP1 146F 83 DUP4 1470 11 GT 1471 61 PUSH2 0x1461 1474 57 *JUMPI 1475 82 DUP3 1476 90 SWAP1 1477 03 SUB 1478 60 PUSH1 0x1f 147A 16 AND 147B 82 DUP3 147C 01 ADD 147D 91 SWAP2 147E 5B JUMPDEST 147F 50 POP 1480 50 POP 1481 50 POP 1482 50 POP 1483 50 POP 1484 61 PUSH2 0x195d 1487 90 SWAP1 1488 91 SWAP2 1489 90 SWAP1 148A 63 PUSH4 0xffffffff 148F 16 AND 1490 56 *JUMP 1491 5B JUMPDEST 1492 61 PUSH2 0x14a2 1495 60 PUSH1 0x10 1497 82 DUP3 1498 63 PUSH4 0xffffffff 149D 61 PUSH2 0x1a52 14A0 16 AND 14A1 56 *JUMP 14A2 5B JUMPDEST 14A3 60 PUSH1 0x40 14A5 51 MLOAD 14A6 60 PUSH1 0x01 14A8 60 PUSH1 0x01 14AA 60 PUSH1 0xa0 14AC 1B SHL 14AD 03 SUB 14AE 82 DUP3 14AF 16 AND 14B0 90 SWAP1 14B1 7F PUSH32 0x47d1c22a25bb3a5d4e481b9b1e6944c2eade3181a0a20b495ed61d35b5323f24 14D2 90 SWAP1 14D3 60 PUSH1 0x00 14D5 90 SWAP1 14D6 A2 LOG2 14D7 50 POP 14D8 56 *JUMP 14D9 5B JUMPDEST 14DA 60 PUSH1 0x01 14DC 60 PUSH1 0x01 14DE 60 PUSH1 0xa0 14E0 1B SHL 14E1 03 SUB 14E2 81 DUP2 14E3 16 AND 14E4 61 PUSH2 0x14ff 14E7 57 *JUMPI 14E8 60 PUSH1 0x40 14EA 51 MLOAD 14EB 62 PUSH3 0x461bcd 14EF 60 PUSH1 0xe5 14F1 1B SHL 14F2 81 DUP2 14F3 52 MSTORE 14F4 60 PUSH1 0x04 14F6 01 ADD 14F7 61 PUSH2 0x054b 14FA 90 SWAP1 14FB 61 PUSH2 0x2e45 14FE 56 *JUMP 14FF 5B JUMPDEST 1500 60 PUSH1 0x00 1502 80 DUP1 1503 54 SLOAD 1504 60 PUSH1 0x40 1506 51 MLOAD 1507 60 PUSH1 0x01 1509 60 PUSH1 0x01 150B 60 PUSH1 0xa0 150D 1B SHL 150E 03 SUB 150F 80 DUP1 1510 85 DUP6 1511 16 AND 1512 93 SWAP4 1513 92 SWAP3 1514 16 AND 1515 91 SWAP2 1516 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1537 91 SWAP2 1538 A3 LOG3 1539 60 PUSH1 0x00 153B 80 DUP1 153C 54 SLOAD 153D 60 PUSH1 0x01 153F 60 PUSH1 0x01 1541 60 PUSH1 0xa0 1543 1B SHL 1544 03 SUB 1545 19 NOT 1546 16 AND 1547 60 PUSH1 0x01 1549 60 PUSH1 0x01 154B 60 PUSH1 0xa0 154D 1B SHL 154E 03 SUB 154F 92 SWAP3 1550 90 SWAP1 1551 92 SWAP3 1552 16 AND 1553 91 SWAP2 1554 90 SWAP1 1555 91 SWAP2 1556 17 OR 1557 90 SWAP1 1558 55 SSTORE 1559 56 *JUMP label_155A: // Incoming call from 0x0F6B, returns to 0x0F6C // Inputs[2] // { // @155E stack[-2] // @155F stack[-1] // } 155A 5B JUMPDEST 155B 61 PUSH2 0x1564 155E 82 DUP3 155F 82 DUP3 1560 61 PUSH2 0x12b5 1563 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @155B stack[0] = 0x1564 // @155E stack[1] = stack[-2] // @155F stack[2] = stack[-1] // } // Block ends with call to 0x12b5, returns to 0x1564 label_1564: // Incoming return from call to 0x12B5 at 0x1563 // Inputs[1] { @1568 stack[-1] } 1564 5B JUMPDEST 1565 61 PUSH2 0x1580 1568 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1580, if stack[-1] label_1569: // Incoming jump from 0x1568, if not stack[-1] // Inputs[1] { @156B memory[0x40:0x60] } 1569 60 PUSH1 0x40 156B 51 MLOAD 156C 62 PUSH3 0x461bcd 1570 60 PUSH1 0xe5 1572 1B SHL 1573 81 DUP2 1574 52 MSTORE 1575 60 PUSH1 0x04 1577 01 ADD 1578 61 PUSH2 0x054b 157B 90 SWAP1 157C 61 PUSH2 0x2ec5 157F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1574 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @157B stack[0] = 0x054b // @157B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2ec5 label_1580: // Incoming jump from 0x1568, if stack[-1] // Inputs[5] // { // @1589 stack[-1] // @1591 stack[-2] // @1598 memory[0x00:0x40] // @159A storage[keccak256(memory[0x00:0x40])] // @15A1 stack[-3] // } 1580 5B JUMPDEST 1581 60 PUSH1 0x01 1583 60 PUSH1 0x01 1585 60 PUSH1 0xa0 1587 1B SHL 1588 03 SUB 1589 16 AND 158A 60 PUSH1 0x00 158C 90 SWAP1 158D 81 DUP2 158E 52 MSTORE 158F 60 PUSH1 0x20 1591 91 SWAP2 1592 90 SWAP1 1593 91 SWAP2 1594 52 MSTORE 1595 60 PUSH1 0x40 1597 90 SWAP1 1598 20 SHA3 1599 80 DUP1 159A 54 SLOAD 159B 60 PUSH1 0xff 159D 19 NOT 159E 16 AND 159F 90 SWAP1 15A0 55 SSTORE 15A1 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @158E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1594 memory[0x20:0x40] = stack[-2] // @15A0 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 15A2 5B JUMPDEST 15A3 82 DUP3 15A4 60 PUSH1 0x01 15A6 60 PUSH1 0x01 15A8 60 PUSH1 0xa0 15AA 1B SHL 15AB 03 SUB 15AC 16 AND 15AD 61 PUSH2 0x15b5 15B0 82 DUP3 15B1 61 PUSH2 0x08f2 15B4 56 *JUMP 15B5 5B JUMPDEST 15B6 60 PUSH1 0x01 15B8 60 PUSH1 0x01 15BA 60 PUSH1 0xa0 15BC 1B SHL 15BD 03 SUB 15BE 16 AND 15BF 14 EQ 15C0 61 PUSH2 0x15db 15C3 57 *JUMPI 15C4 60 PUSH1 0x40 15C6 51 MLOAD 15C7 62 PUSH3 0x461bcd 15CB 60 PUSH1 0xe5 15CD 1B SHL 15CE 81 DUP2 15CF 52 MSTORE 15D0 60 PUSH1 0x04 15D2 01 ADD 15D3 61 PUSH2 0x054b 15D6 90 SWAP1 15D7 61 PUSH2 0x2f25 15DA 56 *JUMP 15DB 5B JUMPDEST 15DC 60 PUSH1 0x01 15DE 60 PUSH1 0x01 15E0 60 PUSH1 0xa0 15E2 1B SHL 15E3 03 SUB 15E4 82 DUP3 15E5 16 AND 15E6 61 PUSH2 0x1601 15E9 57 *JUMPI 15EA 60 PUSH1 0x40 15EC 51 MLOAD 15ED 62 PUSH3 0x461bcd 15F1 60 PUSH1 0xe5 15F3 1B SHL 15F4 81 DUP2 15F5 52 MSTORE 15F6 60 PUSH1 0x04 15F8 01 ADD 15F9 61 PUSH2 0x054b 15FC 90 SWAP1 15FD 61 PUSH2 0x2e65 1600 56 *JUMP 1601 5B JUMPDEST 1602 61 PUSH2 0x160a 1605 81 DUP2 1606 61 PUSH2 0x1a9e 1609 56 *JUMP 160A 5B JUMPDEST 160B 60 PUSH1 0x01 160D 60 PUSH1 0x01 160F 60 PUSH1 0xa0 1611 1B SHL 1612 03 SUB 1613 83 DUP4 1614 16 AND 1615 60 PUSH1 0x00 1617 90 SWAP1 1618 81 DUP2 1619 52 MSTORE 161A 60 PUSH1 0x04 161C 60 PUSH1 0x20 161E 52 MSTORE 161F 60 PUSH1 0x40 1621 90 SWAP1 1622 20 SHA3 1623 61 PUSH2 0x162b 1626 90 SWAP1 1627 61 PUSH2 0x1ad9 162A 56 *JUMP 162B 5B JUMPDEST 162C 60 PUSH1 0x01 162E 60 PUSH1 0x01 1630 60 PUSH1 0xa0 1632 1B SHL 1633 03 SUB 1634 82 DUP3 1635 16 AND 1636 60 PUSH1 0x00 1638 90 SWAP1 1639 81 DUP2 163A 52 MSTORE 163B 60 PUSH1 0x04 163D 60 PUSH1 0x20 163F 52 MSTORE 1640 60 PUSH1 0x40 1642 90 SWAP1 1643 20 SHA3 1644 61 PUSH2 0x164c 1647 90 SWAP1 1648 61 PUSH2 0x1af0 164B 56 *JUMP 164C 5B JUMPDEST 164D 60 PUSH1 0x00 164F 81 DUP2 1650 81 DUP2 1651 52 MSTORE 1652 60 PUSH1 0x02 1654 60 PUSH1 0x20 1656 52 MSTORE 1657 60 PUSH1 0x40 1659 80 DUP1 165A 82 DUP3 165B 20 SHA3 165C 80 DUP1 165D 54 SLOAD 165E 60 PUSH1 0x01 1660 60 PUSH1 0x01 1662 60 PUSH1 0xa0 1664 1B SHL 1665 03 SUB 1666 19 NOT 1667 16 AND 1668 60 PUSH1 0x01 166A 60 PUSH1 0x01 166C 60 PUSH1 0xa0 166E 1B SHL 166F 03 SUB 1670 86 DUP7 1671 81 DUP2 1672 16 AND 1673 91 SWAP2 1674 82 DUP3 1675 17 OR 1676 90 SWAP1 1677 92 SWAP3 1678 55 SSTORE 1679 91 SWAP2 167A 51 MLOAD 167B 84 DUP5 167C 93 SWAP4 167D 91 SWAP2 167E 87 DUP8 167F 16 AND 1680 91 SWAP2 1681 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 16A2 91 SWAP2 16A3 A4 LOG4 16A4 50 POP 16A5 50 POP 16A6 50 POP 16A7 56 *JUMP 16A8 5B JUMPDEST 16A9 60 PUSH1 0x01 16AB 60 PUSH1 0x01 16AD 60 PUSH1 0xa0 16AF 1B SHL 16B0 03 SUB 16B1 82 DUP3 16B2 16 AND 16B3 60 PUSH1 0x00 16B5 90 SWAP1 16B6 81 DUP2 16B7 52 MSTORE 16B8 60 PUSH1 0x09 16BA 60 PUSH1 0x20 16BC 52 MSTORE 16BD 60 PUSH1 0x40 16BF 81 DUP2 16C0 20 SHA3 16C1 54 SLOAD 16C2 61 PUSH2 0x16d2 16C5 90 SWAP1 16C6 60 PUSH1 0x01 16C8 63 PUSH4 0xffffffff 16CD 61 PUSH2 0x1af9 16D0 16 AND 16D1 56 *JUMP 16D2 5B JUMPDEST 16D3 60 PUSH1 0x00 16D5 83 DUP4 16D6 81 DUP2 16D7 52 MSTORE 16D8 60 PUSH1 0x0a 16DA 60 PUSH1 0x20 16DC 52 MSTORE 16DD 60 PUSH1 0x40 16DF 90 SWAP1 16E0 20 SHA3 16E1 54 SLOAD 16E2 90 SWAP1 16E3 91 SWAP2 16E4 50 POP 16E5 80 DUP1 16E6 82 DUP3 16E7 14 EQ 16E8 61 PUSH2 0x176d 16EB 57 *JUMPI 16EC 60 PUSH1 0x01 16EE 60 PUSH1 0x01 16F0 60 PUSH1 0xa0 16F2 1B SHL 16F3 03 SUB 16F4 84 DUP5 16F5 16 AND 16F6 60 PUSH1 0x00 16F8 90 SWAP1 16F9 81 DUP2 16FA 52 MSTORE 16FB 60 PUSH1 0x09 16FD 60 PUSH1 0x20 16FF 52 MSTORE 1700 60 PUSH1 0x40 1702 81 DUP2 1703 20 SHA3 1704 80 DUP1 1705 54 SLOAD 1706 84 DUP5 1707 90 SWAP1 1708 81 DUP2 1709 10 LT 170A 61 PUSH2 0x170f 170D 57 *JUMPI 170E FE *ASSERT 170F 5B JUMPDEST 1710 90 SWAP1 1711 60 PUSH1 0x00 1713 52 MSTORE 1714 60 PUSH1 0x20 1716 60 PUSH1 0x00 1718 20 SHA3 1719 01 ADD 171A 54 SLOAD 171B 90 SWAP1 171C 50 POP 171D 80 DUP1 171E 60 PUSH1 0x09 1720 60 PUSH1 0x00 1722 87 DUP8 1723 60 PUSH1 0x01 1725 60 PUSH1 0x01 1727 60 PUSH1 0xa0 1729 1B SHL 172A 03 SUB 172B 16 AND 172C 60 PUSH1 0x01 172E 60 PUSH1 0x01 1730 60 PUSH1 0xa0 1732 1B SHL 1733 03 SUB 1734 16 AND 1735 81 DUP2 1736 52 MSTORE 1737 60 PUSH1 0x20 1739 01 ADD 173A 90 SWAP1 173B 81 DUP2 173C 52 MSTORE 173D 60 PUSH1 0x20 173F 01 ADD 1740 60 PUSH1 0x00 1742 20 SHA3 1743 83 DUP4 1744 81 DUP2 1745 54 SLOAD 1746 81 DUP2 1747 10 LT 1748 61 PUSH2 0x174d 174B 57 *JUMPI 174C FE *ASSERT 174D 5B JUMPDEST 174E 60 PUSH1 0x00 1750 91 SWAP2 1751 82 DUP3 1752 52 MSTORE 1753 60 PUSH1 0x20 1755 80 DUP1 1756 83 DUP4 1757 20 SHA3 1758 90 SWAP1 1759 91 SWAP2 175A 01 ADD 175B 92 SWAP3 175C 90 SWAP1 175D 92 SWAP3 175E 55 SSTORE 175F 91 SWAP2 1760 82 DUP3 1761 52 MSTORE 1762 60 PUSH1 0x0a 1764 90 SWAP1 1765 52 MSTORE 1766 60 PUSH1 0x40 1768 90 SWAP1 1769 20 SHA3 176A 81 DUP2 176B 90 SWAP1 176C 55 SSTORE 176D 5B JUMPDEST 176E 60 PUSH1 0x01 1770 60 PUSH1 0x01 1772 60 PUSH1 0xa0 1774 1B SHL 1775 03 SUB 1776 84 DUP5 1777 16 AND 1778 60 PUSH1 0x00 177A 90 SWAP1 177B 81 DUP2 177C 52 MSTORE 177D 60 PUSH1 0x09 177F 60 PUSH1 0x20 1781 52 MSTORE 1782 60 PUSH1 0x40 1784 90 SWAP1 1785 20 SHA3 1786 80 DUP1 1787 54 SLOAD 1788 90 SWAP1 1789 61 PUSH2 0x1277 178C 90 SWAP1 178D 60 PUSH1 0x00 178F 19 NOT 1790 83 DUP4 1791 01 ADD 1792 61 PUSH2 0x1eee 1795 56 *JUMP 1796 5B JUMPDEST 1797 60 PUSH1 0x01 1799 60 PUSH1 0x01 179B 60 PUSH1 0xa0 179D 1B SHL 179E 03 SUB 179F 90 SWAP1 17A0 91 SWAP2 17A1 16 AND 17A2 60 PUSH1 0x00 17A4 90 SWAP1 17A5 81 DUP2 17A6 52 MSTORE 17A7 60 PUSH1 0x09 17A9 60 PUSH1 0x20 17AB 81 DUP2 17AC 81 DUP2 17AD 52 MSTORE 17AE 60 PUSH1 0x40 17B0 80 DUP1 17B1 84 DUP5 17B2 20 SHA3 17B3 80 DUP1 17B4 54 SLOAD 17B5 86 DUP7 17B6 86 DUP7 17B7 52 MSTORE 17B8 60 PUSH1 0x0a 17BA 84 DUP5 17BB 52 MSTORE 17BC 91 SWAP2 17BD 85 DUP6 17BE 20 SHA3 17BF 82 DUP3 17C0 90 SWAP1 17C1 55 SSTORE 17C2 92 SWAP3 17C3 82 DUP3 17C4 52 MSTORE 17C5 60 PUSH1 0x01 17C7 81 DUP2 17C8 01 ADD 17C9 83 DUP4 17CA 55 SSTORE 17CB 91 SWAP2 17CC 83 DUP4 17CD 52 MSTORE 17CE 90 SWAP1 17CF 91 SWAP2 17D0 20 SHA3 17D1 01 ADD 17D2 55 SSTORE 17D3 56 *JUMP 17D4 5B JUMPDEST 17D5 61 PUSH2 0x17de 17D8 82 DUP3 17D9 82 DUP3 17DA 61 PUSH2 0x1b42 17DD 56 *JUMP 17DE 5B JUMPDEST 17DF 61 PUSH2 0x12ad 17E2 81 DUP2 17E3 61 PUSH2 0x1b6e 17E6 56 *JUMP 17E7 5B JUMPDEST 17E8 61 PUSH2 0x17f1 17EB 82 DUP3 17EC 82 DUP3 17ED 61 PUSH2 0x1bac 17F0 56 *JUMP 17F1 5B JUMPDEST 17F2 61 PUSH2 0x17fb 17F5 82 DUP3 17F6 82 DUP3 17F7 61 PUSH2 0x1796 17FA 56 *JUMP 17FB 5B JUMPDEST 17FC 61 PUSH2 0x12ad 17FF 81 DUP2 1800 61 PUSH2 0x1c73 1803 56 *JUMP 1804 5B JUMPDEST 1805 60 PUSH1 0x00 1807 82 DUP3 1808 81 DUP2 1809 52 MSTORE 180A 60 PUSH1 0x08 180C 60 PUSH1 0x20 180E 90 SWAP1 180F 81 DUP2 1810 52 MSTORE 1811 60 PUSH1 0x40 1813 90 SWAP1 1814 91 SWAP2 1815 20 SHA3 1816 82 DUP3 1817 51 MLOAD 1818 61 PUSH2 0x07b7 181B 92 SWAP3 181C 84 DUP5 181D 01 ADD 181E 90 SWAP1 181F 61 PUSH2 0x1e70 1822 56 *JUMP 1823 5B JUMPDEST 1824 60 PUSH1 0x00 1826 61 PUSH2 0x1837 1829 84 DUP5 182A 60 PUSH1 0x01 182C 60 PUSH1 0x01 182E 60 PUSH1 0xa0 1830 1B SHL 1831 03 SUB 1832 16 AND 1833 61 PUSH2 0x1cb7 1836 56 *JUMP 1837 5B JUMPDEST 1838 61 PUSH2 0x1843 183B 57 *JUMPI 183C 50 POP 183D 60 PUSH1 0x01 183F 61 PUSH2 0x1020 1842 56 *JUMP 1843 5B JUMPDEST 1844 60 PUSH1 0x00 1846 60 PUSH1 0x60 1848 60 PUSH1 0x01 184A 60 PUSH1 0x01 184C 60 PUSH1 0xa0 184E 1B SHL 184F 03 SUB 1850 86 DUP7 1851 16 AND 1852 63 PUSH4 0x0a85bd01 1857 60 PUSH1 0xe1 1859 1B SHL 185A 61 PUSH2 0x1861 185D 61 PUSH2 0x0f57 1860 56 *JUMP 1861 5B JUMPDEST 1862 89 DUP10 1863 88 DUP9 1864 88 DUP9 1865 60 PUSH1 0x40 1867 51 MLOAD 1868 60 PUSH1 0x24 186A 01 ADD 186B 61 PUSH2 0x1877 186E 94 SWAP5 186F 93 SWAP4 1870 92 SWAP3 1871 91 SWAP2 1872 90 SWAP1 1873 61 PUSH2 0x2d27 1876 56 *JUMP 1877 5B JUMPDEST 1878 60 PUSH1 0x40 187A 80 DUP1 187B 51 MLOAD 187C 60 PUSH1 0x1f 187E 19 NOT 187F 81 DUP2 1880 84 DUP5 1881 03 SUB 1882 01 ADD 1883 81 DUP2 1884 52 MSTORE 1885 91 SWAP2 1886 81 DUP2 1887 52 MSTORE 1888 60 PUSH1 0x20 188A 82 DUP3 188B 01 ADD 188C 80 DUP1 188D 51 MLOAD 188E 60 PUSH1 0x01 1890 60 PUSH1 0x01 1892 60 PUSH1 0xe0 1894 1B SHL 1895 03 SUB 1896 16 AND 1897 60 PUSH1 0x01 1899 60 PUSH1 0x01 189B 60 PUSH1 0xe0 189D 1B SHL 189E 03 SUB 189F 19 NOT 18A0 90 SWAP1 18A1 94 SWAP5 18A2 16 AND 18A3 93 SWAP4 18A4 90 SWAP1 18A5 93 SWAP4 18A6 17 OR 18A7 90 SWAP1 18A8 92 SWAP3 18A9 52 MSTORE 18AA 90 SWAP1 18AB 51 MLOAD 18AC 61 PUSH2 0x18b5 18AF 91 SWAP2 18B0 90 SWAP1 18B1 61 PUSH2 0x2ce7 18B4 56 *JUMP 18B5 5B JUMPDEST 18B6 60 PUSH1 0x00 18B8 60 PUSH1 0x40 18BA 51 MLOAD 18BB 80 DUP1 18BC 83 DUP4 18BD 03 SUB 18BE 81 DUP2 18BF 60 PUSH1 0x00 18C1 86 DUP7 18C2 5A GAS 18C3 F1 CALL 18C4 91 SWAP2 18C5 50 POP 18C6 50 POP 18C7 3D RETURNDATASIZE 18C8 80 DUP1 18C9 60 PUSH1 0x00 18CB 81 DUP2 18CC 14 EQ 18CD 61 PUSH2 0x18f2 18D0 57 *JUMPI 18D1 60 PUSH1 0x40 18D3 51 MLOAD 18D4 91 SWAP2 18D5 50 POP 18D6 60 PUSH1 0x1f 18D8 19 NOT 18D9 60 PUSH1 0x3f 18DB 3D RETURNDATASIZE 18DC 01 ADD 18DD 16 AND 18DE 82 DUP3 18DF 01 ADD 18E0 60 PUSH1 0x40 18E2 52 MSTORE 18E3 3D RETURNDATASIZE 18E4 82 DUP3 18E5 52 MSTORE 18E6 3D RETURNDATASIZE 18E7 60 PUSH1 0x00 18E9 60 PUSH1 0x20 18EB 84 DUP5 18EC 01 ADD 18ED 3E RETURNDATACOPY 18EE 61 PUSH2 0x18f7 18F1 56 *JUMP 18F2 5B JUMPDEST 18F3 60 PUSH1 0x60 18F5 91 SWAP2 18F6 50 POP 18F7 5B JUMPDEST 18F8 50 POP 18F9 91 SWAP2 18FA 50 POP 18FB 91 SWAP2 18FC 50 POP 18FD 81 DUP2 18FE 61 PUSH2 0x1929 1901 57 *JUMPI 1902 80 DUP1 1903 51 MLOAD 1904 15 ISZERO 1905 61 PUSH2 0x1911 1908 57 *JUMPI 1909 80 DUP1 190A 51 MLOAD 190B 80 DUP1 190C 82 DUP3 190D 60 PUSH1 0x20 190F 01 ADD 1910 FD *REVERT 1911 5B JUMPDEST 1912 60 PUSH1 0x40 1914 51 MLOAD 1915 62 PUSH3 0x461bcd 1919 60 PUSH1 0xe5 191B 1B SHL 191C 81 DUP2 191D 52 MSTORE 191E 60 PUSH1 0x04 1920 01 ADD 1921 61 PUSH2 0x054b 1924 90 SWAP1 1925 61 PUSH2 0x2e35 1928 56 *JUMP 1929 5B JUMPDEST 192A 60 PUSH1 0x00 192C 81 DUP2 192D 80 DUP1 192E 60 PUSH1 0x20 1930 01 ADD 1931 90 SWAP1 1932 51 MLOAD 1933 61 PUSH2 0x193f 1936 91 SWAP2 1937 90 SWAP1 1938 81 DUP2 1939 01 ADD 193A 90 SWAP1 193B 61 PUSH2 0x2261 193E 56 *JUMP 193F 5B JUMPDEST 1940 60 PUSH1 0x01 1942 60 PUSH1 0x01 1944 60 PUSH1 0xe0 1946 1B SHL 1947 03 SUB 1948 19 NOT 1949 16 AND 194A 63 PUSH4 0x0a85bd01 194F 60 PUSH1 0xe1 1951 1B SHL 1952 14 EQ 1953 93 SWAP4 1954 50 POP 1955 61 PUSH2 0x1020 1958 92 SWAP3 1959 50 POP 195A 50 POP 195B 50 POP 195C 56 *JUMP 195D 5B JUMPDEST 195E 60 PUSH1 0x60 1960 80 DUP1 1961 83 DUP4 1962 90 SWAP1 1963 50 POP 1964 60 PUSH1 0x60 1966 83 DUP4 1967 90 SWAP1 1968 50 POP 1969 60 PUSH1 0x60 196B 81 DUP2 196C 51 MLOAD 196D 83 DUP4 196E 51 MLOAD 196F 01 ADD 1970 60 PUSH1 0x40 1972 51 MLOAD 1973 90 SWAP1 1974 80 DUP1 1975 82 DUP3 1976 52 MSTORE 1977 80 DUP1 1978 60 PUSH1 0x1f 197A 01 ADD 197B 60 PUSH1 0x1f 197D 19 NOT 197E 16 AND 197F 60 PUSH1 0x20 1981 01 ADD 1982 82 DUP3 1983 01 ADD 1984 60 PUSH1 0x40 1986 52 MSTORE 1987 80 DUP1 1988 15 ISZERO 1989 61 PUSH2 0x1999 198C 57 *JUMPI 198D 60 PUSH1 0x20 198F 82 DUP3 1990 01 ADD 1991 81 DUP2 1992 80 DUP1 1993 38 CODESIZE 1994 83 DUP4 1995 39 CODECOPY 1996 01 ADD 1997 90 SWAP1 1998 50 POP 1999 5B JUMPDEST 199A 50 POP 199B 90 SWAP1 199C 50 POP 199D 60 PUSH1 0x00 199F 80 DUP1 19A0 5B JUMPDEST 19A1 84 DUP5 19A2 51 MLOAD 19A3 81 DUP2 19A4 10 LT 19A5 15 ISZERO 19A6 61 PUSH2 0x19f1 19A9 57 *JUMPI 19AA 84 DUP5 19AB 81 DUP2 19AC 81 DUP2 19AD 51 MLOAD 19AE 81 DUP2 19AF 10 LT 19B0 61 PUSH2 0x19b5 19B3 57 *JUMPI 19B4 FE *ASSERT 19B5 5B JUMPDEST 19B6 60 PUSH1 0x20 19B8 01 ADD 19B9 01 ADD 19BA 51 MLOAD 19BB 60 PUSH1 0xf8 19BD 1C SHR 19BE 60 PUSH1 0xf8 19C0 1B SHL 19C1 83 DUP4 19C2 83 DUP4 19C3 80 DUP1 19C4 60 PUSH1 0x01 19C6 01 ADD 19C7 94 SWAP5 19C8 50 POP 19C9 81 DUP2 19CA 51 MLOAD 19CB 81 DUP2 19CC 10 LT 19CD 61 PUSH2 0x19d2 19D0 57 *JUMPI 19D1 FE *ASSERT 19D2 5B JUMPDEST 19D3 60 PUSH1 0x20 19D5 01 ADD 19D6 01 ADD 19D7 90 SWAP1 19D8 60 PUSH1 0x01 19DA 60 PUSH1 0x01 19DC 60 PUSH1 0xf8 19DE 1B SHL 19DF 03 SUB 19E0 19 NOT 19E1 16 AND 19E2 90 SWAP1 19E3 81 DUP2 19E4 60 PUSH1 0x00 19E6 1A BYTE 19E7 90 SWAP1 19E8 53 MSTORE8 19E9 50 POP 19EA 60 PUSH1 0x01 19EC 01 ADD 19ED 61 PUSH2 0x19a0 19F0 56 *JUMP 19F1 5B JUMPDEST 19F2 50 POP 19F3 60 PUSH1 0x00 19F5 5B JUMPDEST 19F6 83 DUP4 19F7 51 MLOAD 19F8 81 DUP2 19F9 10 LT 19FA 15 ISZERO 19FB 61 PUSH2 0x1a46 19FE 57 *JUMPI 19FF 83 DUP4 1A00 81 DUP2 1A01 81 DUP2 1A02 51 MLOAD 1A03 81 DUP2 1A04 10 LT 1A05 61 PUSH2 0x1a0a 1A08 57 *JUMPI 1A09 FE *ASSERT 1A0A 5B JUMPDEST 1A0B 60 PUSH1 0x20 1A0D 01 ADD 1A0E 01 ADD 1A0F 51 MLOAD 1A10 60 PUSH1 0xf8 1A12 1C SHR 1A13 60 PUSH1 0xf8 1A15 1B SHL 1A16 83 DUP4 1A17 83 DUP4 1A18 80 DUP1 1A19 60 PUSH1 0x01 1A1B 01 ADD 1A1C 94 SWAP5 1A1D 50 POP 1A1E 81 DUP2 1A1F 51 MLOAD 1A20 81 DUP2 1A21 10 LT 1A22 61 PUSH2 0x1a27 1A25 57 *JUMPI 1A26 FE *ASSERT 1A27 5B JUMPDEST 1A28 60 PUSH1 0x20 1A2A 01 ADD 1A2B 01 ADD 1A2C 90 SWAP1 1A2D 60 PUSH1 0x01 1A2F 60 PUSH1 0x01 1A31 60 PUSH1 0xf8 1A33 1B SHL 1A34 03 SUB 1A35 19 NOT 1A36 16 AND 1A37 90 SWAP1 1A38 81 DUP2 1A39 60 PUSH1 0x00 1A3B 1A BYTE 1A3C 90 SWAP1 1A3D 53 MSTORE8 1A3E 50 POP 1A3F 60 PUSH1 0x01 1A41 01 ADD 1A42 61 PUSH2 0x19f5 1A45 56 *JUMP 1A46 5B JUMPDEST 1A47 50 POP 1A48 90 SWAP1 1A49 96 SWAP7 1A4A 95 SWAP6 1A4B 50 POP 1A4C 50 POP 1A4D 50 POP 1A4E 50 POP 1A4F 50 POP 1A50 50 POP 1A51 56 *JUMP 1A52 5B JUMPDEST 1A53 61 PUSH2 0x1a5c 1A56 82 DUP3 1A57 82 DUP3 1A58 61 PUSH2 0x12b5 1A5B 56 *JUMP 1A5C 5B JUMPDEST 1A5D 15 ISZERO 1A5E 61 PUSH2 0x1a79 1A61 57 *JUMPI 1A62 60 PUSH1 0x40 1A64 51 MLOAD 1A65 62 PUSH3 0x461bcd 1A69 60 PUSH1 0xe5 1A6B 1B SHL 1A6C 81 DUP2 1A6D 52 MSTORE 1A6E 60 PUSH1 0x04 1A70 01 ADD 1A71 61 PUSH2 0x054b 1A74 90 SWAP1 1A75 61 PUSH2 0x2e15 1A78 56 *JUMP 1A79 5B JUMPDEST 1A7A 60 PUSH1 0x01 1A7C 60 PUSH1 0x01 1A7E 60 PUSH1 0xa0 1A80 1B SHL 1A81 03 SUB 1A82 16 AND 1A83 60 PUSH1 0x00 1A85 90 SWAP1 1A86 81 DUP2 1A87 52 MSTORE 1A88 60 PUSH1 0x20 1A8A 91 SWAP2 1A8B 90 SWAP1 1A8C 91 SWAP2 1A8D 52 MSTORE 1A8E 60 PUSH1 0x40 1A90 90 SWAP1 1A91 20 SHA3 1A92 80 DUP1 1A93 54 SLOAD 1A94 60 PUSH1 0xff 1A96 19 NOT 1A97 16 AND 1A98 60 PUSH1 0x01 1A9A 17 OR 1A9B 90 SWAP1 1A9C 55 SSTORE 1A9D 56 *JUMP 1A9E 5B JUMPDEST 1A9F 60 PUSH1 0x00 1AA1 81 DUP2 1AA2 81 DUP2 1AA3 52 MSTORE 1AA4 60 PUSH1 0x03 1AA6 60 PUSH1 0x20 1AA8 52 MSTORE 1AA9 60 PUSH1 0x40 1AAB 90 SWAP1 1AAC 20 SHA3 1AAD 54 SLOAD 1AAE 60 PUSH1 0x01 1AB0 60 PUSH1 0x01 1AB2 60 PUSH1 0xa0 1AB4 1B SHL 1AB5 03 SUB 1AB6 16 AND 1AB7 15 ISZERO 1AB8 61 PUSH2 0x0682 1ABB 57 *JUMPI 1ABC 60 PUSH1 0x00 1ABE 90 SWAP1 1ABF 81 DUP2 1AC0 52 MSTORE 1AC1 60 PUSH1 0x03 1AC3 60 PUSH1 0x20 1AC5 52 MSTORE 1AC6 60 PUSH1 0x40 1AC8 90 SWAP1 1AC9 20 SHA3 1ACA 80 DUP1 1ACB 54 SLOAD 1ACC 60 PUSH1 0x01 1ACE 60 PUSH1 0x01 1AD0 60 PUSH1 0xa0 1AD2 1B SHL 1AD3 03 SUB 1AD4 19 NOT 1AD5 16 AND 1AD6 90 SWAP1 1AD7 55 SSTORE 1AD8 56 *JUMP 1AD9 5B JUMPDEST 1ADA 80 DUP1 1ADB 54 SLOAD 1ADC 61 PUSH2 0x1aec 1ADF 90 SWAP1 1AE0 60 PUSH1 0x01 1AE2 63 PUSH4 0xffffffff 1AE7 61 PUSH2 0x1af9 1AEA 16 AND 1AEB 56 *JUMP 1AEC 5B JUMPDEST 1AED 90 SWAP1 1AEE 55 SSTORE 1AEF 56 *JUMP 1AF0 5B JUMPDEST 1AF1 80 DUP1 1AF2 54 SLOAD 1AF3 60 PUSH1 0x01 1AF5 01 ADD 1AF6 90 SWAP1 1AF7 55 SSTORE 1AF8 56 *JUMP 1AF9 5B JUMPDEST 1AFA 60 PUSH1 0x00 1AFC 61 PUSH2 0x1b3b 1AFF 83 DUP4 1B00 83 DUP4 1B01 60 PUSH1 0x40 1B03 51 MLOAD 1B04 80 DUP1 1B05 60 PUSH1 0x40 1B07 01 ADD 1B08 60 PUSH1 0x40 1B0A 52 MSTORE 1B0B 80 DUP1 1B0C 60 PUSH1 0x1e 1B0E 81 DUP2 1B0F 52 MSTORE 1B10 60 PUSH1 0x20 1B12 01 ADD 1B13 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 1B34 81 DUP2 1B35 52 MSTORE 1B36 50 POP 1B37 61 PUSH2 0x1cf0 1B3A 56 *JUMP label_1B3B: // Incoming return from call to 0x24DE at 0x2E04 // Inputs[3] // { // @1B3C stack[-5] // @1B3C stack[-1] // @1B3D stack[-4] // } 1B3B 5B JUMPDEST 1B3C 93 SWAP4 1B3D 92 SWAP3 1B3E 50 POP 1B3F 50 POP 1B40 50 POP 1B41 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B3C stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 1B42 5B JUMPDEST 1B43 61 PUSH2 0x1b4c 1B46 82 DUP3 1B47 82 DUP3 1B48 61 PUSH2 0x1d1c 1B4B 56 *JUMP 1B4C 5B JUMPDEST 1B4D 61 PUSH2 0x1b56 1B50 82 DUP3 1B51 82 DUP3 1B52 61 PUSH2 0x16a8 1B55 56 *JUMP 1B56 5B JUMPDEST 1B57 60 PUSH1 0x00 1B59 81 DUP2 1B5A 81 DUP2 1B5B 52 MSTORE 1B5C 60 PUSH1 0x0a 1B5E 60 PUSH1 0x20 1B60 52 MSTORE 1B61 60 PUSH1 0x40 1B63 81 DUP2 1B64 20 SHA3 1B65 55 SSTORE 1B66 61 PUSH2 0x12ad 1B69 81 DUP2 1B6A 61 PUSH2 0x1dd4 1B6D 56 *JUMP 1B6E 5B JUMPDEST 1B6F 60 PUSH1 0x00 1B71 81 DUP2 1B72 81 DUP2 1B73 52 MSTORE 1B74 60 PUSH1 0x08 1B76 60 PUSH1 0x20 1B78 52 MSTORE 1B79 60 PUSH1 0x40 1B7B 90 SWAP1 1B7C 20 SHA3 1B7D 54 SLOAD 1B7E 60 PUSH1 0x02 1B80 60 PUSH1 0x00 1B82 19 NOT 1B83 61 PUSH2 0x0100 1B86 60 PUSH1 0x01 1B88 84 DUP5 1B89 16 AND 1B8A 15 ISZERO 1B8B 02 MUL 1B8C 01 ADD 1B8D 90 SWAP1 1B8E 91 SWAP2 1B8F 16 AND 1B90 04 DIV 1B91 15 ISZERO 1B92 61 PUSH2 0x0682 1B95 57 *JUMPI 1B96 60 PUSH1 0x00 1B98 81 DUP2 1B99 81 DUP2 1B9A 52 MSTORE 1B9B 60 PUSH1 0x08 1B9D 60 PUSH1 0x20 1B9F 52 MSTORE 1BA0 60 PUSH1 0x40 1BA2 81 DUP2 1BA3 20 SHA3 1BA4 61 PUSH2 0x0682 1BA7 91 SWAP2 1BA8 61 PUSH2 0x1f12 1BAB 56 *JUMP 1BAC 5B JUMPDEST 1BAD 60 PUSH1 0x01 1BAF 60 PUSH1 0x01 1BB1 60 PUSH1 0xa0 1BB3 1B SHL 1BB4 03 SUB 1BB5 82 DUP3 1BB6 16 AND 1BB7 61 PUSH2 0x1bd2 1BBA 57 *JUMPI 1BBB 60 PUSH1 0x40 1BBD 51 MLOAD 1BBE 62 PUSH3 0x461bcd 1BC2 60 PUSH1 0xe5 1BC4 1B SHL 1BC5 81 DUP2 1BC6 52 MSTORE 1BC7 60 PUSH1 0x04 1BC9 01 ADD 1BCA 61 PUSH2 0x054b 1BCD 90 SWAP1 1BCE 61 PUSH2 0x2ed5 1BD1 56 *JUMP 1BD2 5B JUMPDEST 1BD3 61 PUSH2 0x1bdb 1BD6 81 DUP2 1BD7 61 PUSH2 0x0f3a 1BDA 56 *JUMP 1BDB 5B JUMPDEST 1BDC 15 ISZERO 1BDD 61 PUSH2 0x1bf8 1BE0 57 *JUMPI 1BE1 60 PUSH1 0x40 1BE3 51 MLOAD 1BE4 62 PUSH3 0x461bcd 1BE8 60 PUSH1 0xe5 1BEA 1B SHL 1BEB 81 DUP2 1BEC 52 MSTORE 1BED 60 PUSH1 0x04 1BEF 01 ADD 1BF0 61 PUSH2 0x054b 1BF3 90 SWAP1 1BF4 61 PUSH2 0x2e55 1BF7 56 *JUMP 1BF8 5B JUMPDEST 1BF9 60 PUSH1 0x00 1BFB 81 DUP2 1BFC 81 DUP2 1BFD 52 MSTORE 1BFE 60 PUSH1 0x02 1C00 60 PUSH1 0x20 1C02 90 SWAP1 1C03 81 DUP2 1C04 52 MSTORE 1C05 60 PUSH1 0x40 1C07 80 DUP1 1C08 83 DUP4 1C09 20 SHA3 1C0A 80 DUP1 1C0B 54 SLOAD 1C0C 60 PUSH1 0x01 1C0E 60 PUSH1 0x01 1C10 60 PUSH1 0xa0 1C12 1B SHL 1C13 03 SUB 1C14 19 NOT 1C15 16 AND 1C16 60 PUSH1 0x01 1C18 60 PUSH1 0x01 1C1A 60 PUSH1 0xa0 1C1C 1B SHL 1C1D 03 SUB 1C1E 87 DUP8 1C1F 16 AND 1C20 90 SWAP1 1C21 81 DUP2 1C22 17 OR 1C23 90 SWAP1 1C24 91 SWAP2 1C25 55 SSTORE 1C26 83 DUP4 1C27 52 MSTORE 1C28 60 PUSH1 0x04 1C2A 90 SWAP1 1C2B 91 SWAP2 1C2C 52 MSTORE 1C2D 90 SWAP1 1C2E 20 SHA3 1C2F 61 PUSH2 0x1c37 1C32 90 SWAP1 1C33 61 PUSH2 0x1af0 1C36 56 *JUMP 1C37 5B JUMPDEST 1C38 60 PUSH1 0x40 1C3A 51 MLOAD 1C3B 81 DUP2 1C3C 90 SWAP1 1C3D 60 PUSH1 0x01 1C3F 60 PUSH1 0x01 1C41 60 PUSH1 0xa0 1C43 1B SHL 1C44 03 SUB 1C45 84 DUP5 1C46 16 AND 1C47 90 SWAP1 1C48 60 PUSH1 0x00 1C4A 90 SWAP1 1C4B 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1C6C 90 SWAP1 1C6D 82 DUP3 1C6E 90 SWAP1 1C6F A4 LOG4 1C70 50 POP 1C71 50 POP 1C72 56 *JUMP 1C73 5B JUMPDEST 1C74 60 PUSH1 0x0b 1C76 80 DUP1 1C77 54 SLOAD 1C78 60 PUSH1 0x00 1C7A 83 DUP4 1C7B 81 DUP2 1C7C 52 MSTORE 1C7D 60 PUSH1 0x0c 1C7F 60 PUSH1 0x20 1C81 52 MSTORE 1C82 60 PUSH1 0x40 1C84 81 DUP2 1C85 20 SHA3 1C86 82 DUP3 1C87 90 SWAP1 1C88 55 SSTORE 1C89 60 PUSH1 0x01 1C8B 82 DUP3 1C8C 01 ADD 1C8D 83 DUP4 1C8E 55 SSTORE 1C8F 91 SWAP2 1C90 90 SWAP1 1C91 91 SWAP2 1C92 52 MSTORE 1C93 7F PUSH32 0x0175b7a638427703f0dbe7bb9bbf987a2551717b34e79f33b5b1008d1fa01db9 1CB4 01 ADD 1CB5 55 SSTORE 1CB6 56 *JUMP 1CB7 5B JUMPDEST 1CB8 60 PUSH1 0x00 1CBA 81 DUP2 1CBB 3F EXTCODEHASH 1CBC 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 1CDD 81 DUP2 1CDE 81 DUP2 1CDF 14 EQ 1CE0 80 DUP1 1CE1 15 ISZERO 1CE2 90 SWAP1 1CE3 61 PUSH2 0x1020 1CE6 57 *JUMPI 1CE7 50 POP 1CE8 50 POP 1CE9 15 ISZERO 1CEA 15 ISZERO 1CEB 92 SWAP3 1CEC 91 SWAP2 1CED 50 POP 1CEE 50 POP 1CEF 56 *JUMP 1CF0 5B JUMPDEST 1CF1 60 PUSH1 0x00 1CF3 81 DUP2 1CF4 84 DUP5 1CF5 84 DUP5 1CF6 11 GT 1CF7 15 ISZERO 1CF8 61 PUSH2 0x1d14 1CFB 57 *JUMPI 1CFC 60 PUSH1 0x40 1CFE 51 MLOAD 1CFF 62 PUSH3 0x461bcd 1D03 60 PUSH1 0xe5 1D05 1B SHL 1D06 81 DUP2 1D07 52 MSTORE 1D08 60 PUSH1 0x04 1D0A 01 ADD 1D0B 61 PUSH2 0x054b 1D0E 91 SWAP2 1D0F 90 SWAP1 1D10 61 PUSH2 0x2df4 1D13 56 *JUMP 1D14 5B JUMPDEST 1D15 50 POP 1D16 50 POP 1D17 50 POP 1D18 90 SWAP1 1D19 03 SUB 1D1A 90 SWAP1 1D1B 56 *JUMP 1D1C 5B JUMPDEST 1D1D 81 DUP2 1D1E 60 PUSH1 0x01 1D20 60 PUSH1 0x01 1D22 60 PUSH1 0xa0 1D24 1B SHL 1D25 03 SUB 1D26 16 AND 1D27 61 PUSH2 0x1d2f 1D2A 82 DUP3 1D2B 61 PUSH2 0x08f2 1D2E 56 *JUMP 1D2F 5B JUMPDEST 1D30 60 PUSH1 0x01 1D32 60 PUSH1 0x01 1D34 60 PUSH1 0xa0 1D36 1B SHL 1D37 03 SUB 1D38 16 AND 1D39 14 EQ 1D3A 61 PUSH2 0x1d55 1D3D 57 *JUMPI 1D3E 60 PUSH1 0x40 1D40 51 MLOAD 1D41 62 PUSH3 0x461bcd 1D45 60 PUSH1 0xe5 1D47 1B SHL 1D48 81 DUP2 1D49 52 MSTORE 1D4A 60 PUSH1 0x04 1D4C 01 ADD 1D4D 61 PUSH2 0x054b 1D50 90 SWAP1 1D51 61 PUSH2 0x2f75 1D54 56 *JUMP 1D55 5B JUMPDEST 1D56 61 PUSH2 0x1d5e 1D59 81 DUP2 1D5A 61 PUSH2 0x1a9e 1D5D 56 *JUMP 1D5E 5B JUMPDEST 1D5F 60 PUSH1 0x01 1D61 60 PUSH1 0x01 1D63 60 PUSH1 0xa0 1D65 1B SHL 1D66 03 SUB 1D67 82 DUP3 1D68 16 AND 1D69 60 PUSH1 0x00 1D6B 90 SWAP1 1D6C 81 DUP2 1D6D 52 MSTORE 1D6E 60 PUSH1 0x04 1D70 60 PUSH1 0x20 1D72 52 MSTORE 1D73 60 PUSH1 0x40 1D75 90 SWAP1 1D76 20 SHA3 1D77 61 PUSH2 0x1d7f 1D7A 90 SWAP1 1D7B 61 PUSH2 0x1ad9 1D7E 56 *JUMP 1D7F 5B JUMPDEST 1D80 60 PUSH1 0x00 1D82 81 DUP2 1D83 81 DUP2 1D84 52 MSTORE 1D85 60 PUSH1 0x02 1D87 60 PUSH1 0x20 1D89 52 MSTORE 1D8A 60 PUSH1 0x40 1D8C 80 DUP1 1D8D 82 DUP3 1D8E 20 SHA3 1D8F 80 DUP1 1D90 54 SLOAD 1D91 60 PUSH1 0x01 1D93 60 PUSH1 0x01 1D95 60 PUSH1 0xa0 1D97 1B SHL 1D98 03 SUB 1D99 19 NOT 1D9A 16 AND 1D9B 90 SWAP1 1D9C 55 SSTORE 1D9D 51 MLOAD 1D9E 82 DUP3 1D9F 91 SWAP2 1DA0 90 SWAP1 1DA1 60 PUSH1 0x01 1DA3 60 PUSH1 0x01 1DA5 60 PUSH1 0xa0 1DA7 1B SHL 1DA8 03 SUB 1DA9 85 DUP6 1DAA 16 AND 1DAB 90 SWAP1 1DAC 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1DCD 90 SWAP1 1DCE 83 DUP4 1DCF 90 SWAP1 1DD0 A4 LOG4 1DD1 50 POP 1DD2 50 POP 1DD3 56 *JUMP 1DD4 5B JUMPDEST 1DD5 60 PUSH1 0x0b 1DD7 54 SLOAD 1DD8 60 PUSH1 0x00 1DDA 90 SWAP1 1DDB 61 PUSH2 0x1deb 1DDE 90 SWAP1 1DDF 60 PUSH1 0x01 1DE1 63 PUSH4 0xffffffff 1DE6 61 PUSH2 0x1af9 1DE9 16 AND 1DEA 56 *JUMP 1DEB 5B JUMPDEST 1DEC 60 PUSH1 0x00 1DEE 83 DUP4 1DEF 81 DUP2 1DF0 52 MSTORE 1DF1 60 PUSH1 0x0c 1DF3 60 PUSH1 0x20 1DF5 52 MSTORE 1DF6 60 PUSH1 0x40 1DF8 81 DUP2 1DF9 20 SHA3 1DFA 54 SLOAD 1DFB 60 PUSH1 0x0b 1DFD 80 DUP1 1DFE 54 SLOAD 1DFF 93 SWAP4 1E00 94 SWAP5 1E01 50 POP 1E02 90 SWAP1 1E03 92 SWAP3 1E04 84 DUP5 1E05 90 SWAP1 1E06 81 DUP2 1E07 10 LT 1E08 61 PUSH2 0x1e0d 1E0B 57 *JUMPI 1E0C FE *ASSERT 1E0D 5B JUMPDEST 1E0E 90 SWAP1 1E0F 60 PUSH1 0x00 1E11 52 MSTORE 1E12 60 PUSH1 0x20 1E14 60 PUSH1 0x00 1E16 20 SHA3 1E17 01 ADD 1E18 54 SLOAD 1E19 90 SWAP1 1E1A 50 POP 1E1B 80 DUP1 1E1C 60 PUSH1 0x0b 1E1E 83 DUP4 1E1F 81 DUP2 1E20 54 SLOAD 1E21 81 DUP2 1E22 10 LT 1E23 61 PUSH2 0x1e28 1E26 57 *JUMPI 1E27 FE *ASSERT 1E28 5B JUMPDEST 1E29 60 PUSH1 0x00 1E2B 91 SWAP2 1E2C 82 DUP3 1E2D 52 MSTORE 1E2E 60 PUSH1 0x20 1E30 80 DUP1 1E31 83 DUP4 1E32 20 SHA3 1E33 90 SWAP1 1E34 91 SWAP2 1E35 01 ADD 1E36 92 SWAP3 1E37 90 SWAP1 1E38 92 SWAP3 1E39 55 SSTORE 1E3A 82 DUP3 1E3B 81 DUP2 1E3C 52 MSTORE 1E3D 60 PUSH1 0x0c 1E3F 90 SWAP1 1E40 91 SWAP2 1E41 52 MSTORE 1E42 60 PUSH1 0x40 1E44 90 SWAP1 1E45 20 SHA3 1E46 82 DUP3 1E47 90 SWAP1 1E48 55 SSTORE 1E49 60 PUSH1 0x0b 1E4B 80 DUP1 1E4C 54 SLOAD 1E4D 90 SWAP1 1E4E 61 PUSH2 0x1e5b 1E51 90 SWAP1 1E52 60 PUSH1 0x00 1E54 19 NOT 1E55 83 DUP4 1E56 01 ADD 1E57 61 PUSH2 0x1eee 1E5A 56 *JUMP 1E5B 5B JUMPDEST 1E5C 50 POP 1E5D 50 POP 1E5E 50 POP 1E5F 60 PUSH1 0x00 1E61 91 SWAP2 1E62 82 DUP3 1E63 52 MSTORE 1E64 50 POP 1E65 60 PUSH1 0x0c 1E67 60 PUSH1 0x20 1E69 52 MSTORE 1E6A 60 PUSH1 0x40 1E6C 81 DUP2 1E6D 20 SHA3 1E6E 55 SSTORE 1E6F 56 *JUMP label_1E70: // Incoming jump from 0x1322 // Incoming jump from 0x130F // Inputs[5] // { // @1E71 stack[-3] // @1E73 storage[stack[-3]] // @1E8D memory[0x00:0x20] // @1E98 stack[-2] // @1E99 stack[-1] // } 1E70 5B JUMPDEST 1E71 82 DUP3 1E72 80 DUP1 1E73 54 SLOAD 1E74 60 PUSH1 0x01 1E76 81 DUP2 1E77 60 PUSH1 0x01 1E79 16 AND 1E7A 15 ISZERO 1E7B 61 PUSH2 0x0100 1E7E 02 MUL 1E7F 03 SUB 1E80 16 AND 1E81 60 PUSH1 0x02 1E83 90 SWAP1 1E84 04 DIV 1E85 90 SWAP1 1E86 60 PUSH1 0x00 1E88 52 MSTORE 1E89 60 PUSH1 0x20 1E8B 60 PUSH1 0x00 1E8D 20 SHA3 1E8E 90 SWAP1 1E8F 60 PUSH1 0x1f 1E91 01 ADD 1E92 60 PUSH1 0x20 1E94 90 SWAP1 1E95 04 DIV 1E96 81 DUP2 1E97 01 ADD 1E98 92 SWAP3 1E99 82 DUP3 1E9A 60 PUSH1 0x1f 1E9C 10 LT 1E9D 61 PUSH2 0x1eb1 1EA0 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1E88 memory[0x00:0x20] = stack[-3] // @1E8E stack[0] = keccak256(memory[0x00:0x20]) // @1E98 stack[1] = stack[-2] // @1E98 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x1eb1, if 0x1f < stack[-1] label_1EA1: // Incoming jump from 0x1EA0, if not 0x1f < stack[-1] // Inputs[4] // { // @1EA1 stack[-1] // @1EA2 memory[stack[-1]:stack[-1] + 0x20] // @1EA7 stack[-3] // @1EAB stack[-5] // } 1EA1 80 DUP1 1EA2 51 MLOAD 1EA3 60 PUSH1 0xff 1EA5 19 NOT 1EA6 16 AND 1EA7 83 DUP4 1EA8 80 DUP1 1EA9 01 ADD 1EAA 17 OR 1EAB 85 DUP6 1EAC 55 SSTORE 1EAD 61 PUSH2 0x1ede 1EB0 56 *JUMP // Stack delta = +0 // Outputs[1] { @1EAC storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1ede label_1EB1: // Incoming jump from 0x1EA0, if 0x1f < stack[-1] // Inputs[2] // { // @1EB2 stack[-3] // @1EB8 stack[-5] // } 1EB1 5B JUMPDEST 1EB2 82 DUP3 1EB3 80 DUP1 1EB4 01 ADD 1EB5 60 PUSH1 0x01 1EB7 01 ADD 1EB8 85 DUP6 1EB9 55 SSTORE 1EBA 82 DUP3 1EBB 15 ISZERO 1EBC 61 PUSH2 0x1ede 1EBF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1EB9 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1ede, if !stack[-3] label_1EC0: // Incoming jump from 0x1EBF, if not !stack[-3] // Inputs[2] // { // @1EC0 stack[-3] // @1EC0 stack[-1] // } 1EC0 91 SWAP2 1EC1 82 DUP3 1EC2 01 ADD 1EC3 5B JUMPDEST 1EC4 82 DUP3 1EC5 81 DUP2 1EC6 11 GT 1EC7 15 ISZERO 1EC8 61 PUSH2 0x1ede 1ECB 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1EC0 stack[-3] = stack[-1] // @1EC2 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1ede, if !(stack[-1] + stack[-3] > stack[-1]) label_1ECC: // Incoming jump from 0x1ECB, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1ECB, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @1ECC stack[-3] // @1ECD memory[stack[-3]:stack[-3] + 0x20] // @1ECE stack[-2] // @1ED0 stack[-1] // } 1ECC 82 DUP3 1ECD 51 MLOAD 1ECE 82 DUP3 1ECF 55 SSTORE 1ED0 91 SWAP2 1ED1 60 PUSH1 0x20 1ED3 01 ADD 1ED4 91 SWAP2 1ED5 90 SWAP1 1ED6 60 PUSH1 0x01 1ED8 01 ADD 1ED9 90 SWAP1 1EDA 61 PUSH2 0x1ec3 1EDD 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1ECF storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1ED4 stack[-3] = 0x20 + stack[-3] // @1ED9 stack[-2] = 0x01 + stack[-2] // @1ED9 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1ec3 label_1EDE: // Incoming jump from 0x1ECB, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1ECB, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1EBF, if !stack[-3] // Incoming jump from 0x1EB0 // Inputs[2] // { // @1EE3 stack[-4] // @1EE4 stack[-3] // } 1EDE 5B JUMPDEST 1EDF 50 POP 1EE0 61 PUSH2 0x1eea 1EE3 92 SWAP3 1EE4 91 SWAP2 1EE5 50 POP 1EE6 61 PUSH2 0x1f52 1EE9 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1EE3 stack[-4] = 0x1eea // @1EE4 stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0x1f52 label_1EEA: // Incoming call from 0x1F60, returns to 0x077C, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1F60, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1EEC stack[-2] // @1EEC stack[-3] // } 1EEA 5B JUMPDEST 1EEB 50 POP 1EEC 90 SWAP1 1EED 56 *JUMP // Stack delta = -2 // Outputs[1] { @1EEC stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] 1EEE 5B JUMPDEST 1EEF 81 DUP2 1EF0 54 SLOAD 1EF1 81 DUP2 1EF2 83 DUP4 1EF3 55 SSTORE 1EF4 81 DUP2 1EF5 81 DUP2 1EF6 11 GT 1EF7 15 ISZERO 1EF8 61 PUSH2 0x07b7 1EFB 57 *JUMPI 1EFC 60 PUSH1 0x00 1EFE 83 DUP4 1EFF 81 DUP2 1F00 52 MSTORE 1F01 60 PUSH1 0x20 1F03 90 SWAP1 1F04 20 SHA3 1F05 61 PUSH2 0x07b7 1F08 91 SWAP2 1F09 81 DUP2 1F0A 01 ADD 1F0B 90 SWAP1 1F0C 83 DUP4 1F0D 01 ADD 1F0E 61 PUSH2 0x1f52 1F11 56 *JUMP 1F12 5B JUMPDEST 1F13 50 POP 1F14 80 DUP1 1F15 54 SLOAD 1F16 60 PUSH1 0x01 1F18 81 DUP2 1F19 60 PUSH1 0x01 1F1B 16 AND 1F1C 15 ISZERO 1F1D 61 PUSH2 0x0100 1F20 02 MUL 1F21 03 SUB 1F22 16 AND 1F23 60 PUSH1 0x02 1F25 90 SWAP1 1F26 04 DIV 1F27 60 PUSH1 0x00 1F29 82 DUP3 1F2A 55 SSTORE 1F2B 80 DUP1 1F2C 60 PUSH1 0x1f 1F2E 10 LT 1F2F 61 PUSH2 0x1f38 1F32 57 *JUMPI 1F33 50 POP 1F34 61 PUSH2 0x0682 1F37 56 *JUMP 1F38 5B JUMPDEST 1F39 60 PUSH1 0x1f 1F3B 01 ADD 1F3C 60 PUSH1 0x20 1F3E 90 SWAP1 1F3F 04 DIV 1F40 90 SWAP1 1F41 60 PUSH1 0x00 1F43 52 MSTORE 1F44 60 PUSH1 0x20 1F46 60 PUSH1 0x00 1F48 20 SHA3 1F49 90 SWAP1 1F4A 81 DUP2 1F4B 01 ADD 1F4C 90 SWAP1 1F4D 61 PUSH2 0x0682 1F50 91 SWAP2 1F51 90 SWAP1 label_1F52: // Incoming jump from 0x1EE9 // Inputs[2] // { // @1F56 stack[-2] // @1F57 stack[-1] // } 1F52 5B JUMPDEST 1F53 61 PUSH2 0x077c 1F56 91 SWAP2 1F57 90 SWAP1 1F58 5B JUMPDEST 1F59 80 DUP1 1F5A 82 DUP3 1F5B 11 GT 1F5C 15 ISZERO 1F5D 61 PUSH2 0x1eea 1F60 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1F56 stack[-2] = 0x077c // @1F57 stack[-1] = stack[-2] // @1F57 stack[0] = stack[-1] // } // Block ends with conditional call to 0x1eea, returns to 0x077C, if !(stack[-2] > stack[-1]) label_1F61: // Incoming jump from 0x1F60, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1F60, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1F63 stack[-1] } 1F61 60 PUSH1 0x00 1F63 81 DUP2 1F64 55 SSTORE 1F65 60 PUSH1 0x01 1F67 01 ADD 1F68 61 PUSH2 0x1f58 1F6B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1F64 storage[stack[-1]] = 0x00 // @1F67 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1f58 label_1F6C: // Incoming jump from 0x2201 // Incoming jump from 0x213D // Incoming jump from 0x2101 // Incoming jump from 0x20E2 // Incoming jump from 0x218B // Incoming jump from 0x2231 // Inputs[2] // { // @1F6D stack[-1] // @1F6E msg.data[stack[-1]:stack[-1] + 0x20] // } 1F6C 5B JUMPDEST 1F6D 80 DUP1 1F6E 35 CALLDATALOAD 1F6F 61 PUSH2 0x0817 1F72 81 DUP2 1F73 61 PUSH2 0x3112 1F76 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F6E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1F6F stack[1] = 0x0817 // @1F72 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x3112 1F77 5B JUMPDEST 1F78 60 PUSH1 0x00 1F7A 82 DUP3 1F7B 60 PUSH1 0x1f 1F7D 83 DUP4 1F7E 01 ADD 1F7F 12 SLT 1F80 61 PUSH2 0x1f88 1F83 57 *JUMPI 1F84 60 PUSH1 0x00 1F86 80 DUP1 1F87 FD *REVERT 1F88 5B JUMPDEST 1F89 81 DUP2 1F8A 35 CALLDATALOAD 1F8B 61 PUSH2 0x1f9b 1F8E 61 PUSH2 0x1f96 1F91 82 DUP3 1F92 61 PUSH2 0x301e 1F95 56 *JUMP label_1F96: // Incoming return from call to 0x303F at 0x2042 1F96 5B JUMPDEST 1F97 61 PUSH2 0x2ff7 1F9A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2ff7 1F9B 5B JUMPDEST 1F9C 91 SWAP2 1F9D 50 POP 1F9E 81 DUP2 1F9F 81 DUP2 1FA0 83 DUP4 1FA1 52 MSTORE 1FA2 60 PUSH1 0x20 1FA4 84 DUP5 1FA5 01 ADD 1FA6 93 SWAP4 1FA7 50 POP 1FA8 60 PUSH1 0x20 1FAA 81 DUP2 1FAB 01 ADD 1FAC 90 SWAP1 1FAD 50 POP 1FAE 83 DUP4 1FAF 85 DUP6 1FB0 60 PUSH1 0x40 1FB2 84 DUP5 1FB3 02 MUL 1FB4 82 DUP3 1FB5 01 ADD 1FB6 11 GT 1FB7 15 ISZERO 1FB8 61 PUSH2 0x1fc0 1FBB 57 *JUMPI 1FBC 60 PUSH1 0x00 1FBE 80 DUP1 1FBF FD *REVERT 1FC0 5B JUMPDEST 1FC1 60 PUSH1 0x00 1FC3 5B JUMPDEST 1FC4 83 DUP4 1FC5 81 DUP2 1FC6 10 LT 1FC7 15 ISZERO 1FC8 61 PUSH2 0x1fee 1FCB 57 *JUMPI 1FCC 81 DUP2 1FCD 61 PUSH2 0x1fd6 1FD0 88 DUP9 1FD1 82 DUP3 1FD2 61 PUSH2 0x2073 1FD5 56 *JUMP 1FD6 5B JUMPDEST 1FD7 84 DUP5 1FD8 52 MSTORE 1FD9 50 POP 1FDA 60 PUSH1 0x20 1FDC 90 SWAP1 1FDD 92 SWAP3 1FDE 01 ADD 1FDF 91 SWAP2 1FE0 60 PUSH1 0x40 1FE2 91 SWAP2 1FE3 90 SWAP1 1FE4 91 SWAP2 1FE5 01 ADD 1FE6 90 SWAP1 1FE7 60 PUSH1 0x01 1FE9 01 ADD 1FEA 61 PUSH2 0x1fc3 1FED 56 *JUMP 1FEE 5B JUMPDEST 1FEF 50 POP 1FF0 50 POP 1FF1 50 POP 1FF2 50 POP 1FF3 92 SWAP3 1FF4 91 SWAP2 1FF5 50 POP 1FF6 50 POP 1FF7 56 *JUMP 1FF8 5B JUMPDEST 1FF9 80 DUP1 1FFA 35 CALLDATALOAD 1FFB 61 PUSH2 0x0817 1FFE 81 DUP2 1FFF 61 PUSH2 0x3126 2002 56 *JUMP label_2003: // Incoming jump from 0x22F0 // Incoming jump from 0x22D1 // Incoming jump from 0x2315 // Inputs[2] // { // @2004 stack[-1] // @2005 msg.data[stack[-1]:stack[-1] + 0x20] // } 2003 5B JUMPDEST 2004 80 DUP1 2005 35 CALLDATALOAD 2006 61 PUSH2 0x0817 2009 81 DUP2 200A 61 PUSH2 0x312f 200D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2005 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @2006 stack[1] = 0x0817 // @2009 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x312f, returns to 0x0817 label_200E: // Incoming jump from 0x2260 // Inputs[2] // { // @200F stack[-1] // @2010 msg.data[stack[-1]:stack[-1] + 0x20] // } 200E 5B JUMPDEST 200F 80 DUP1 2010 35 CALLDATALOAD 2011 61 PUSH2 0x0817 2014 81 DUP2 2015 61 PUSH2 0x3138 2018 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2010 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @2011 stack[1] = 0x0817 // @2014 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3138, returns to 0x0817 2019 5B JUMPDEST 201A 80 DUP1 201B 51 MLOAD 201C 61 PUSH2 0x0817 201F 81 DUP2 2020 61 PUSH2 0x3138 2023 56 *JUMP label_2024: // Incoming call from 0x22B3, returns to 0x1020 // Inputs[2] // { // @2027 stack[-2] // @202A stack[-1] // } 2024 5B JUMPDEST 2025 60 PUSH1 0x00 2027 82 DUP3 2028 60 PUSH1 0x1f 202A 83 DUP4 202B 01 ADD 202C 12 SLT 202D 61 PUSH2 0x2035 2030 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2025 stack[0] = 0x00 } // Block ends with conditional jump to 0x2035, if stack[-1] + 0x1f i< stack[-2] label_2031: // Incoming jump from 0x2030, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2034 memory[0x00:0x00] } 2031 60 PUSH1 0x00 2033 80 DUP1 2034 FD *REVERT // Stack delta = +0 // Outputs[1] { @2034 revert(memory[0x00:0x00]); } // Block terminates label_2035: // Incoming jump from 0x2030, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2036 stack[-2] // @2037 msg.data[stack[-2]:stack[-2] + 0x20] // } 2035 5B JUMPDEST 2036 81 DUP2 2037 35 CALLDATALOAD 2038 61 PUSH2 0x2043 203B 61 PUSH2 0x1f96 203E 82 DUP3 203F 61 PUSH2 0x303f 2042 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2037 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2038 stack[1] = 0x2043 // @203B stack[2] = 0x1f96 // @203E stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x303f, returns to 0x1F96 label_2043: // Incoming return from call to 0x1F96 at 0x2042 // Inputs[5] // { // @2044 stack[-1] // @2044 stack[-3] // @2046 stack[-2] // @204B stack[-4] // @2051 stack[-5] // } 2043 5B JUMPDEST 2044 91 SWAP2 2045 50 POP 2046 80 DUP1 2047 82 DUP3 2048 52 MSTORE 2049 60 PUSH1 0x20 204B 83 DUP4 204C 01 ADD 204D 60 PUSH1 0x20 204F 83 DUP4 2050 01 ADD 2051 85 DUP6 2052 83 DUP4 2053 83 DUP4 2054 01 ADD 2055 11 GT 2056 15 ISZERO 2057 61 PUSH2 0x205f 205A 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2044 stack[-3] = stack[-1] // @2048 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @204C stack[-1] = stack[-4] + 0x20 // @2050 stack[0] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x205f, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) label_205B: // Incoming jump from 0x205A, if not !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[1] { @205E memory[0x00:0x00] } 205B 60 PUSH1 0x00 205D 80 DUP1 205E FD *REVERT // Stack delta = +0 // Outputs[1] { @205E revert(memory[0x00:0x00]); } // Block terminates label_205F: // Incoming jump from 0x205A, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[3] // { // @2063 stack[-3] // @2064 stack[-1] // @2065 stack[-2] // } 205F 5B JUMPDEST 2060 61 PUSH2 0x206a 2063 83 DUP4 2064 82 DUP3 2065 84 DUP5 2066 61 PUSH2 0x30b9 2069 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2060 stack[0] = 0x206a // @2063 stack[1] = stack[-3] // @2064 stack[2] = stack[-1] // @2065 stack[3] = stack[-2] // } // Block ends with call to 0x30b9, returns to 0x206A label_206A: // Incoming return from call to 0x30B9 at 0x2069 // Inputs[3] // { // @206E stack[-4] // @206E stack[-7] // @206F stack[-6] // } 206A 5B JUMPDEST 206B 50 POP 206C 50 POP 206D 50 POP 206E 92 SWAP3 206F 91 SWAP2 2070 50 POP 2071 50 POP 2072 56 *JUMP // Stack delta = -6 // Outputs[1] { @206E stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] 2073 5B JUMPDEST 2074 60 PUSH1 0x00 2076 60 PUSH1 0x40 2078 82 DUP3 2079 84 DUP5 207A 03 SUB 207B 12 SLT 207C 15 ISZERO 207D 61 PUSH2 0x2085 2080 57 *JUMPI 2081 60 PUSH1 0x00 2083 80 DUP1 2084 FD *REVERT 2085 5B JUMPDEST 2086 61 PUSH2 0x208f 2089 60 PUSH1 0x40 208B 61 PUSH2 0x2ff7 208E 56 *JUMP 208F 5B JUMPDEST 2090 90 SWAP1 2091 50 POP 2092 60 PUSH1 0x00 2094 61 PUSH2 0x209d 2097 84 DUP5 2098 84 DUP5 2099 61 PUSH2 0x1f6c 209C 56 *JUMP 209D 5B JUMPDEST 209E 82 DUP3 209F 52 MSTORE 20A0 50 POP 20A1 60 PUSH1 0x20 20A3 61 PUSH2 0x20ae 20A6 84 DUP5 20A7 84 DUP5 20A8 83 DUP4 20A9 01 ADD 20AA 61 PUSH2 0x2003 20AD 56 *JUMP 20AE 5B JUMPDEST 20AF 60 PUSH1 0x20 20B1 83 DUP4 20B2 01 ADD 20B3 52 MSTORE 20B4 50 POP 20B5 92 SWAP3 20B6 91 SWAP2 20B7 50 POP 20B8 50 POP 20B9 56 *JUMP 20BA 5B JUMPDEST 20BB 80 DUP1 20BC 35 CALLDATALOAD 20BD 61 PUSH2 0x0817 20C0 81 DUP2 20C1 61 PUSH2 0x3141 20C4 56 *JUMP label_20C5: // Incoming jump from 0x0280 // Incoming jump from 0x0471 // Incoming jump from 0x036E // Incoming jump from 0x0389 // Incoming jump from 0x045E // Inputs[2] // { // @20CA stack[-1] // @20CB stack[-2] // } 20C5 5B JUMPDEST 20C6 60 PUSH1 0x00 20C8 60 PUSH1 0x20 20CA 82 DUP3 20CB 84 DUP5 20CC 03 SUB 20CD 12 SLT 20CE 15 ISZERO 20CF 61 PUSH2 0x20d7 20D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20C6 stack[0] = 0x00 } // Block ends with conditional jump to 0x20d7, if !(stack[-2] - stack[-1] i< 0x20) label_20D3: // Incoming jump from 0x20D2, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20D6 memory[0x00:0x00] } 20D3 60 PUSH1 0x00 20D5 80 DUP1 20D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @20D6 revert(memory[0x00:0x00]); } // Block terminates label_20D7: // Incoming jump from 0x20D2, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @20DD stack[-3] // @20DE stack[-2] // } 20D7 5B JUMPDEST 20D8 60 PUSH1 0x00 20DA 61 PUSH2 0x1020 20DD 84 DUP5 20DE 84 DUP5 20DF 61 PUSH2 0x1f6c 20E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20D8 stack[0] = 0x00 // @20DA stack[1] = 0x1020 // @20DD stack[2] = stack[-3] // @20DE stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1f6c label_20E3: // Incoming jump from 0x044B // Inputs[2] // { // @20E9 stack[-1] // @20EA stack[-2] // } 20E3 5B JUMPDEST 20E4 60 PUSH1 0x00 20E6 80 DUP1 20E7 60 PUSH1 0x40 20E9 83 DUP4 20EA 85 DUP6 20EB 03 SUB 20EC 12 SLT 20ED 15 ISZERO 20EE 61 PUSH2 0x20f6 20F1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20E4 stack[0] = 0x00 // @20E6 stack[1] = 0x00 // } // Block ends with conditional jump to 0x20f6, if !(stack[-2] - stack[-1] i< 0x40) label_20F2: // Incoming jump from 0x20F1, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20F5 memory[0x00:0x00] } 20F2 60 PUSH1 0x00 20F4 80 DUP1 20F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @20F5 revert(memory[0x00:0x00]); } // Block terminates label_20F6: // Incoming jump from 0x20F1, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @20FC stack[-4] // @20FD stack[-3] // } 20F6 5B JUMPDEST 20F7 60 PUSH1 0x00 20F9 61 PUSH2 0x2102 20FC 85 DUP6 20FD 85 DUP6 20FE 61 PUSH2 0x1f6c 2101 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20F7 stack[0] = 0x00 // @20F9 stack[1] = 0x2102 // @20FC stack[2] = stack[-4] // @20FD stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1f6c 2102 5B JUMPDEST 2103 92 SWAP3 2104 50 POP 2105 50 POP 2106 60 PUSH1 0x20 2108 61 PUSH2 0x2113 210B 85 DUP6 210C 82 DUP3 210D 86 DUP7 210E 01 ADD 210F 61 PUSH2 0x1f6c 2112 56 *JUMP 2113 5B JUMPDEST 2114 91 SWAP2 2115 50 POP 2116 50 POP 2117 92 SWAP3 2118 50 POP 2119 92 SWAP3 211A 90 SWAP1 211B 50 POP 211C 56 *JUMP label_211D: // Incoming jump from 0x02EE // Incoming jump from 0x02C8 // Inputs[2] // { // @2125 stack[-1] // @2126 stack[-2] // } 211D 5B JUMPDEST 211E 60 PUSH1 0x00 2120 80 DUP1 2121 60 PUSH1 0x00 2123 60 PUSH1 0x60 2125 84 DUP5 2126 86 DUP7 2127 03 SUB 2128 12 SLT 2129 15 ISZERO 212A 61 PUSH2 0x2132 212D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @211E stack[0] = 0x00 // @2120 stack[1] = 0x00 // @2121 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2132, if !(stack[-2] - stack[-1] i< 0x60) label_212E: // Incoming jump from 0x212D, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2131 memory[0x00:0x00] } 212E 60 PUSH1 0x00 2130 80 DUP1 2131 FD *REVERT // Stack delta = +0 // Outputs[1] { @2131 revert(memory[0x00:0x00]); } // Block terminates label_2132: // Incoming jump from 0x212D, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2138 stack[-5] // @2139 stack[-4] // } 2132 5B JUMPDEST 2133 60 PUSH1 0x00 2135 61 PUSH2 0x213e 2138 86 DUP7 2139 86 DUP7 213A 61 PUSH2 0x1f6c 213D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2133 stack[0] = 0x00 // @2135 stack[1] = 0x213e // @2138 stack[2] = stack[-5] // @2139 stack[3] = stack[-4] // } // Block ends with unconditional jump to 0x1f6c 213E 5B JUMPDEST 213F 93 SWAP4 2140 50 POP 2141 50 POP 2142 60 PUSH1 0x20 2144 61 PUSH2 0x214f 2147 86 DUP7 2148 82 DUP3 2149 87 DUP8 214A 01 ADD 214B 61 PUSH2 0x1f6c 214E 56 *JUMP 214F 5B JUMPDEST 2150 92 SWAP3 2151 50 POP 2152 50 POP 2153 60 PUSH1 0x40 2155 61 PUSH2 0x2160 2158 86 DUP7 2159 82 DUP3 215A 87 DUP8 215B 01 ADD 215C 61 PUSH2 0x2003 215F 56 *JUMP 2160 5B JUMPDEST 2161 91 SWAP2 2162 50 POP 2163 50 POP 2164 92 SWAP3 2165 50 POP 2166 92 SWAP3 2167 50 POP 2168 92 SWAP3 2169 56 *JUMP label_216A: // Incoming jump from 0x03ED // Inputs[2] // { // @2173 stack[-1] // @2174 stack[-2] // } 216A 5B JUMPDEST 216B 60 PUSH1 0x00 216D 80 DUP1 216E 60 PUSH1 0x00 2170 80 DUP1 2171 60 PUSH1 0x80 2173 85 DUP6 2174 87 DUP8 2175 03 SUB 2176 12 SLT 2177 15 ISZERO 2178 61 PUSH2 0x2180 217B 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @216B stack[0] = 0x00 // @216D stack[1] = 0x00 // @216E stack[2] = 0x00 // @2170 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2180, if !(stack[-2] - stack[-1] i< 0x80) label_217C: // Incoming jump from 0x217B, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @217F memory[0x00:0x00] } 217C 60 PUSH1 0x00 217E 80 DUP1 217F FD *REVERT // Stack delta = +0 // Outputs[1] { @217F revert(memory[0x00:0x00]); } // Block terminates label_2180: // Incoming jump from 0x217B, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2186 stack[-6] // @2187 stack[-5] // } 2180 5B JUMPDEST 2181 60 PUSH1 0x00 2183 61 PUSH2 0x218c 2186 87 DUP8 2187 87 DUP8 2188 61 PUSH2 0x1f6c 218B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2181 stack[0] = 0x00 // @2183 stack[1] = 0x218c // @2186 stack[2] = stack[-6] // @2187 stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1f6c 218C 5B JUMPDEST 218D 94 SWAP5 218E 50 POP 218F 50 POP 2190 60 PUSH1 0x20 2192 61 PUSH2 0x219d 2195 87 DUP8 2196 82 DUP3 2197 88 DUP9 2198 01 ADD 2199 61 PUSH2 0x1f6c 219C 56 *JUMP 219D 5B JUMPDEST 219E 93 SWAP4 219F 50 POP 21A0 50 POP 21A1 60 PUSH1 0x40 21A3 61 PUSH2 0x21ae 21A6 87 DUP8 21A7 82 DUP3 21A8 88 DUP9 21A9 01 ADD 21AA 61 PUSH2 0x2003 21AD 56 *JUMP 21AE 5B JUMPDEST 21AF 92 SWAP3 21B0 50 POP 21B1 50 POP 21B2 60 PUSH1 0x60 21B4 85 DUP6 21B5 01 ADD 21B6 35 CALLDATALOAD 21B7 67 PUSH8 0xffffffffffffffff 21C0 81 DUP2 21C1 11 GT 21C2 15 ISZERO 21C3 61 PUSH2 0x21cb 21C6 57 *JUMPI 21C7 60 PUSH1 0x00 21C9 80 DUP1 21CA FD *REVERT 21CB 5B JUMPDEST 21CC 61 PUSH2 0x21d7 21CF 87 DUP8 21D0 82 DUP3 21D1 88 DUP9 21D2 01 ADD 21D3 61 PUSH2 0x2024 21D6 56 *JUMP 21D7 5B JUMPDEST 21D8 91 SWAP2 21D9 50 POP 21DA 50 POP 21DB 92 SWAP3 21DC 95 SWAP6 21DD 91 SWAP2 21DE 94 SWAP5 21DF 50 POP 21E0 92 SWAP3 21E1 50 POP 21E2 56 *JUMP label_21E3: // Incoming jump from 0x03DA // Inputs[2] // { // @21E9 stack[-1] // @21EA stack[-2] // } 21E3 5B JUMPDEST 21E4 60 PUSH1 0x00 21E6 80 DUP1 21E7 60 PUSH1 0x40 21E9 83 DUP4 21EA 85 DUP6 21EB 03 SUB 21EC 12 SLT 21ED 15 ISZERO 21EE 61 PUSH2 0x21f6 21F1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21E4 stack[0] = 0x00 // @21E6 stack[1] = 0x00 // } // Block ends with conditional jump to 0x21f6, if !(stack[-2] - stack[-1] i< 0x40) label_21F2: // Incoming jump from 0x21F1, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @21F5 memory[0x00:0x00] } 21F2 60 PUSH1 0x00 21F4 80 DUP1 21F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @21F5 revert(memory[0x00:0x00]); } // Block terminates label_21F6: // Incoming jump from 0x21F1, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @21FC stack[-4] // @21FD stack[-3] // } 21F6 5B JUMPDEST 21F7 60 PUSH1 0x00 21F9 61 PUSH2 0x2202 21FC 85 DUP6 21FD 85 DUP6 21FE 61 PUSH2 0x1f6c 2201 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @21F7 stack[0] = 0x00 // @21F9 stack[1] = 0x2202 // @21FC stack[2] = stack[-4] // @21FD stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1f6c 2202 5B JUMPDEST 2203 92 SWAP3 2204 50 POP 2205 50 POP 2206 60 PUSH1 0x20 2208 61 PUSH2 0x2113 220B 85 DUP6 220C 82 DUP3 220D 86 DUP7 220E 01 ADD 220F 61 PUSH2 0x1ff8 2212 56 *JUMP label_2213: // Incoming jump from 0x02DB // Incoming jump from 0x026B // Inputs[2] // { // @2219 stack[-1] // @221A stack[-2] // } 2213 5B JUMPDEST 2214 60 PUSH1 0x00 2216 80 DUP1 2217 60 PUSH1 0x40 2219 83 DUP4 221A 85 DUP6 221B 03 SUB 221C 12 SLT 221D 15 ISZERO 221E 61 PUSH2 0x2226 2221 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2214 stack[0] = 0x00 // @2216 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2226, if !(stack[-2] - stack[-1] i< 0x40) label_2222: // Incoming jump from 0x2221, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2225 memory[0x00:0x00] } 2222 60 PUSH1 0x00 2224 80 DUP1 2225 FD *REVERT // Stack delta = +0 // Outputs[1] { @2225 revert(memory[0x00:0x00]); } // Block terminates label_2226: // Incoming jump from 0x2221, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @222C stack[-4] // @222D stack[-3] // } 2226 5B JUMPDEST 2227 60 PUSH1 0x00 2229 61 PUSH2 0x2232 222C 85 DUP6 222D 85 DUP6 222E 61 PUSH2 0x1f6c 2231 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2227 stack[0] = 0x00 // @2229 stack[1] = 0x2232 // @222C stack[2] = stack[-4] // @222D stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1f6c 2232 5B JUMPDEST 2233 92 SWAP3 2234 50 POP 2235 50 POP 2236 60 PUSH1 0x20 2238 61 PUSH2 0x2113 223B 85 DUP6 223C 82 DUP3 223D 86 DUP7 223E 01 ADD 223F 61 PUSH2 0x2003 2242 56 *JUMP label_2243: // Incoming jump from 0x020D // Inputs[2] // { // @2248 stack[-1] // @2249 stack[-2] // } 2243 5B JUMPDEST 2244 60 PUSH1 0x00 2246 60 PUSH1 0x20 2248 82 DUP3 2249 84 DUP5 224A 03 SUB 224B 12 SLT 224C 15 ISZERO 224D 61 PUSH2 0x2255 2250 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2244 stack[0] = 0x00 } // Block ends with conditional jump to 0x2255, if !(stack[-2] - stack[-1] i< 0x20) label_2251: // Incoming jump from 0x2250, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2254 memory[0x00:0x00] } 2251 60 PUSH1 0x00 2253 80 DUP1 2254 FD *REVERT // Stack delta = +0 // Outputs[1] { @2254 revert(memory[0x00:0x00]); } // Block terminates label_2255: // Incoming jump from 0x2250, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @225B stack[-3] // @225C stack[-2] // } 2255 5B JUMPDEST 2256 60 PUSH1 0x00 2258 61 PUSH2 0x1020 225B 84 DUP5 225C 84 DUP5 225D 61 PUSH2 0x200e 2260 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2256 stack[0] = 0x00 // @2258 stack[1] = 0x1020 // @225B stack[2] = stack[-3] // @225C stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x200e 2261 5B JUMPDEST 2262 60 PUSH1 0x00 2264 60 PUSH1 0x20 2266 82 DUP3 2267 84 DUP5 2268 03 SUB 2269 12 SLT 226A 15 ISZERO 226B 61 PUSH2 0x2273 226E 57 *JUMPI 226F 60 PUSH1 0x00 2271 80 DUP1 2272 FD *REVERT 2273 5B JUMPDEST 2274 60 PUSH1 0x00 2276 61 PUSH2 0x1020 2279 84 DUP5 227A 84 DUP5 227B 61 PUSH2 0x2019 227E 56 *JUMP label_227F: // Incoming call from 0x03AC, returns to 0x03AD // Incoming call from 0x03C7, returns to 0x03C8 // Inputs[2] // { // @2284 stack[-1] // @2285 stack[-2] // } 227F 5B JUMPDEST 2280 60 PUSH1 0x00 2282 60 PUSH1 0x20 2284 82 DUP3 2285 84 DUP5 2286 03 SUB 2287 12 SLT 2288 15 ISZERO 2289 61 PUSH2 0x2291 228C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2280 stack[0] = 0x00 } // Block ends with conditional jump to 0x2291, if !(stack[-2] - stack[-1] i< 0x20) label_228D: // Incoming jump from 0x228C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2290 memory[0x00:0x00] } 228D 60 PUSH1 0x00 228F 80 DUP1 2290 FD *REVERT // Stack delta = +0 // Outputs[1] { @2290 revert(memory[0x00:0x00]); } // Block terminates label_2291: // Incoming jump from 0x228C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2292 stack[-2] // @2293 msg.data[stack[-2]:stack[-2] + 0x20] // } 2291 5B JUMPDEST 2292 81 DUP2 2293 35 CALLDATALOAD 2294 67 PUSH8 0xffffffffffffffff 229D 81 DUP2 229E 11 GT 229F 15 ISZERO 22A0 61 PUSH2 0x22a8 22A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2293 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x22a8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_22A4: // Incoming jump from 0x22A3, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @22A7 memory[0x00:0x00] } 22A4 60 PUSH1 0x00 22A6 80 DUP1 22A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @22A7 revert(memory[0x00:0x00]); } // Block terminates label_22A8: // Incoming jump from 0x22A3, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @22AC stack[-4] // @22AD stack[-1] // @22AE stack[-3] // } 22A8 5B JUMPDEST 22A9 61 PUSH2 0x1020 22AC 84 DUP5 22AD 82 DUP3 22AE 85 DUP6 22AF 01 ADD 22B0 61 PUSH2 0x2024 22B3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22A9 stack[0] = 0x1020 // @22AC stack[1] = stack[-4] // @22AF stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x2024, returns to 0x1020 label_22B4: // Incoming jump from 0x024B // Incoming jump from 0x0301 // Incoming jump from 0x0348 // Incoming jump from 0x0428 // Incoming jump from 0x0293 // Incoming jump from 0x0400 // Incoming jump from 0x0314 // Inputs[2] // { // @22B9 stack[-1] // @22BA stack[-2] // } 22B4 5B JUMPDEST 22B5 60 PUSH1 0x00 22B7 60 PUSH1 0x20 22B9 82 DUP3 22BA 84 DUP5 22BB 03 SUB 22BC 12 SLT 22BD 15 ISZERO 22BE 61 PUSH2 0x22c6 22C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22B5 stack[0] = 0x00 } // Block ends with conditional jump to 0x22c6, if !(stack[-2] - stack[-1] i< 0x20) label_22C2: // Incoming jump from 0x22C1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22C5 memory[0x00:0x00] } 22C2 60 PUSH1 0x00 22C4 80 DUP1 22C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @22C5 revert(memory[0x00:0x00]); } // Block terminates label_22C6: // Incoming jump from 0x22C1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @22CC stack[-3] // @22CD stack[-2] // } 22C6 5B JUMPDEST 22C7 60 PUSH1 0x00 22C9 61 PUSH2 0x1020 22CC 84 DUP5 22CD 84 DUP5 22CE 61 PUSH2 0x2003 22D1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22C7 stack[0] = 0x00 // @22C9 stack[1] = 0x1020 // @22CC stack[2] = stack[-3] // @22CD stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x2003 label_22D2: // Incoming jump from 0x0327 // Inputs[2] // { // @22D8 stack[-1] // @22D9 stack[-2] // } 22D2 5B JUMPDEST 22D3 60 PUSH1 0x00 22D5 80 DUP1 22D6 60 PUSH1 0x40 22D8 83 DUP4 22D9 85 DUP6 22DA 03 SUB 22DB 12 SLT 22DC 15 ISZERO 22DD 61 PUSH2 0x22e5 22E0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22D3 stack[0] = 0x00 // @22D5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x22e5, if !(stack[-2] - stack[-1] i< 0x40) label_22E1: // Incoming jump from 0x22E0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22E4 memory[0x00:0x00] } 22E1 60 PUSH1 0x00 22E3 80 DUP1 22E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @22E4 revert(memory[0x00:0x00]); } // Block terminates label_22E5: // Incoming jump from 0x22E0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22EB stack[-4] // @22EC stack[-3] // } 22E5 5B JUMPDEST 22E6 60 PUSH1 0x00 22E8 61 PUSH2 0x2232 22EB 85 DUP6 22EC 85 DUP6 22ED 61 PUSH2 0x2003 22F0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22E6 stack[0] = 0x00 // @22E8 stack[1] = 0x2232 // @22EB stack[2] = stack[-4] // @22EC stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x2003 label_22F1: // Incoming jump from 0x035B // Inputs[2] // { // @22FD stack[-1] // @22FE stack[-2] // } 22F1 5B JUMPDEST 22F2 60 PUSH1 0x00 22F4 80 DUP1 22F5 60 PUSH1 0x00 22F7 80 DUP1 22F8 60 PUSH1 0x00 22FA 80 DUP1 22FB 60 PUSH1 0xc0 22FD 87 DUP8 22FE 89 DUP10 22FF 03 SUB 2300 12 SLT 2301 15 ISZERO 2302 61 PUSH2 0x230a 2305 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @22F2 stack[0] = 0x00 // @22F4 stack[1] = 0x00 // @22F5 stack[2] = 0x00 // @22F7 stack[3] = 0x00 // @22F8 stack[4] = 0x00 // @22FA stack[5] = 0x00 // } // Block ends with conditional jump to 0x230a, if !(stack[-2] - stack[-1] i< 0xc0) label_2306: // Incoming jump from 0x2305, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[1] { @2309 memory[0x00:0x00] } 2306 60 PUSH1 0x00 2308 80 DUP1 2309 FD *REVERT // Stack delta = +0 // Outputs[1] { @2309 revert(memory[0x00:0x00]); } // Block terminates label_230A: // Incoming jump from 0x2305, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @2310 stack[-8] // @2311 stack[-7] // } 230A 5B JUMPDEST 230B 60 PUSH1 0x00 230D 61 PUSH2 0x2316 2310 89 DUP10 2311 89 DUP10 2312 61 PUSH2 0x2003 2315 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @230B stack[0] = 0x00 // @230D stack[1] = 0x2316 // @2310 stack[2] = stack[-8] // @2311 stack[3] = stack[-7] // } // Block ends with unconditional jump to 0x2003 2316 5B JUMPDEST 2317 96 SWAP7 2318 50 POP 2319 50 POP 231A 60 PUSH1 0x20 231C 61 PUSH2 0x2327 231F 89 DUP10 2320 82 DUP3 2321 8A DUP11 2322 01 ADD 2323 61 PUSH2 0x20ba 2326 56 *JUMP 2327 5B JUMPDEST 2328 95 SWAP6 2329 50 POP 232A 50 POP 232B 60 PUSH1 0x40 232D 61 PUSH2 0x2338 2330 89 DUP10 2331 82 DUP3 2332 8A DUP11 2333 01 ADD 2334 61 PUSH2 0x2003 2337 56 *JUMP 2338 5B JUMPDEST 2339 94 SWAP5 233A 50 POP 233B 50 POP 233C 60 PUSH1 0x60 233E 61 PUSH2 0x2349 2341 89 DUP10 2342 82 DUP3 2343 8A DUP11 2344 01 ADD 2345 61 PUSH2 0x2003 2348 56 *JUMP 2349 5B JUMPDEST 234A 93 SWAP4 234B 50 POP 234C 50 POP 234D 60 PUSH1 0x80 234F 87 DUP8 2350 01 ADD 2351 35 CALLDATALOAD 2352 67 PUSH8 0xffffffffffffffff 235B 81 DUP2 235C 11 GT 235D 15 ISZERO 235E 61 PUSH2 0x2366 2361 57 *JUMPI 2362 60 PUSH1 0x00 2364 80 DUP1 2365 FD *REVERT 2366 5B JUMPDEST 2367 61 PUSH2 0x2372 236A 89 DUP10 236B 82 DUP3 236C 8A DUP11 236D 01 ADD 236E 61 PUSH2 0x1f77 2371 56 *JUMP 2372 5B JUMPDEST 2373 92 SWAP3 2374 50 POP 2375 50 POP 2376 60 PUSH1 0xa0 2378 87 DUP8 2379 01 ADD 237A 35 CALLDATALOAD 237B 67 PUSH8 0xffffffffffffffff 2384 81 DUP2 2385 11 GT 2386 15 ISZERO 2387 61 PUSH2 0x238f 238A 57 *JUMPI 238B 60 PUSH1 0x00 238D 80 DUP1 238E FD *REVERT 238F 5B JUMPDEST 2390 61 PUSH2 0x239b 2393 89 DUP10 2394 82 DUP3 2395 8A DUP11 2396 01 ADD 2397 61 PUSH2 0x2024 239A 56 *JUMP 239B 5B JUMPDEST 239C 91 SWAP2 239D 50 POP 239E 50 POP 239F 92 SWAP3 23A0 95 SWAP6 23A1 50 POP 23A2 92 SWAP3 23A3 95 SWAP6 23A4 50 POP 23A5 92 SWAP3 23A6 95 SWAP6 23A7 56 *JUMP 23A8 5B JUMPDEST 23A9 60 PUSH1 0x00 23AB 61 PUSH2 0x23b4 23AE 83 DUP4 23AF 83 DUP4 23B0 61 PUSH2 0x23c8 23B3 56 *JUMP 23B4 5B JUMPDEST 23B5 50 POP 23B6 50 POP 23B7 60 PUSH1 0x20 23B9 01 ADD 23BA 90 SWAP1 23BB 56 *JUMP 23BC 5B JUMPDEST 23BD 60 PUSH1 0x00 23BF 61 PUSH2 0x23b4 23C2 83 DUP4 23C3 83 DUP4 23C4 61 PUSH2 0x24d5 23C7 56 *JUMP label_23C8: // Incoming call from 0x2D26, returns to 0x0817 // Inputs[1] { @23CC stack[-1] } 23C8 5B JUMPDEST 23C9 61 PUSH2 0x23d1 23CC 81 DUP2 23CD 61 PUSH2 0x307f 23D0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23C9 stack[0] = 0x23d1 // @23CC stack[1] = stack[-1] // } // Block ends with call to 0x307f, returns to 0x23D1 label_23D1: // Incoming return from call to 0x077C at 0x24DD // Incoming return from call to 0x307F at 0x23D0 // Incoming return from call to 0x308A at 0x24D4 // Inputs[3] // { // @23D2 stack[-3] // @23D3 stack[-1] // @23D6 stack[-4] // } 23D1 5B JUMPDEST 23D2 82 DUP3 23D3 52 MSTORE 23D4 50 POP 23D5 50 POP 23D6 56 *JUMP // Stack delta = -4 // Outputs[1] { @23D3 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] 23D7 5B JUMPDEST 23D8 60 PUSH1 0x00 23DA 61 PUSH2 0x23e2 23DD 82 DUP3 23DE 61 PUSH2 0x306d 23E1 56 *JUMP 23E2 5B JUMPDEST 23E3 61 PUSH2 0x23ec 23E6 81 DUP2 23E7 85 DUP6 23E8 61 PUSH2 0x3071 23EB 56 *JUMP 23EC 5B JUMPDEST 23ED 93 SWAP4 23EE 50 POP 23EF 61 PUSH2 0x23f7 23F2 83 DUP4 23F3 61 PUSH2 0x3067 23F6 56 *JUMP 23F7 5B JUMPDEST 23F8 80 DUP1 23F9 60 PUSH1 0x00 23FB 5B JUMPDEST 23FC 83 DUP4 23FD 81 DUP2 23FE 10 LT 23FF 15 ISZERO 2400 61 PUSH2 0x2425 2403 57 *JUMPI 2404 81 DUP2 2405 51 MLOAD 2406 61 PUSH2 0x240f 2409 88 DUP9 240A 82 DUP3 240B 61 PUSH2 0x23a8 240E 56 *JUMP 240F 5B JUMPDEST 2410 97 SWAP8 2411 50 POP 2412 61 PUSH2 0x241a 2415 83 DUP4 2416 61 PUSH2 0x3067 2419 56 *JUMP 241A 5B JUMPDEST 241B 92 SWAP3 241C 50 POP 241D 50 POP 241E 60 PUSH1 0x01 2420 01 ADD 2421 61 PUSH2 0x23fb 2424 56 *JUMP 2425 5B JUMPDEST 2426 50 POP 2427 94 SWAP5 2428 95 SWAP6 2429 94 SWAP5 242A 50 POP 242B 50 POP 242C 50 POP 242D 50 POP 242E 50 POP 242F 56 *JUMP 2430 5B JUMPDEST 2431 60 PUSH1 0x00 2433 61 PUSH2 0x243b 2436 82 DUP3 2437 61 PUSH2 0x306d 243A 56 *JUMP 243B 5B JUMPDEST 243C 61 PUSH2 0x2445 243F 81 DUP2 2440 85 DUP6 2441 61 PUSH2 0x3071 2444 56 *JUMP 2445 5B JUMPDEST 2446 93 SWAP4 2447 50 POP 2448 61 PUSH2 0x2450 244B 83 DUP4 244C 61 PUSH2 0x3067 244F 56 *JUMP 2450 5B JUMPDEST 2451 80 DUP1 2452 60 PUSH1 0x00 2454 5B JUMPDEST 2455 83 DUP4 2456 81 DUP2 2457 10 LT 2458 15 ISZERO 2459 61 PUSH2 0x2425 245C 57 *JUMPI 245D 81 DUP2 245E 51 MLOAD 245F 61 PUSH2 0x2468 2462 88 DUP9 2463 82 DUP3 2464 61 PUSH2 0x23a8 2467 56 *JUMP 2468 5B JUMPDEST 2469 97 SWAP8 246A 50 POP 246B 61 PUSH2 0x2473 246E 83 DUP4 246F 61 PUSH2 0x3067 2472 56 *JUMP 2473 5B JUMPDEST 2474 92 SWAP3 2475 50 POP 2476 50 POP 2477 60 PUSH1 0x01 2479 01 ADD 247A 61 PUSH2 0x2454 247D 56 *JUMP 247E 5B JUMPDEST 247F 60 PUSH1 0x00 2481 61 PUSH2 0x2489 2484 82 DUP3 2485 61 PUSH2 0x306d 2488 56 *JUMP 2489 5B JUMPDEST 248A 61 PUSH2 0x2493 248D 81 DUP2 248E 85 DUP6 248F 61 PUSH2 0x3071 2492 56 *JUMP 2493 5B JUMPDEST 2494 93 SWAP4 2495 50 POP 2496 61 PUSH2 0x249e 2499 83 DUP4 249A 61 PUSH2 0x3067 249D 56 *JUMP 249E 5B JUMPDEST 249F 80 DUP1 24A0 60 PUSH1 0x00 24A2 5B JUMPDEST 24A3 83 DUP4 24A4 81 DUP2 24A5 10 LT 24A6 15 ISZERO 24A7 61 PUSH2 0x2425 24AA 57 *JUMPI 24AB 81 DUP2 24AC 51 MLOAD 24AD 61 PUSH2 0x24b6 24B0 88 DUP9 24B1 82 DUP3 24B2 61 PUSH2 0x23bc 24B5 56 *JUMP 24B6 5B JUMPDEST 24B7 97 SWAP8 24B8 50 POP 24B9 61 PUSH2 0x24c1 24BC 83 DUP4 24BD 61 PUSH2 0x3067 24C0 56 *JUMP 24C1 5B JUMPDEST 24C2 92 SWAP3 24C3 50 POP 24C4 50 POP 24C5 60 PUSH1 0x01 24C7 01 ADD 24C8 61 PUSH2 0x24a2 24CB 56 *JUMP label_24CC: // Incoming jump from 0x2DB5 // Inputs[1] { @24D0 stack[-1] } 24CC 5B JUMPDEST 24CD 61 PUSH2 0x23d1 24D0 81 DUP2 24D1 61 PUSH2 0x308a 24D4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24CD stack[0] = 0x23d1 // @24D0 stack[1] = stack[-1] // } // Block ends with call to 0x308a, returns to 0x23D1 label_24D5: // Incoming call from 0x2FC2, returns to 0x0817 // Inputs[1] { @24D9 stack[-1] } 24D5 5B JUMPDEST 24D6 61 PUSH2 0x23d1 24D9 81 DUP2 24DA 61 PUSH2 0x077c 24DD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24D6 stack[0] = 0x23d1 // @24D9 stack[1] = stack[-1] // } // Block ends with call to 0x077c, returns to 0x23D1 label_24DE: // Incoming call from 0x2E04, returns to 0x1B3B // Inputs[1] { @24E4 stack[-1] } 24DE 5B JUMPDEST 24DF 60 PUSH1 0x00 24E1 61 PUSH2 0x24e9 24E4 82 DUP3 24E5 61 PUSH2 0x306d 24E8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24DF stack[0] = 0x00 // @24E1 stack[1] = 0x24e9 // @24E4 stack[2] = stack[-1] // } // Block ends with call to 0x306d, returns to 0x24E9 label_24E9: // Incoming return from call to 0x306D at 0x24E8 // Inputs[2] // { // @24ED stack[-1] // @24EE stack[-4] // } 24E9 5B JUMPDEST 24EA 61 PUSH2 0x24f3 24ED 81 DUP2 24EE 85 DUP6 24EF 61 PUSH2 0x3071 24F2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24EA stack[0] = 0x24f3 // @24ED stack[1] = stack[-1] // @24EE stack[2] = stack[-4] // } // Block ends with call to 0x3071, returns to 0x24F3 label_24F3: // Incoming return from call to 0x3071 at 0x24F2 // Inputs[4] // { // @24F4 stack[-1] // @24F4 stack[-5] // @24F9 stack[-2] // @24FD stack[-4] // } 24F3 5B JUMPDEST 24F4 93 SWAP4 24F5 50 POP 24F6 61 PUSH2 0x2503 24F9 81 DUP2 24FA 85 DUP6 24FB 60 PUSH1 0x20 24FD 86 DUP7 24FE 01 ADD 24FF 61 PUSH2 0x30c5 2502 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @24F4 stack[-5] = stack[-1] // @24F6 stack[-1] = 0x2503 // @24F9 stack[0] = stack[-2] // @24FA stack[1] = stack[-1] // @24FE stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x30c5, returns to 0x2503 label_2503: // Incoming return from call to 0x30C5 at 0x2502 // Inputs[1] { @2507 stack[-1] } 2503 5B JUMPDEST 2504 61 PUSH2 0x250c 2507 81 DUP2 2508 61 PUSH2 0x3102 250B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2504 stack[0] = 0x250c // @2507 stack[1] = stack[-1] // } // Block ends with call to 0x3102, returns to 0x250C label_250C: // Incoming return from call to 0x3102 at 0x250B // Inputs[4] // { // @250D stack[-2] // @250D stack[-1] // @250E stack[-5] // @2510 stack[-6] // } 250C 5B JUMPDEST 250D 90 SWAP1 250E 93 SWAP4 250F 01 ADD 2510 93 SWAP4 2511 92 SWAP3 2512 50 POP 2513 50 POP 2514 50 POP 2515 56 *JUMP // Stack delta = -5 // Outputs[1] { @2510 stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] 2516 5B JUMPDEST 2517 60 PUSH1 0x00 2519 61 PUSH2 0x2521 251C 82 DUP3 251D 61 PUSH2 0x306d 2520 56 *JUMP 2521 5B JUMPDEST 2522 61 PUSH2 0x252b 2525 81 DUP2 2526 85 DUP6 2527 61 PUSH2 0x307a 252A 56 *JUMP 252B 5B JUMPDEST 252C 93 SWAP4 252D 50 POP 252E 61 PUSH2 0x253b 2531 81 DUP2 2532 85 DUP6 2533 60 PUSH1 0x20 2535 86 DUP7 2536 01 ADD 2537 61 PUSH2 0x30c5 253A 56 *JUMP 253B 5B JUMPDEST 253C 92 SWAP3 253D 90 SWAP1 253E 92 SWAP3 253F 01 ADD 2540 92 SWAP3 2541 91 SWAP2 2542 50 POP 2543 50 POP 2544 56 *JUMP 2545 5B JUMPDEST 2546 61 PUSH2 0x23d1 2549 61 PUSH2 0x2551 254C 82 DUP3 254D 61 PUSH2 0x30ae 2550 56 *JUMP 2551 5B JUMPDEST 2552 61 PUSH2 0x30f1 2555 56 *JUMP 2556 5B JUMPDEST 2557 60 PUSH1 0x00 2559 61 PUSH2 0x2563 255C 60 PUSH1 0x1c 255E 83 DUP4 255F 61 PUSH2 0x3071 2562 56 *JUMP 2563 5B JUMPDEST 2564 7F PUSH32 0x4665652076616c75652073686f756c6420626520706f73697469766500000000 2585 81 DUP2 2586 52 MSTORE 2587 60 PUSH1 0x20 2589 01 ADD 258A 92 SWAP3 258B 91 SWAP2 258C 50 POP 258D 50 POP 258E 56 *JUMP 258F 5B JUMPDEST 2590 60 PUSH1 0x00 2592 61 PUSH2 0x259c 2595 60 PUSH1 0x1f 2597 83 DUP4 2598 61 PUSH2 0x3071 259B 56 *JUMP 259C 5B JUMPDEST 259D 7F PUSH32 0x526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500 25BE 81 DUP2 25BF 52 MSTORE 25C0 60 PUSH1 0x20 25C2 01 ADD 25C3 92 SWAP3 25C4 91 SWAP2 25C5 50 POP 25C6 50 POP 25C7 56 *JUMP 25C8 5B JUMPDEST 25C9 60 PUSH1 0x00 25CB 61 PUSH2 0x25d5 25CE 60 PUSH1 0x2b 25D0 83 DUP4 25D1 61 PUSH2 0x3071 25D4 56 *JUMP 25D5 5B JUMPDEST 25D6 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 25F7 81 DUP2 25F8 52 MSTORE 25F9 6A PUSH11 0x74206f6620626f756e6473 2605 60 PUSH1 0xa8 2607 1B SHL 2608 60 PUSH1 0x20 260A 82 DUP3 260B 01 ADD 260C 52 MSTORE 260D 60 PUSH1 0x40 260F 01 ADD 2610 92 SWAP3 2611 91 SWAP2 2612 50 POP 2613 50 POP 2614 56 *JUMP 2615 5B JUMPDEST 2616 60 PUSH1 0x00 2618 61 PUSH2 0x2622 261B 60 PUSH1 0x32 261D 83 DUP4 261E 61 PUSH2 0x3071 2621 56 *JUMP 2622 5B JUMPDEST 2623 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 2644 81 DUP2 2645 52 MSTORE 2646 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 2659 60 PUSH1 0x71 265B 1B SHL 265C 60 PUSH1 0x20 265E 82 DUP3 265F 01 ADD 2660 52 MSTORE 2661 60 PUSH1 0x40 2663 01 ADD 2664 92 SWAP3 2665 91 SWAP2 2666 50 POP 2667 50 POP 2668 56 *JUMP 2669 5B JUMPDEST 266A 60 PUSH1 0x00 266C 61 PUSH2 0x2676 266F 60 PUSH1 0x26 2671 83 DUP4 2672 61 PUSH2 0x3071 2675 56 *JUMP 2676 5B JUMPDEST 2677 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 2698 81 DUP2 2699 52 MSTORE 269A 65 PUSH6 0x646472657373 26A1 60 PUSH1 0xd0 26A3 1B SHL 26A4 60 PUSH1 0x20 26A6 82 DUP3 26A7 01 ADD 26A8 52 MSTORE 26A9 60 PUSH1 0x40 26AB 01 ADD 26AC 92 SWAP3 26AD 91 SWAP2 26AE 50 POP 26AF 50 POP 26B0 56 *JUMP 26B1 5B JUMPDEST 26B2 60 PUSH1 0x00 26B4 61 PUSH2 0x26be 26B7 60 PUSH1 0x1c 26B9 83 DUP4 26BA 61 PUSH2 0x3071 26BD 56 *JUMP 26BE 5B JUMPDEST 26BF 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 26E0 81 DUP2 26E1 52 MSTORE 26E2 60 PUSH1 0x20 26E4 01 ADD 26E5 92 SWAP3 26E6 91 SWAP2 26E7 50 POP 26E8 50 POP 26E9 56 *JUMP 26EA 5B JUMPDEST 26EB 60 PUSH1 0x00 26ED 61 PUSH2 0x26f7 26F0 60 PUSH1 0x24 26F2 83 DUP4 26F3 61 PUSH2 0x3071 26F6 56 *JUMP 26F7 5B JUMPDEST 26F8 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 2719 81 DUP2 271A 52 MSTORE 271B 63 PUSH4 0x72657373 2720 60 PUSH1 0xe0 2722 1B SHL 2723 60 PUSH1 0x20 2725 82 DUP3 2726 01 ADD 2727 52 MSTORE 2728 60 PUSH1 0x40 272A 01 ADD 272B 92 SWAP3 272C 91 SWAP2 272D 50 POP 272E 50 POP 272F 56 *JUMP 2730 5B JUMPDEST 2731 60 PUSH1 0x00 2733 61 PUSH2 0x273d 2736 60 PUSH1 0x19 2738 83 DUP4 2739 61 PUSH2 0x3071 273C 56 *JUMP 273D 5B JUMPDEST 273E 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 275F 81 DUP2 2760 52 MSTORE 2761 60 PUSH1 0x20 2763 01 ADD 2764 92 SWAP3 2765 91 SWAP2 2766 50 POP 2767 50 POP 2768 56 *JUMP 2769 5B JUMPDEST 276A 60 PUSH1 0x00 276C 61 PUSH2 0x2776 276F 60 PUSH1 0x2c 2771 83 DUP4 2772 61 PUSH2 0x3071 2775 56 *JUMP 2776 5B JUMPDEST 2777 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 2798 81 DUP2 2799 52 MSTORE 279A 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 27A7 60 PUSH1 0xa1 27A9 1B SHL 27AA 60 PUSH1 0x20 27AC 82 DUP3 27AD 01 ADD 27AE 52 MSTORE 27AF 60 PUSH1 0x40 27B1 01 ADD 27B2 92 SWAP3 27B3 91 SWAP2 27B4 50 POP 27B5 50 POP 27B6 56 *JUMP 27B7 5B JUMPDEST 27B8 60 PUSH1 0x00 27BA 61 PUSH2 0x27c4 27BD 60 PUSH1 0x38 27BF 83 DUP4 27C0 61 PUSH2 0x3071 27C3 56 *JUMP 27C4 5B JUMPDEST 27C5 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 27E6 81 DUP2 27E7 52 MSTORE 27E8 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 2809 60 PUSH1 0x20 280B 82 DUP3 280C 01 ADD 280D 52 MSTORE 280E 60 PUSH1 0x40 2810 01 ADD 2811 92 SWAP3 2812 91 SWAP2 2813 50 POP 2814 50 POP 2815 56 *JUMP 2816 5B JUMPDEST 2817 60 PUSH1 0x00 2819 61 PUSH2 0x2823 281C 60 PUSH1 0x2a 281E 83 DUP4 281F 61 PUSH2 0x3071 2822 56 *JUMP 2823 5B JUMPDEST 2824 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 2845 81 DUP2 2846 52 MSTORE 2847 69 PUSH10 0x726f2061646472657373 2852 60 PUSH1 0xb0 2854 1B SHL 2855 60 PUSH1 0x20 2857 82 DUP3 2858 01 ADD 2859 52 MSTORE 285A 60 PUSH1 0x40 285C 01 ADD 285D 92 SWAP3 285E 91 SWAP2 285F 50 POP 2860 50 POP 2861 56 *JUMP 2862 5B JUMPDEST 2863 60 PUSH1 0x00 2865 61 PUSH2 0x286f 2868 60 PUSH1 0x29 286A 83 DUP4 286B 61 PUSH2 0x3071 286E 56 *JUMP 286F 5B JUMPDEST 2870 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 2891 81 DUP2 2892 52 MSTORE 2893 68 PUSH9 0x32b73a103a37b5b2b7 289D 60 PUSH1 0xb9 289F 1B SHL 28A0 60 PUSH1 0x20 28A2 82 DUP3 28A3 01 ADD 28A4 52 MSTORE 28A5 60 PUSH1 0x40 28A7 01 ADD 28A8 92 SWAP3 28A9 91 SWAP2 28AA 50 POP 28AB 50 POP 28AC 56 *JUMP label_28AD: // Incoming call from 0x2ED4, returns to 0x0817 // Inputs[1] { @28B5 stack[-1] } 28AD 5B JUMPDEST 28AE 60 PUSH1 0x00 28B0 61 PUSH2 0x28ba 28B3 60 PUSH1 0x21 28B5 83 DUP4 28B6 61 PUSH2 0x3071 28B9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @28AE stack[0] = 0x00 // @28B0 stack[1] = 0x28ba // @28B3 stack[2] = 0x21 // @28B5 stack[3] = stack[-1] // } // Block ends with call to 0x3071, returns to 0x28BA label_28BA: // Incoming return from call to 0x3071 at 0x28B9 // Inputs[3] // { // @28DC stack[-1] // @28EB stack[-4] // @28EC stack[-3] // } 28BA 5B JUMPDEST 28BB 7F PUSH32 0x526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c 28DC 81 DUP2 28DD 52 MSTORE 28DE 60 PUSH1 0x65 28E0 60 PUSH1 0xf8 28E2 1B SHL 28E3 60 PUSH1 0x20 28E5 82 DUP3 28E6 01 ADD 28E7 52 MSTORE 28E8 60 PUSH1 0x40 28EA 01 ADD 28EB 92 SWAP3 28EC 91 SWAP2 28ED 50 POP 28EE 50 POP 28EF 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @28DD memory[stack[-1]:stack[-1] + 0x20] = 0x526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c // @28E7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x65 << 0xf8 // @28EB stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] 28F0 5B JUMPDEST 28F1 60 PUSH1 0x00 28F3 61 PUSH2 0x28fd 28F6 60 PUSH1 0x20 28F8 83 DUP4 28F9 61 PUSH2 0x3071 28FC 56 *JUMP 28FD 5B JUMPDEST 28FE 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 291F 81 DUP2 2920 52 MSTORE 2921 60 PUSH1 0x20 2923 01 ADD 2924 92 SWAP3 2925 91 SWAP2 2926 50 POP 2927 50 POP 2928 56 *JUMP 2929 5B JUMPDEST 292A 60 PUSH1 0x00 292C 61 PUSH2 0x2936 292F 60 PUSH1 0x2c 2931 83 DUP4 2932 61 PUSH2 0x3071 2935 56 *JUMP 2936 5B JUMPDEST 2937 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 2958 81 DUP2 2959 52 MSTORE 295A 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 2967 60 PUSH1 0xa1 2969 1B SHL 296A 60 PUSH1 0x20 296C 82 DUP3 296D 01 ADD 296E 52 MSTORE 296F 60 PUSH1 0x40 2971 01 ADD 2972 92 SWAP3 2973 91 SWAP2 2974 50 POP 2975 50 POP 2976 56 *JUMP 2977 5B JUMPDEST 2978 60 PUSH1 0x00 297A 61 PUSH2 0x2984 297D 60 PUSH1 0x2c 297F 83 DUP4 2980 61 PUSH2 0x3071 2983 56 *JUMP 2984 5B JUMPDEST 2985 7F PUSH32 0x4552433732314d657461646174613a2055524920736574206f66206e6f6e6578 29A6 81 DUP2 29A7 52 MSTORE 29A8 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 29B5 60 PUSH1 0xa1 29B7 1B SHL 29B8 60 PUSH1 0x20 29BA 82 DUP3 29BB 01 ADD 29BC 52 MSTORE 29BD 60 PUSH1 0x40 29BF 01 ADD 29C0 92 SWAP3 29C1 91 SWAP2 29C2 50 POP 29C3 50 POP 29C4 56 *JUMP label_29C5: // Incoming call from 0x2F14, returns to 0x0817 // Inputs[1] { @29CD stack[-1] } 29C5 5B JUMPDEST 29C6 60 PUSH1 0x00 29C8 61 PUSH2 0x29d2 29CB 60 PUSH1 0x20 29CD 83 DUP4 29CE 61 PUSH2 0x3071 29D1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @29C6 stack[0] = 0x00 // @29C8 stack[1] = 0x29d2 // @29CB stack[2] = 0x20 // @29CD stack[3] = stack[-1] // } // Block ends with call to 0x3071, returns to 0x29D2 label_29D2: // Incoming return from call to 0x3071 at 0x29D1 // Inputs[3] // { // @29F4 stack[-1] // @29F9 stack[-4] // @29FA stack[-3] // } 29D2 5B JUMPDEST 29D3 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 29F4 81 DUP2 29F5 52 MSTORE 29F6 60 PUSH1 0x20 29F8 01 ADD 29F9 92 SWAP3 29FA 91 SWAP2 29FB 50 POP 29FC 50 POP 29FD 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @29F5 memory[stack[-1]:stack[-1] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @29F9 stack[-4] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_29FE: // Incoming call from 0x2F24, returns to 0x0817 // Inputs[1] { @2A06 stack[-1] } 29FE 5B JUMPDEST 29FF 60 PUSH1 0x00 2A01 61 PUSH2 0x2a0b 2A04 60 PUSH1 0x22 2A06 83 DUP4 2A07 61 PUSH2 0x3071 2A0A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @29FF stack[0] = 0x00 // @2A01 stack[1] = 0x2a0b // @2A04 stack[2] = 0x22 // @2A06 stack[3] = stack[-1] // } // Block ends with call to 0x3071, returns to 0x2A0B label_2A0B: // Incoming return from call to 0x3071 at 0x2A0A // Inputs[3] // { // @2A2D stack[-1] // @2A3D stack[-4] // @2A3E stack[-3] // } 2A0B 5B JUMPDEST 2A0C 7F PUSH32 0x526f6c65733a206163636f756e7420697320746865207a65726f206164647265 2A2D 81 DUP2 2A2E 52 MSTORE 2A2F 61 PUSH2 0x7373 2A32 60 PUSH1 0xf0 2A34 1B SHL 2A35 60 PUSH1 0x20 2A37 82 DUP3 2A38 01 ADD 2A39 52 MSTORE 2A3A 60 PUSH1 0x40 2A3C 01 ADD 2A3D 92 SWAP3 2A3E 91 SWAP2 2A3F 50 POP 2A40 50 POP 2A41 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2A2E memory[stack[-1]:stack[-1] + 0x20] = 0x526f6c65733a206163636f756e7420697320746865207a65726f206164647265 // @2A39 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7373 << 0xf0 // @2A3D stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] 2A42 5B JUMPDEST 2A43 60 PUSH1 0x00 2A45 61 PUSH2 0x2a4f 2A48 60 PUSH1 0x29 2A4A 83 DUP4 2A4B 61 PUSH2 0x3071 2A4E 56 *JUMP 2A4F 5B JUMPDEST 2A50 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 2A71 81 DUP2 2A72 52 MSTORE 2A73 68 PUSH9 0x39903737ba1037bbb7 2A7D 60 PUSH1 0xb9 2A7F 1B SHL 2A80 60 PUSH1 0x20 2A82 82 DUP3 2A83 01 ADD 2A84 52 MSTORE 2A85 60 PUSH1 0x40 2A87 01 ADD 2A88 92 SWAP3 2A89 91 SWAP2 2A8A 50 POP 2A8B 50 POP 2A8C 56 *JUMP 2A8D 5B JUMPDEST 2A8E 60 PUSH1 0x00 2A90 61 PUSH2 0x2a9a 2A93 60 PUSH1 0x2f 2A95 83 DUP4 2A96 61 PUSH2 0x3071 2A99 56 *JUMP 2A9A 5B JUMPDEST 2A9B 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 2ABC 81 DUP2 2ABD 52 MSTORE 2ABE 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 2ACE 60 PUSH1 0x89 2AD0 1B SHL 2AD1 60 PUSH1 0x20 2AD3 82 DUP3 2AD4 01 ADD 2AD5 52 MSTORE 2AD6 60 PUSH1 0x40 2AD8 01 ADD 2AD9 92 SWAP3 2ADA 91 SWAP2 2ADB 50 POP 2ADC 50 POP 2ADD 56 *JUMP 2ADE 5B JUMPDEST 2ADF 60 PUSH1 0x00 2AE1 61 PUSH2 0x2aeb 2AE4 60 PUSH1 0x21 2AE6 83 DUP4 2AE7 61 PUSH2 0x3071 2AEA 56 *JUMP 2AEB 5B JUMPDEST 2AEC 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 2B0D 81 DUP2 2B0E 52 MSTORE 2B0F 60 PUSH1 0x39 2B11 60 PUSH1 0xf9 2B13 1B SHL 2B14 60 PUSH1 0x20 2B16 82 DUP3 2B17 01 ADD 2B18 52 MSTORE 2B19 60 PUSH1 0x40 2B1B 01 ADD 2B1C 92 SWAP3 2B1D 91 SWAP2 2B1E 50 POP 2B1F 50 POP 2B20 56 *JUMP 2B21 5B JUMPDEST 2B22 60 PUSH1 0x00 2B24 61 PUSH2 0x2b2e 2B27 60 PUSH1 0x31 2B29 83 DUP4 2B2A 61 PUSH2 0x3071 2B2D 56 *JUMP 2B2E 5B JUMPDEST 2B2F 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2B50 81 DUP2 2B51 52 MSTORE 2B52 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 2B64 60 PUSH1 0x7a 2B66 1B SHL 2B67 60 PUSH1 0x20 2B69 82 DUP3 2B6A 01 ADD 2B6B 52 MSTORE 2B6C 60 PUSH1 0x40 2B6E 01 ADD 2B6F 92 SWAP3 2B70 91 SWAP2 2B71 50 POP 2B72 50 POP 2B73 56 *JUMP 2B74 5B JUMPDEST 2B75 60 PUSH1 0x00 2B77 61 PUSH2 0x2b81 2B7A 60 PUSH1 0x2c 2B7C 83 DUP4 2B7D 61 PUSH2 0x3071 2B80 56 *JUMP 2B81 5B JUMPDEST 2B82 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 2BA3 81 DUP2 2BA4 52 MSTORE 2BA5 6B PUSH12 0x7574206f6620626f756e6473 2BB2 60 PUSH1 0xa0 2BB4 1B SHL 2BB5 60 PUSH1 0x20 2BB7 82 DUP3 2BB8 01 ADD 2BB9 52 MSTORE 2BBA 60 PUSH1 0x40 2BBC 01 ADD 2BBD 92 SWAP3 2BBE 91 SWAP2 2BBF 50 POP 2BC0 50 POP 2BC1 56 *JUMP 2BC2 5B JUMPDEST 2BC3 60 PUSH1 0x00 2BC5 61 PUSH2 0x2bcf 2BC8 60 PUSH1 0x25 2BCA 83 DUP4 2BCB 61 PUSH2 0x3071 2BCE 56 *JUMP 2BCF 5B JUMPDEST 2BD0 7F PUSH32 0x4552433732313a206275726e206f6620746f6b656e2074686174206973206e6f 2BF1 81 DUP2 2BF2 52 MSTORE 2BF3 64 PUSH5 0x3a1037bbb7 2BF9 60 PUSH1 0xd9 2BFB 1B SHL 2BFC 60 PUSH1 0x20 2BFE 82 DUP3 2BFF 01 ADD 2C00 52 MSTORE 2C01 60 PUSH1 0x40 2C03 01 ADD 2C04 92 SWAP3 2C05 91 SWAP2 2C06 50 POP 2C07 50 POP 2C08 56 *JUMP 2C09 5B JUMPDEST 2C0A 60 PUSH1 0x00 2C0C 61 PUSH2 0x2c16 2C0F 60 PUSH1 0x1b 2C11 83 DUP4 2C12 61 PUSH2 0x3071 2C15 56 *JUMP 2C16 5B JUMPDEST 2C17 7F PUSH32 0x526563697069656e742073686f756c642062652070726573656e740000000000 2C38 81 DUP2 2C39 52 MSTORE 2C3A 60 PUSH1 0x20 2C3C 01 ADD 2C3D 92 SWAP3 2C3E 91 SWAP2 2C3F 50 POP 2C40 50 POP 2C41 56 *JUMP 2C42 5B JUMPDEST 2C43 60 PUSH1 0x00 2C45 61 PUSH2 0x2c4f 2C48 60 PUSH1 0x30 2C4A 83 DUP4 2C4B 61 PUSH2 0x3071 2C4E 56 *JUMP 2C4F 5B JUMPDEST 2C50 7F PUSH32 0x4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f77 2C71 81 DUP2 2C72 52 MSTORE 2C73 6F PUSH16 0x1b995c881b9bdc88185c1c1c9bdd9959 2C84 60 PUSH1 0x82 2C86 1B SHL 2C87 60 PUSH1 0x20 2C89 82 DUP3 2C8A 01 ADD 2C8B 52 MSTORE 2C8C 60 PUSH1 0x40 2C8E 01 ADD 2C8F 92 SWAP3 2C90 91 SWAP2 2C91 50 POP 2C92 50 POP 2C93 56 *JUMP 2C94 5B JUMPDEST 2C95 60 PUSH1 0x00 2C97 61 PUSH2 0x2ca1 2C9A 60 PUSH1 0x1a 2C9C 83 DUP4 2C9D 61 PUSH2 0x3071 2CA0 56 *JUMP 2CA1 5B JUMPDEST 2CA2 7F PUSH32 0x7369676e65722073686f756c64207369676e20746f6b656e4964000000000000 2CC3 81 DUP2 2CC4 52 MSTORE 2CC5 60 PUSH1 0x20 2CC7 01 ADD 2CC8 92 SWAP3 2CC9 91 SWAP2 2CCA 50 POP 2CCB 50 POP 2CCC 56 *JUMP 2CCD 5B JUMPDEST 2CCE 61 PUSH2 0x23d1 2CD1 61 PUSH2 0x2cd9 2CD4 82 DUP3 2CD5 61 PUSH2 0x077c 2CD8 56 *JUMP 2CD9 5B JUMPDEST 2CDA 61 PUSH2 0x077c 2CDD 56 *JUMP 2CDE 5B JUMPDEST 2CDF 61 PUSH2 0x23d1 2CE2 81 DUP2 2CE3 61 PUSH2 0x30a8 2CE6 56 *JUMP 2CE7 5B JUMPDEST 2CE8 60 PUSH1 0x00 2CEA 61 PUSH2 0x1b3b 2CED 82 DUP3 2CEE 84 DUP5 2CEF 61 PUSH2 0x2516 2CF2 56 *JUMP 2CF3 5B JUMPDEST 2CF4 60 PUSH1 0x00 2CF6 61 PUSH2 0x2cff 2CF9 82 DUP3 2CFA 85 DUP6 2CFB 61 PUSH2 0x2545 2CFE 56 *JUMP 2CFF 5B JUMPDEST 2D00 60 PUSH1 0x14 2D02 82 DUP3 2D03 01 ADD 2D04 91 SWAP2 2D05 50 POP 2D06 61 PUSH2 0x2d0f 2D09 82 DUP3 2D0A 84 DUP5 2D0B 61 PUSH2 0x2ccd 2D0E 56 *JUMP 2D0F 5B JUMPDEST 2D10 50 POP 2D11 60 PUSH1 0x20 2D13 01 ADD 2D14 92 SWAP3 2D15 91 SWAP2 2D16 50 POP 2D17 50 POP 2D18 56 *JUMP label_2D19: // Incoming jump from 0x025D // Inputs[2] // { // @2D1C stack[-1] // @2D22 stack[-2] // } 2D19 5B JUMPDEST 2D1A 60 PUSH1 0x20 2D1C 81 DUP2 2D1D 01 ADD 2D1E 61 PUSH2 0x0817 2D21 82 DUP3 2D22 84 DUP5 2D23 61 PUSH2 0x23c8 2D26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2D1D stack[0] = stack[-1] + 0x20 // @2D1E stack[1] = 0x0817 // @2D21 stack[2] = stack[-1] // @2D22 stack[3] = stack[-2] // } // Block ends with call to 0x23c8, returns to 0x0817 2D27 5B JUMPDEST 2D28 60 PUSH1 0x80 2D2A 81 DUP2 2D2B 01 ADD 2D2C 61 PUSH2 0x2d35 2D2F 82 DUP3 2D30 87 DUP8 2D31 61 PUSH2 0x23c8 2D34 56 *JUMP 2D35 5B JUMPDEST 2D36 61 PUSH2 0x2d42 2D39 60 PUSH1 0x20 2D3B 83 DUP4 2D3C 01 ADD 2D3D 86 DUP7 2D3E 61 PUSH2 0x23c8 2D41 56 *JUMP 2D42 5B JUMPDEST 2D43 61 PUSH2 0x2d4f 2D46 60 PUSH1 0x40 2D48 83 DUP4 2D49 01 ADD 2D4A 85 DUP6 2D4B 61 PUSH2 0x24d5 2D4E 56 *JUMP 2D4F 5B JUMPDEST 2D50 81 DUP2 2D51 81 DUP2 2D52 03 SUB 2D53 60 PUSH1 0x60 2D55 83 DUP4 2D56 01 ADD 2D57 52 MSTORE 2D58 61 PUSH2 0x2d61 2D5B 81 DUP2 2D5C 84 DUP5 2D5D 61 PUSH2 0x24de 2D60 56 *JUMP 2D61 5B JUMPDEST 2D62 96 SWAP7 2D63 95 SWAP6 2D64 50 POP 2D65 50 POP 2D66 50 POP 2D67 50 POP 2D68 50 POP 2D69 50 POP 2D6A 56 *JUMP 2D6B 5B JUMPDEST 2D6C 60 PUSH1 0x40 2D6E 81 DUP2 2D6F 01 ADD 2D70 61 PUSH2 0x2d79 2D73 82 DUP3 2D74 85 DUP6 2D75 61 PUSH2 0x23c8 2D78 56 *JUMP 2D79 5B JUMPDEST 2D7A 61 PUSH2 0x1b3b 2D7D 60 PUSH1 0x20 2D7F 83 DUP4 2D80 01 ADD 2D81 84 DUP5 2D82 61 PUSH2 0x24d5 2D85 56 *JUMP 2D86 5B JUMPDEST 2D87 60 PUSH1 0x20 2D89 80 DUP1 2D8A 82 DUP3 2D8B 52 MSTORE 2D8C 81 DUP2 2D8D 01 ADD 2D8E 61 PUSH2 0x1b3b 2D91 81 DUP2 2D92 84 DUP5 2D93 61 PUSH2 0x2430 2D96 56 *JUMP 2D97 5B JUMPDEST 2D98 60 PUSH1 0x20 2D9A 80 DUP1 2D9B 82 DUP3 2D9C 52 MSTORE 2D9D 81 DUP2 2D9E 01 ADD 2D9F 61 PUSH2 0x1b3b 2DA2 81 DUP2 2DA3 84 DUP5 2DA4 61 PUSH2 0x247e 2DA7 56 *JUMP label_2DA8: // Incoming jump from 0x021F // Inputs[2] // { // @2DAB stack[-1] // @2DB1 stack[-2] // } 2DA8 5B JUMPDEST 2DA9 60 PUSH1 0x20 2DAB 81 DUP2 2DAC 01 ADD 2DAD 61 PUSH2 0x0817 2DB0 82 DUP3 2DB1 84 DUP5 2DB2 61 PUSH2 0x24cc 2DB5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2DAC stack[0] = stack[-1] + 0x20 // @2DAD stack[1] = 0x0817 // @2DB0 stack[2] = stack[-1] // @2DB1 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x24cc 2DB6 5B JUMPDEST 2DB7 60 PUSH1 0x80 2DB9 81 DUP2 2DBA 01 ADD 2DBB 61 PUSH2 0x2dc4 2DBE 82 DUP3 2DBF 87 DUP8 2DC0 61 PUSH2 0x24d5 2DC3 56 *JUMP 2DC4 5B JUMPDEST 2DC5 61 PUSH2 0x2dd1 2DC8 60 PUSH1 0x20 2DCA 83 DUP4 2DCB 01 ADD 2DCC 86 DUP7 2DCD 61 PUSH2 0x2cde 2DD0 56 *JUMP 2DD1 5B JUMPDEST 2DD2 61 PUSH2 0x2dde 2DD5 60 PUSH1 0x40 2DD7 83 DUP4 2DD8 01 ADD 2DD9 85 DUP6 2DDA 61 PUSH2 0x24d5 2DDD 56 *JUMP 2DDE 5B JUMPDEST 2DDF 61 PUSH2 0x2deb 2DE2 60 PUSH1 0x60 2DE4 83 DUP4 2DE5 01 ADD 2DE6 84 DUP5 2DE7 61 PUSH2 0x24d5 2DEA 56 *JUMP 2DEB 5B JUMPDEST 2DEC 95 SWAP6 2DED 94 SWAP5 2DEE 50 POP 2DEF 50 POP 2DF0 50 POP 2DF1 50 POP 2DF2 50 POP 2DF3 56 *JUMP label_2DF4: // Incoming call from 0x023D, returns to 0x0220 // Inputs[2] // { // @2DF8 stack[-1] // @2E00 stack[-2] // } 2DF4 5B JUMPDEST 2DF5 60 PUSH1 0x20 2DF7 80 DUP1 2DF8 82 DUP3 2DF9 52 MSTORE 2DFA 81 DUP2 2DFB 01 ADD 2DFC 61 PUSH2 0x1b3b 2DFF 81 DUP2 2E00 84 DUP5 2E01 61 PUSH2 0x24de 2E04 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2DF9 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2DFB stack[0] = stack[-1] + 0x20 // @2DFC stack[1] = 0x1b3b // @2DFF stack[2] = stack[-1] + 0x20 // @2E00 stack[3] = stack[-2] // } // Block ends with call to 0x24de, returns to 0x1B3B 2E05 5B JUMPDEST 2E06 60 PUSH1 0x20 2E08 80 DUP1 2E09 82 DUP3 2E0A 52 MSTORE 2E0B 81 DUP2 2E0C 01 ADD 2E0D 61 PUSH2 0x0817 2E10 81 DUP2 2E11 61 PUSH2 0x2556 2E14 56 *JUMP 2E15 5B JUMPDEST 2E16 60 PUSH1 0x20 2E18 80 DUP1 2E19 82 DUP3 2E1A 52 MSTORE 2E1B 81 DUP2 2E1C 01 ADD 2E1D 61 PUSH2 0x0817 2E20 81 DUP2 2E21 61 PUSH2 0x258f 2E24 56 *JUMP 2E25 5B JUMPDEST 2E26 60 PUSH1 0x20 2E28 80 DUP1 2E29 82 DUP3 2E2A 52 MSTORE 2E2B 81 DUP2 2E2C 01 ADD 2E2D 61 PUSH2 0x0817 2E30 81 DUP2 2E31 61 PUSH2 0x25c8 2E34 56 *JUMP 2E35 5B JUMPDEST 2E36 60 PUSH1 0x20 2E38 80 DUP1 2E39 82 DUP3 2E3A 52 MSTORE 2E3B 81 DUP2 2E3C 01 ADD 2E3D 61 PUSH2 0x0817 2E40 81 DUP2 2E41 61 PUSH2 0x2615 2E44 56 *JUMP 2E45 5B JUMPDEST 2E46 60 PUSH1 0x20 2E48 80 DUP1 2E49 82 DUP3 2E4A 52 MSTORE 2E4B 81 DUP2 2E4C 01 ADD 2E4D 61 PUSH2 0x0817 2E50 81 DUP2 2E51 61 PUSH2 0x2669 2E54 56 *JUMP 2E55 5B JUMPDEST 2E56 60 PUSH1 0x20 2E58 80 DUP1 2E59 82 DUP3 2E5A 52 MSTORE 2E5B 81 DUP2 2E5C 01 ADD 2E5D 61 PUSH2 0x0817 2E60 81 DUP2 2E61 61 PUSH2 0x26b1 2E64 56 *JUMP 2E65 5B JUMPDEST 2E66 60 PUSH1 0x20 2E68 80 DUP1 2E69 82 DUP3 2E6A 52 MSTORE 2E6B 81 DUP2 2E6C 01 ADD 2E6D 61 PUSH2 0x0817 2E70 81 DUP2 2E71 61 PUSH2 0x26ea 2E74 56 *JUMP 2E75 5B JUMPDEST 2E76 60 PUSH1 0x20 2E78 80 DUP1 2E79 82 DUP3 2E7A 52 MSTORE 2E7B 81 DUP2 2E7C 01 ADD 2E7D 61 PUSH2 0x0817 2E80 81 DUP2 2E81 61 PUSH2 0x2730 2E84 56 *JUMP 2E85 5B JUMPDEST 2E86 60 PUSH1 0x20 2E88 80 DUP1 2E89 82 DUP3 2E8A 52 MSTORE 2E8B 81 DUP2 2E8C 01 ADD 2E8D 61 PUSH2 0x0817 2E90 81 DUP2 2E91 61 PUSH2 0x2769 2E94 56 *JUMP 2E95 5B JUMPDEST 2E96 60 PUSH1 0x20 2E98 80 DUP1 2E99 82 DUP3 2E9A 52 MSTORE 2E9B 81 DUP2 2E9C 01 ADD 2E9D 61 PUSH2 0x0817 2EA0 81 DUP2 2EA1 61 PUSH2 0x27b7 2EA4 56 *JUMP 2EA5 5B JUMPDEST 2EA6 60 PUSH1 0x20 2EA8 80 DUP1 2EA9 82 DUP3 2EAA 52 MSTORE 2EAB 81 DUP2 2EAC 01 ADD 2EAD 61 PUSH2 0x0817 2EB0 81 DUP2 2EB1 61 PUSH2 0x2816 2EB4 56 *JUMP 2EB5 5B JUMPDEST 2EB6 60 PUSH1 0x20 2EB8 80 DUP1 2EB9 82 DUP3 2EBA 52 MSTORE 2EBB 81 DUP2 2EBC 01 ADD 2EBD 61 PUSH2 0x0817 2EC0 81 DUP2 2EC1 61 PUSH2 0x2862 2EC4 56 *JUMP label_2EC5: // Incoming jump from 0x157F // Inputs[1] { @2EC9 stack[-1] } 2EC5 5B JUMPDEST 2EC6 60 PUSH1 0x20 2EC8 80 DUP1 2EC9 82 DUP3 2ECA 52 MSTORE 2ECB 81 DUP2 2ECC 01 ADD 2ECD 61 PUSH2 0x0817 2ED0 81 DUP2 2ED1 61 PUSH2 0x28ad 2ED4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2ECA memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2ECC stack[0] = stack[-1] + 0x20 // @2ECD stack[1] = 0x0817 // @2ED0 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x28ad, returns to 0x0817 2ED5 5B JUMPDEST 2ED6 60 PUSH1 0x20 2ED8 80 DUP1 2ED9 82 DUP3 2EDA 52 MSTORE 2EDB 81 DUP2 2EDC 01 ADD 2EDD 61 PUSH2 0x0817 2EE0 81 DUP2 2EE1 61 PUSH2 0x28f0 2EE4 56 *JUMP 2EE5 5B JUMPDEST 2EE6 60 PUSH1 0x20 2EE8 80 DUP1 2EE9 82 DUP3 2EEA 52 MSTORE 2EEB 81 DUP2 2EEC 01 ADD 2EED 61 PUSH2 0x0817 2EF0 81 DUP2 2EF1 61 PUSH2 0x2929 2EF4 56 *JUMP 2EF5 5B JUMPDEST 2EF6 60 PUSH1 0x20 2EF8 80 DUP1 2EF9 82 DUP3 2EFA 52 MSTORE 2EFB 81 DUP2 2EFC 01 ADD 2EFD 61 PUSH2 0x0817 2F00 81 DUP2 2F01 61 PUSH2 0x2977 2F04 56 *JUMP label_2F05: // Incoming jump from 0x0BAB // Incoming jump from 0x0B23 // Incoming jump from 0x0A6F // Inputs[1] { @2F09 stack[-1] } 2F05 5B JUMPDEST 2F06 60 PUSH1 0x20 2F08 80 DUP1 2F09 82 DUP3 2F0A 52 MSTORE 2F0B 81 DUP2 2F0C 01 ADD 2F0D 61 PUSH2 0x0817 2F10 81 DUP2 2F11 61 PUSH2 0x29c5 2F14 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2F0A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2F0C stack[0] = stack[-1] + 0x20 // @2F0D stack[1] = 0x0817 // @2F10 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x29c5, returns to 0x0817 label_2F15: // Incoming jump from 0x12DC // Inputs[1] { @2F19 stack[-1] } 2F15 5B JUMPDEST 2F16 60 PUSH1 0x20 2F18 80 DUP1 2F19 82 DUP3 2F1A 52 MSTORE 2F1B 81 DUP2 2F1C 01 ADD 2F1D 61 PUSH2 0x0817 2F20 81 DUP2 2F21 61 PUSH2 0x29fe 2F24 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2F1A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2F1C stack[0] = stack[-1] + 0x20 // @2F1D stack[1] = 0x0817 // @2F20 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x29fe, returns to 0x0817 2F25 5B JUMPDEST 2F26 60 PUSH1 0x20 2F28 80 DUP1 2F29 82 DUP3 2F2A 52 MSTORE 2F2B 81 DUP2 2F2C 01 ADD 2F2D 61 PUSH2 0x0817 2F30 81 DUP2 2F31 61 PUSH2 0x2a42 2F34 56 *JUMP 2F35 5B JUMPDEST 2F36 60 PUSH1 0x20 2F38 80 DUP1 2F39 82 DUP3 2F3A 52 MSTORE 2F3B 81 DUP2 2F3C 01 ADD 2F3D 61 PUSH2 0x0817 2F40 81 DUP2 2F41 61 PUSH2 0x2a8d 2F44 56 *JUMP 2F45 5B JUMPDEST 2F46 60 PUSH1 0x20 2F48 80 DUP1 2F49 82 DUP3 2F4A 52 MSTORE 2F4B 81 DUP2 2F4C 01 ADD 2F4D 61 PUSH2 0x0817 2F50 81 DUP2 2F51 61 PUSH2 0x2ade 2F54 56 *JUMP 2F55 5B JUMPDEST 2F56 60 PUSH1 0x20 2F58 80 DUP1 2F59 82 DUP3 2F5A 52 MSTORE 2F5B 81 DUP2 2F5C 01 ADD 2F5D 61 PUSH2 0x0817 2F60 81 DUP2 2F61 61 PUSH2 0x2b21 2F64 56 *JUMP 2F65 5B JUMPDEST 2F66 60 PUSH1 0x20 2F68 80 DUP1 2F69 82 DUP3 2F6A 52 MSTORE 2F6B 81 DUP2 2F6C 01 ADD 2F6D 61 PUSH2 0x0817 2F70 81 DUP2 2F71 61 PUSH2 0x2b74 2F74 56 *JUMP 2F75 5B JUMPDEST 2F76 60 PUSH1 0x20 2F78 80 DUP1 2F79 82 DUP3 2F7A 52 MSTORE 2F7B 81 DUP2 2F7C 01 ADD 2F7D 61 PUSH2 0x0817 2F80 81 DUP2 2F81 61 PUSH2 0x2bc2 2F84 56 *JUMP 2F85 5B JUMPDEST 2F86 60 PUSH1 0x20 2F88 80 DUP1 2F89 82 DUP3 2F8A 52 MSTORE 2F8B 81 DUP2 2F8C 01 ADD 2F8D 61 PUSH2 0x0817 2F90 81 DUP2 2F91 61 PUSH2 0x2c09 2F94 56 *JUMP 2F95 5B JUMPDEST 2F96 60 PUSH1 0x20 2F98 80 DUP1 2F99 82 DUP3 2F9A 52 MSTORE 2F9B 81 DUP2 2F9C 01 ADD 2F9D 61 PUSH2 0x0817 2FA0 81 DUP2 2FA1 61 PUSH2 0x2c42 2FA4 56 *JUMP 2FA5 5B JUMPDEST 2FA6 60 PUSH1 0x20 2FA8 80 DUP1 2FA9 82 DUP3 2FAA 52 MSTORE 2FAB 81 DUP2 2FAC 01 ADD 2FAD 61 PUSH2 0x0817 2FB0 81 DUP2 2FB1 61 PUSH2 0x2c94 2FB4 56 *JUMP label_2FB5: // Incoming jump from 0x02BA // Inputs[2] // { // @2FB8 stack[-1] // @2FBE stack[-2] // } 2FB5 5B JUMPDEST 2FB6 60 PUSH1 0x20 2FB8 81 DUP2 2FB9 01 ADD 2FBA 61 PUSH2 0x0817 2FBD 82 DUP3 2FBE 84 DUP5 2FBF 61 PUSH2 0x24d5 2FC2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2FB9 stack[0] = stack[-1] + 0x20 // @2FBA stack[1] = 0x0817 // @2FBD stack[2] = stack[-1] // @2FBE stack[3] = stack[-2] // } // Block ends with call to 0x24d5, returns to 0x0817 2FC3 5B JUMPDEST 2FC4 60 PUSH1 0x60 2FC6 81 DUP2 2FC7 01 ADD 2FC8 61 PUSH2 0x2fd1 2FCB 82 DUP3 2FCC 86 DUP7 2FCD 61 PUSH2 0x24d5 2FD0 56 *JUMP 2FD1 5B JUMPDEST 2FD2 81 DUP2 2FD3 81 DUP2 2FD4 03 SUB 2FD5 60 PUSH1 0x20 2FD7 83 DUP4 2FD8 01 ADD 2FD9 52 MSTORE 2FDA 61 PUSH2 0x2fe3 2FDD 81 DUP2 2FDE 85 DUP6 2FDF 61 PUSH2 0x23d7 2FE2 56 *JUMP 2FE3 5B JUMPDEST 2FE4 90 SWAP1 2FE5 50 POP 2FE6 81 DUP2 2FE7 81 DUP2 2FE8 03 SUB 2FE9 60 PUSH1 0x40 2FEB 83 DUP4 2FEC 01 ADD 2FED 52 MSTORE 2FEE 61 PUSH2 0x2deb 2FF1 81 DUP2 2FF2 84 DUP5 2FF3 61 PUSH2 0x247e 2FF6 56 *JUMP label_2FF7: // Incoming jump from 0x1F9A // Inputs[2] // { // @2FFA memory[0x40:0x60] // @2FFB stack[-1] // } 2FF7 5B JUMPDEST 2FF8 60 PUSH1 0x40 2FFA 51 MLOAD 2FFB 81 DUP2 2FFC 81 DUP2 2FFD 01 ADD 2FFE 67 PUSH8 0xffffffffffffffff 3007 81 DUP2 3008 11 GT 3009 82 DUP3 300A 82 DUP3 300B 10 LT 300C 17 OR 300D 15 ISZERO 300E 61 PUSH2 0x3016 3011 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2FFA stack[0] = memory[0x40:0x60] // @2FFD stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x3016, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) label_3012: // Incoming jump from 0x3011, if not !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[1] { @3015 memory[0x00:0x00] } 3012 60 PUSH1 0x00 3014 80 DUP1 3015 FD *REVERT // Stack delta = +0 // Outputs[1] { @3015 revert(memory[0x00:0x00]); } // Block terminates label_3016: // Incoming jump from 0x3011, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[4] // { // @3019 stack[-1] // @301A stack[-4] // @301A stack[-2] // @301B stack[-3] // } 3016 5B JUMPDEST 3017 60 PUSH1 0x40 3019 52 MSTORE 301A 91 SWAP2 301B 90 SWAP1 301C 50 POP 301D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3019 memory[0x40:0x60] = stack[-1] // @301A stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] 301E 5B JUMPDEST 301F 60 PUSH1 0x00 3021 67 PUSH8 0xffffffffffffffff 302A 82 DUP3 302B 11 GT 302C 15 ISZERO 302D 61 PUSH2 0x3035 3030 57 *JUMPI 3031 60 PUSH1 0x00 3033 80 DUP1 3034 FD *REVERT 3035 5B JUMPDEST 3036 50 POP 3037 60 PUSH1 0x20 3039 90 SWAP1 303A 81 DUP2 303B 02 MUL 303C 01 ADD 303D 90 SWAP1 303E 56 *JUMP label_303F: // Incoming call from 0x2042, returns to 0x1F96 // Inputs[1] { @304B stack[-1] } 303F 5B JUMPDEST 3040 60 PUSH1 0x00 3042 67 PUSH8 0xffffffffffffffff 304B 82 DUP3 304C 11 GT 304D 15 ISZERO 304E 61 PUSH2 0x3056 3051 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3040 stack[0] = 0x00 } // Block ends with conditional jump to 0x3056, if !(stack[-1] > 0xffffffffffffffff) label_3052: // Incoming jump from 0x3051, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @3055 memory[0x00:0x00] } 3052 60 PUSH1 0x00 3054 80 DUP1 3055 FD *REVERT // Stack delta = +0 // Outputs[1] { @3055 revert(memory[0x00:0x00]); } // Block terminates label_3056: // Incoming jump from 0x3051, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @305C stack[-2] // @3065 stack[-3] // } 3056 5B JUMPDEST 3057 50 POP 3058 60 PUSH1 0x20 305A 60 PUSH1 0x1f 305C 91 SWAP2 305D 90 SWAP1 305E 91 SWAP2 305F 01 ADD 3060 60 PUSH1 0x1f 3062 19 NOT 3063 16 AND 3064 01 ADD 3065 90 SWAP1 3066 56 *JUMP // Stack delta = -2 // Outputs[1] { @3065 stack[-3] = (~0x1f & 0x1f + stack[-2]) + 0x20 } // Block ends with unconditional jump to stack[-3] 3067 5B JUMPDEST 3068 60 PUSH1 0x20 306A 01 ADD 306B 90 SWAP1 306C 56 *JUMP label_306D: // Incoming call from 0x24E8, returns to 0x24E9 // Inputs[3] // { // @306E stack[-1] // @306E memory[stack[-1]:stack[-1] + 0x20] // @306F stack[-2] // } 306D 5B JUMPDEST 306E 51 MLOAD 306F 90 SWAP1 3070 56 *JUMP // Stack delta = -1 // Outputs[1] { @306F stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_3071: // Incoming call from 0x29D1, returns to 0x29D2 // Incoming call from 0x2A0A, returns to 0x2A0B // Incoming call from 0x24F2, returns to 0x24F3 // Incoming call from 0x28B9, returns to 0x28BA // Inputs[3] // { // @3072 stack[-1] // @3072 stack[-2] // @3078 stack[-3] // } 3071 5B JUMPDEST 3072 90 SWAP1 3073 81 DUP2 3074 52 MSTORE 3075 60 PUSH1 0x20 3077 01 ADD 3078 90 SWAP1 3079 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3074 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @3078 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] 307A 5B JUMPDEST 307B 91 SWAP2 307C 90 SWAP1 307D 50 POP 307E 56 *JUMP label_307F: // Incoming call from 0x311A, returns to 0x311B // Incoming call from 0x23D0, returns to 0x23D1 // Inputs[1] { @3085 stack[-1] } 307F 5B JUMPDEST 3080 60 PUSH1 0x00 3082 61 PUSH2 0x0817 3085 82 DUP3 3086 61 PUSH2 0x309c 3089 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3080 stack[0] = 0x00 // @3082 stack[1] = 0x0817 // @3085 stack[2] = stack[-1] // } // Block ends with call to 0x309c, returns to 0x0817 label_308A: // Incoming call from 0x24D4, returns to 0x23D1 // Inputs[2] // { // @308B stack[-1] // @308D stack[-2] // } 308A 5B JUMPDEST 308B 15 ISZERO 308C 15 ISZERO 308D 90 SWAP1 308E 56 *JUMP // Stack delta = -1 // Outputs[1] { @308D stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_308F: // Incoming call from 0x3140, returns to 0x311B // Inputs[2] // { // @3099 stack[-1] // @309A stack[-2] // } 308F 5B JUMPDEST 3090 60 PUSH1 0x01 3092 60 PUSH1 0x01 3094 60 PUSH1 0xe0 3096 1B SHL 3097 03 SUB 3098 19 NOT 3099 16 AND 309A 90 SWAP1 309B 56 *JUMP // Stack delta = -1 // Outputs[1] { @309A stack[-2] = ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block ends with unconditional jump to stack[-2] label_309C: // Incoming call from 0x3089, returns to 0x0817 // Inputs[2] // { // @30A5 stack[-1] // @30A6 stack[-2] // } 309C 5B JUMPDEST 309D 60 PUSH1 0x01 309F 60 PUSH1 0x01 30A1 60 PUSH1 0xa0 30A3 1B SHL 30A4 03 SUB 30A5 16 AND 30A6 90 SWAP1 30A7 56 *JUMP // Stack delta = -1 // Outputs[1] { @30A6 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] } // Block ends with unconditional jump to stack[-2] 30A8 5B JUMPDEST 30A9 60 PUSH1 0xff 30AB 16 AND 30AC 90 SWAP1 30AD 56 *JUMP 30AE 5B JUMPDEST 30AF 60 PUSH1 0x00 30B1 61 PUSH2 0x0817 30B4 82 DUP3 30B5 61 PUSH2 0x307f 30B8 56 *JUMP label_30B9: // Incoming call from 0x2069, returns to 0x206A // Inputs[5] // { // @30BA stack[-3] // @30BB stack[-1] // @30BC stack[-2] // @30BD msg.data[stack[-1]:stack[-1] + stack[-3]] // @30C4 stack[-4] // } 30B9 5B JUMPDEST 30BA 82 DUP3 30BB 81 DUP2 30BC 83 DUP4 30BD 37 CALLDATACOPY 30BE 50 POP 30BF 60 PUSH1 0x00 30C1 91 SWAP2 30C2 01 ADD 30C3 52 MSTORE 30C4 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @30BD memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @30C3 memory[stack[-3] + stack[-2]:stack[-3] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_30C5: // Incoming call from 0x2502, returns to 0x2503 // Inputs[1] { @30C9 stack[-3] } 30C5 5B JUMPDEST 30C6 60 PUSH1 0x00 30C8 5B JUMPDEST 30C9 83 DUP4 30CA 81 DUP2 30CB 10 LT 30CC 15 ISZERO 30CD 61 PUSH2 0x30e0 30D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @30C6 stack[0] = 0x00 } // Block ends with conditional jump to 0x30e0, if !(0x00 < stack[-3]) label_30D1: // Incoming jump from 0x30D0, if not !(0x00 < stack[-3]) // Incoming jump from 0x30D0, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @30D1 stack[-2] // @30D2 stack[-1] // @30D4 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @30D5 stack[-3] // } 30D1 81 DUP2 30D2 81 DUP2 30D3 01 ADD 30D4 51 MLOAD 30D5 83 DUP4 30D6 82 DUP3 30D7 01 ADD 30D8 52 MSTORE 30D9 60 PUSH1 0x20 30DB 01 ADD 30DC 61 PUSH2 0x30c8 30DF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @30D8 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @30DB stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x30c8 label_30E0: // Incoming jump from 0x30D0, if !(0x00 < stack[-3]) // Incoming jump from 0x30D0, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @30E1 stack[-4] // @30E2 stack[-1] // } 30E0 5B JUMPDEST 30E1 83 DUP4 30E2 81 DUP2 30E3 11 GT 30E4 15 ISZERO 30E5 61 PUSH2 0x0cbc 30E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cbc, if !(stack[-1] > stack[-4]) label_30E9: // Incoming jump from 0x30E8, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @30ED stack[-4] // @30EE stack[-3] // @30F0 stack[-5] // } 30E9 50 POP 30EA 50 POP 30EB 60 PUSH1 0x00 30ED 91 SWAP2 30EE 01 ADD 30EF 52 MSTORE 30F0 56 *JUMP // Stack delta = -5 // Outputs[1] { @30EF memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] 30F1 5B JUMPDEST 30F2 60 PUSH1 0x00 30F4 61 PUSH2 0x0817 30F7 82 DUP3 30F8 60 PUSH1 0x00 30FA 61 PUSH2 0x0817 30FD 82 DUP3 30FE 61 PUSH2 0x310c 3101 56 *JUMP label_3102: // Incoming call from 0x250B, returns to 0x250C // Inputs[2] // { // @3105 stack[-1] // @310A stack[-2] // } 3102 5B JUMPDEST 3103 60 PUSH1 0x1f 3105 01 ADD 3106 60 PUSH1 0x1f 3108 19 NOT 3109 16 AND 310A 90 SWAP1 310B 56 *JUMP // Stack delta = -1 // Outputs[1] { @310A stack[-2] = ~0x1f & 0x1f + stack[-1] } // Block ends with unconditional jump to stack[-2] 310C 5B JUMPDEST 310D 60 PUSH1 0x60 310F 1B SHL 3110 90 SWAP1 3111 56 *JUMP label_3112: // Incoming jump from 0x1F76 // Inputs[1] { @3116 stack[-1] } 3112 5B JUMPDEST 3113 61 PUSH2 0x311b 3116 81 DUP2 3117 61 PUSH2 0x307f 311A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3113 stack[0] = 0x311b // @3116 stack[1] = stack[-1] // } // Block ends with call to 0x307f, returns to 0x311B label_311B: // Incoming return from call to 0x077C at 0x3137 // Incoming return from call to 0x308F at 0x3140 // Incoming return from call to 0x307F at 0x311A // Inputs[2] // { // @311C stack[-2] // @311D stack[-1] // } 311B 5B JUMPDEST 311C 81 DUP2 311D 14 EQ 311E 61 PUSH2 0x0682 3121 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0682, if stack[-2] == stack[-1] label_3122: // Incoming jump from 0x3121, if not stack[-2] == stack[-1] // Inputs[1] { @3125 memory[0x00:0x00] } 3122 60 PUSH1 0x00 3124 80 DUP1 3125 FD *REVERT // Stack delta = +0 // Outputs[1] { @3125 revert(memory[0x00:0x00]); } // Block terminates 3126 5B JUMPDEST 3127 61 PUSH2 0x311b 312A 81 DUP2 312B 61 PUSH2 0x308a 312E 56 *JUMP label_312F: // Incoming call from 0x200D, returns to 0x0817 // Inputs[1] { @3133 stack[-1] } 312F 5B JUMPDEST 3130 61 PUSH2 0x311b 3133 81 DUP2 3134 61 PUSH2 0x077c 3137 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3130 stack[0] = 0x311b // @3133 stack[1] = stack[-1] // } // Block ends with call to 0x077c, returns to 0x311B label_3138: // Incoming call from 0x2018, returns to 0x0817 // Inputs[1] { @313C stack[-1] } 3138 5B JUMPDEST 3139 61 PUSH2 0x311b 313C 81 DUP2 313D 61 PUSH2 0x308f 3140 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3139 stack[0] = 0x311b // @313C stack[1] = stack[-1] // } // Block ends with call to 0x308f, returns to 0x311B 3141 5B JUMPDEST 3142 61 PUSH2 0x311b 3145 81 DUP2 3146 61 PUSH2 0x30a8 3149 56 *JUMP 314A FE *ASSERT 314B A3 LOG3 314C 65 PUSH6 0x627a7a723158 3153 20 SHA3 3154 CB CB 3155 DB DB 3156 29 29 3157 BB BB 3158 11 GT 3159 BC BC 315A 4B 4B 315B AF AF 315C 42 TIMESTAMP 315D A2 LOG2 315E F6 F6 315F 22 22 3160 93 SWAP4 3161 55 SSTORE 3162 12 SLT 3163 5F 5F 3164 1B SHL 3165 AA AA 3166 73 PUSH20 0xcc291341c017423c96123797b56c657870657269 317B 6D PUSH14 0x656e74616cf564736f6c63430005 318A 11 GT 318B 00 *STOP 318C 40 BLOCKHASH