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 0x01cf 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01cf, 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 0x4f6ccce7 0026 11 GT 0027 61 PUSH2 0x0104 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0104, if 0x4f6ccce7 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x4f6ccce7 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa217fddf 0031 11 GT 0032 61 PUSH2 0x00a2 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a2, if 0xa217fddf > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa217fddf > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xca15c873 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xca15c873 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xca15c873 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xca15c873 0047 14 EQ 0048 61 PUSH2 0x03c2 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c2, if 0xca15c873 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xca15c873 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xd5391393 0052 14 EQ 0053 61 PUSH2 0x03d5 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d5, if 0xd5391393 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xd5391393 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xd547741f 005D 14 EQ 005E 61 PUSH2 0x03dd 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03dd, if 0xd547741f == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xd547741f == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xe985e9c5 0068 14 EQ 0069 61 PUSH2 0x03f0 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f0, if 0xe985e9c5 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xe985e9c5 == stack[-1] 006D 61 PUSH2 0x01cf 0070 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01cf label_0071: // Incoming jump from 0x0040, if 0xca15c873 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xa217fddf 0078 14 EQ 0079 61 PUSH2 0x0381 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0381, if 0xa217fddf == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xa217fddf == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xa22cb465 0083 14 EQ 0084 61 PUSH2 0x0389 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0389, if 0xa22cb465 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xb88d4fde 008E 14 EQ 008F 61 PUSH2 0x039c 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039c, if 0xb88d4fde == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xc87b56dd 0099 14 EQ 009A 61 PUSH2 0x03af 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03af, if 0xc87b56dd == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xc87b56dd == stack[-1] 009E 61 PUSH2 0x01cf 00A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01cf label_00A2: // Incoming jump from 0x0035, if 0xa217fddf > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0x70a08231 00A9 11 GT 00AA 61 PUSH2 0x00de 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00de, if 0x70a08231 > stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x70a08231 > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x70a08231 00B4 14 EQ 00B5 61 PUSH2 0x0340 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0340, if 0x70a08231 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x70a08231 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x9010d07c 00BF 14 EQ 00C0 61 PUSH2 0x0353 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0353, if 0x9010d07c == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x9010d07c == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x91d14854 00CA 14 EQ 00CB 61 PUSH2 0x0366 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0366, if 0x91d14854 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x91d14854 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x95d89b41 00D5 14 EQ 00D6 61 PUSH2 0x0379 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0379, if 0x95d89b41 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x95d89b41 == stack[-1] 00DA 61 PUSH2 0x01cf 00DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01cf label_00DE: // Incoming jump from 0x00AD, if 0x70a08231 > stack[-1] // Inputs[1] { @00DF stack[-1] } 00DE 5B JUMPDEST 00DF 80 DUP1 00E0 63 PUSH4 0x4f6ccce7 00E5 14 EQ 00E6 61 PUSH2 0x0307 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0307, if 0x4f6ccce7 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x55f804b3 00F0 14 EQ 00F1 61 PUSH2 0x031a 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031a, if 0x55f804b3 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x55f804b3 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x6352211e 00FB 14 EQ 00FC 61 PUSH2 0x032d 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032d, if 0x6352211e == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x6352211e == stack[-1] 0100 61 PUSH2 0x01cf 0103 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01cf label_0104: // Incoming jump from 0x002A, if 0x4f6ccce7 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0105 stack[-1] } 0104 5B JUMPDEST 0105 80 DUP1 0106 63 PUSH4 0x248a9ca3 010B 11 GT 010C 61 PUSH2 0x0171 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0171, if 0x248a9ca3 > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x248a9ca3 > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x36568abe 0116 11 GT 0117 61 PUSH2 0x014b 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x014b, if 0x36568abe > stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x36568abe > stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x36568abe 0121 14 EQ 0122 61 PUSH2 0x02bb 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bb, if 0x36568abe == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x36568abe == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x40c10f19 012C 14 EQ 012D 61 PUSH2 0x02ce 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ce, if 0x40c10f19 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x40c10f19 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x42842e0e 0137 14 EQ 0138 61 PUSH2 0x02e1 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e1, if 0x42842e0e == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x42842e0e == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x42966c68 0142 14 EQ 0143 61 PUSH2 0x02f4 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f4, if 0x42966c68 == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x42966c68 == stack[-1] 0147 61 PUSH2 0x01cf 014A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01cf label_014B: // Incoming jump from 0x011A, if 0x36568abe > stack[-1] // Inputs[1] { @014C stack[-1] } 014B 5B JUMPDEST 014C 80 DUP1 014D 63 PUSH4 0x248a9ca3 0152 14 EQ 0153 61 PUSH2 0x0282 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0282, if 0x248a9ca3 == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x2f2ff15d 015D 14 EQ 015E 61 PUSH2 0x0295 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0295, if 0x2f2ff15d == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @0162 stack[-1] } 0162 80 DUP1 0163 63 PUSH4 0x2f745c59 0168 14 EQ 0169 61 PUSH2 0x02a8 016C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a8, if 0x2f745c59 == stack[-1] label_016D: // Incoming jump from 0x016C, if not 0x2f745c59 == stack[-1] 016D 61 PUSH2 0x01cf 0170 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01cf label_0171: // Incoming jump from 0x010F, if 0x248a9ca3 > stack[-1] // Inputs[1] { @0172 stack[-1] } 0171 5B JUMPDEST 0172 80 DUP1 0173 63 PUSH4 0x095ea7b3 0178 11 GT 0179 61 PUSH2 0x01ad 017C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ad, if 0x095ea7b3 > stack[-1] label_017D: // Incoming jump from 0x017C, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @017D stack[-1] } 017D 80 DUP1 017E 63 PUSH4 0x095ea7b3 0183 14 EQ 0184 61 PUSH2 0x0232 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0232, if 0x095ea7b3 == stack[-1] label_0188: // Incoming jump from 0x0187, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0188 stack[-1] } 0188 80 DUP1 0189 63 PUSH4 0x162094c4 018E 14 EQ 018F 61 PUSH2 0x0247 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0247, if 0x162094c4 == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x162094c4 == stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x18160ddd 0199 14 EQ 019A 61 PUSH2 0x025a 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025a, if 0x18160ddd == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x18160ddd == stack[-1] // Inputs[1] { @019E stack[-1] } 019E 80 DUP1 019F 63 PUSH4 0x23b872dd 01A4 14 EQ 01A5 61 PUSH2 0x026f 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026f, if 0x23b872dd == stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x23b872dd == stack[-1] 01A9 61 PUSH2 0x01cf 01AC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01cf label_01AD: // Incoming jump from 0x017C, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01AE stack[-1] } 01AD 5B JUMPDEST 01AE 80 DUP1 01AF 63 PUSH4 0x01ffc9a7 01B4 14 EQ 01B5 61 PUSH2 0x01d4 01B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d4, if 0x01ffc9a7 == stack[-1] label_01B9: // Incoming jump from 0x01B8, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01B9 stack[-1] } 01B9 80 DUP1 01BA 63 PUSH4 0x06fdde03 01BF 14 EQ 01C0 61 PUSH2 0x01fd 01C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fd, if 0x06fdde03 == stack[-1] label_01C4: // Incoming jump from 0x01C3, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01C4 stack[-1] } 01C4 80 DUP1 01C5 63 PUSH4 0x081812fc 01CA 14 EQ 01CB 61 PUSH2 0x0212 01CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0212, if 0x081812fc == stack[-1] label_01CF: // Incoming jump from 0x01AC // Incoming jump from 0x00DD // Incoming jump from 0x014A // Incoming jump from 0x0070 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x01CE, if not 0x081812fc == stack[-1] // Incoming jump from 0x00A1 // Incoming jump from 0x0170 // Incoming jump from 0x0103 // Inputs[1] { @01D3 memory[0x00:0x00] } 01CF 5B JUMPDEST 01D0 60 PUSH1 0x00 01D2 80 DUP1 01D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D3 revert(memory[0x00:0x00]); } // Block terminates label_01D4: // Incoming jump from 0x01B8, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01DB msg.data.length } 01D4 5B JUMPDEST 01D5 61 PUSH2 0x01e7 01D8 61 PUSH2 0x01e2 01DB 36 CALLDATASIZE 01DC 60 PUSH1 0x04 01DE 61 PUSH2 0x1e23 01E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D5 stack[0] = 0x01e7 // @01D8 stack[1] = 0x01e2 // @01DB stack[2] = msg.data.length // @01DC stack[3] = 0x04 // } // Block ends with call to 0x1e23, returns to 0x01E2 label_01E2: // Incoming return from call to 0x1E23 at 0x01E1 01E2 5B JUMPDEST 01E3 61 PUSH2 0x0403 01E6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0403 label_01E7: // Incoming return from call to 0x0374 at 0x0373 // Inputs[2] // { // @01EA memory[0x40:0x60] // @01EE stack[-1] // } 01E7 5B JUMPDEST 01E8 60 PUSH1 0x40 01EA 51 MLOAD 01EB 61 PUSH2 0x01f4 01EE 91 SWAP2 01EF 90 SWAP1 01F0 61 PUSH2 0x1f7e 01F3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01EE stack[-1] = 0x01f4 // @01EF stack[1] = memory[0x40:0x60] // @01EF stack[0] = stack[-1] // } // Block ends with call to 0x1f7e, returns to 0x01F4 label_01F4: // Incoming return from call to 0x1F89 at 0x026E // Incoming return from call to 0x1F7E at 0x01F3 // Incoming return from call to 0x1F2E at 0x0231 // Inputs[3] // { // @01F7 memory[0x40:0x60] // @01F9 stack[-1] // @01FC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01F4 5B JUMPDEST 01F5 60 PUSH1 0x40 01F7 51 MLOAD 01F8 80 DUP1 01F9 91 SWAP2 01FA 03 SUB 01FB 90 SWAP1 01FC F3 *RETURN // Stack delta = -1 // Outputs[1] { @01FC return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01FD: // Incoming jump from 0x01C3, if 0x06fdde03 == stack[-1] 01FD 5B JUMPDEST 01FE 61 PUSH2 0x0205 0201 61 PUSH2 0x0430 0204 56 *JUMP // Stack delta = +1 // Outputs[1] { @01FE stack[0] = 0x0205 } // Block ends with call to 0x0430, returns to 0x0205 label_0205: // Incoming return from call to 0x0430 at 0x0204 // Incoming return from call to 0x08C1 at 0x0380 // Inputs[2] // { // @0208 memory[0x40:0x60] // @020C stack[-1] // } 0205 5B JUMPDEST 0206 60 PUSH1 0x40 0208 51 MLOAD 0209 61 PUSH2 0x01f4 020C 91 SWAP2 020D 90 SWAP1 020E 61 PUSH2 0x1f92 0211 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @020C stack[-1] = 0x01f4 // @020D stack[1] = memory[0x40:0x60] // @020D stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1f92 label_0212: // Incoming jump from 0x01CE, if 0x081812fc == stack[-1] // Inputs[1] { @0219 msg.data.length } 0212 5B JUMPDEST 0213 61 PUSH2 0x0225 0216 61 PUSH2 0x0220 0219 36 CALLDATASIZE 021A 60 PUSH1 0x04 021C 61 PUSH2 0x1dc8 021F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0213 stack[0] = 0x0225 // @0216 stack[1] = 0x0220 // @0219 stack[2] = msg.data.length // @021A stack[3] = 0x04 // } // Block ends with call to 0x1dc8, returns to 0x0220 label_0220: // Incoming return from call to 0x1DC8 at 0x021F 0220 5B JUMPDEST 0221 61 PUSH2 0x04c2 0224 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04c2 label_0225: // Incoming return from call to 0x0220 at 0x021F // Inputs[2] // { // @0228 memory[0x40:0x60] // @022C stack[-1] // } 0225 5B JUMPDEST 0226 60 PUSH1 0x40 0228 51 MLOAD 0229 61 PUSH2 0x01f4 022C 91 SWAP2 022D 90 SWAP1 022E 61 PUSH2 0x1f2e 0231 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @022C stack[-1] = 0x01f4 // @022D stack[1] = memory[0x40:0x60] // @022D stack[0] = stack[-1] // } // Block ends with call to 0x1f2e, returns to 0x01F4 label_0232: // Incoming jump from 0x0187, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0239 msg.data.length } 0232 5B JUMPDEST 0233 61 PUSH2 0x0245 0236 61 PUSH2 0x0240 0239 36 CALLDATASIZE 023A 60 PUSH1 0x04 023C 61 PUSH2 0x1d9f 023F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0233 stack[0] = 0x0245 // @0236 stack[1] = 0x0240 // @0239 stack[2] = msg.data.length // @023A stack[3] = 0x04 // } // Block ends with call to 0x1d9f, returns to 0x0240 label_0240: // Incoming return from call to 0x1D9F at 0x023F 0240 5B JUMPDEST 0241 61 PUSH2 0x050e 0244 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x050e label_0245: // Incoming return from call to 0x0397 at 0x0396 0245 5B JUMPDEST 0246 00 *STOP // Stack delta = +0 // Outputs[1] { @0246 stop(); } // Block terminates label_0247: // Incoming jump from 0x0192, if 0x162094c4 == stack[-1] // Inputs[1] { @024E msg.data.length } 0247 5B JUMPDEST 0248 61 PUSH2 0x0245 024B 61 PUSH2 0x0255 024E 36 CALLDATASIZE 024F 60 PUSH1 0x04 0251 61 PUSH2 0x1e8e 0254 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0248 stack[0] = 0x0245 // @024B stack[1] = 0x0255 // @024E stack[2] = msg.data.length // @024F stack[3] = 0x04 // } // Block ends with call to 0x1e8e, returns to 0x0255 label_0255: // Incoming return from call to 0x1E8E at 0x0254 0255 5B JUMPDEST 0256 61 PUSH2 0x05a6 0259 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05a6 label_025A: // Incoming jump from 0x019D, if 0x18160ddd == stack[-1] 025A 5B JUMPDEST 025B 61 PUSH2 0x0262 025E 61 PUSH2 0x05dd 0261 56 *JUMP // Stack delta = +1 // Outputs[1] { @025B stack[0] = 0x0262 } // Block ends with call to 0x05dd, returns to 0x0262 label_0262: // Incoming return from call to 0x05DD at 0x0261 // Incoming return from call to 0x0315 at 0x0314 // Incoming return from call to 0x02B6 at 0x02B5 // Incoming return from call to 0x0290 at 0x028F // Incoming return from call to 0x0A04 at 0x03DC // Incoming return from call to 0x034E at 0x034D // Incoming return from call to 0x08D0 at 0x0388 // Inputs[2] // { // @0265 memory[0x40:0x60] // @0269 stack[-1] // } 0262 5B JUMPDEST 0263 60 PUSH1 0x40 0265 51 MLOAD 0266 61 PUSH2 0x01f4 0269 91 SWAP2 026A 90 SWAP1 026B 61 PUSH2 0x1f89 026E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0269 stack[-1] = 0x01f4 // @026A stack[1] = memory[0x40:0x60] // @026A stack[0] = stack[-1] // } // Block ends with call to 0x1f89, returns to 0x01F4 label_026F: // Incoming jump from 0x01A8, if 0x23b872dd == stack[-1] // Inputs[1] { @0276 msg.data.length } 026F 5B JUMPDEST 0270 61 PUSH2 0x0245 0273 61 PUSH2 0x027d 0276 36 CALLDATASIZE 0277 60 PUSH1 0x04 0279 61 PUSH2 0x1cb1 027C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0270 stack[0] = 0x0245 // @0273 stack[1] = 0x027d // @0276 stack[2] = msg.data.length // @0277 stack[3] = 0x04 // } // Block ends with call to 0x1cb1, returns to 0x027D label_027D: // Incoming return from call to 0x1CB1 at 0x027C 027D 5B JUMPDEST 027E 61 PUSH2 0x05e3 0281 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05e3 label_0282: // Incoming jump from 0x0156, if 0x248a9ca3 == stack[-1] // Inputs[1] { @0289 msg.data.length } 0282 5B JUMPDEST 0283 61 PUSH2 0x0262 0286 61 PUSH2 0x0290 0289 36 CALLDATASIZE 028A 60 PUSH1 0x04 028C 61 PUSH2 0x1dc8 028F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0283 stack[0] = 0x0262 // @0286 stack[1] = 0x0290 // @0289 stack[2] = msg.data.length // @028A stack[3] = 0x04 // } // Block ends with call to 0x1dc8, returns to 0x0290 label_0290: // Incoming return from call to 0x1DC8 at 0x028F 0290 5B JUMPDEST 0291 61 PUSH2 0x061b 0294 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x061b label_0295: // Incoming jump from 0x0161, if 0x2f2ff15d == stack[-1] // Inputs[1] { @029C msg.data.length } 0295 5B JUMPDEST 0296 61 PUSH2 0x0245 0299 61 PUSH2 0x02a3 029C 36 CALLDATASIZE 029D 60 PUSH1 0x04 029F 61 PUSH2 0x1de0 02A2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0296 stack[0] = 0x0245 // @0299 stack[1] = 0x02a3 // @029C stack[2] = msg.data.length // @029D stack[3] = 0x04 // } // Block ends with call to 0x1de0, returns to 0x02A3 label_02A3: // Incoming return from call to 0x1DE0 at 0x02A2 02A3 5B JUMPDEST 02A4 61 PUSH2 0x0630 02A7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0630 label_02A8: // Incoming jump from 0x016C, if 0x2f745c59 == stack[-1] // Inputs[1] { @02AF msg.data.length } 02A8 5B JUMPDEST 02A9 61 PUSH2 0x0262 02AC 61 PUSH2 0x02b6 02AF 36 CALLDATASIZE 02B0 60 PUSH1 0x04 02B2 61 PUSH2 0x1d9f 02B5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A9 stack[0] = 0x0262 // @02AC stack[1] = 0x02b6 // @02AF stack[2] = msg.data.length // @02B0 stack[3] = 0x04 // } // Block ends with call to 0x1d9f, returns to 0x02B6 label_02B6: // Incoming return from call to 0x1D9F at 0x02B5 02B6 5B JUMPDEST 02B7 61 PUSH2 0x0652 02BA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0652 label_02BB: // Incoming jump from 0x0125, if 0x36568abe == stack[-1] // Inputs[1] { @02C2 msg.data.length } 02BB 5B JUMPDEST 02BC 61 PUSH2 0x0245 02BF 61 PUSH2 0x02c9 02C2 36 CALLDATASIZE 02C3 60 PUSH1 0x04 02C5 61 PUSH2 0x1de0 02C8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BC stack[0] = 0x0245 // @02BF stack[1] = 0x02c9 // @02C2 stack[2] = msg.data.length // @02C3 stack[3] = 0x04 // } // Block ends with call to 0x1de0, returns to 0x02C9 label_02C9: // Incoming return from call to 0x1DE0 at 0x02C8 02C9 5B JUMPDEST 02CA 61 PUSH2 0x06a7 02CD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06a7 label_02CE: // Incoming jump from 0x0130, if 0x40c10f19 == stack[-1] // Inputs[1] { @02D5 msg.data.length } 02CE 5B JUMPDEST 02CF 61 PUSH2 0x0245 02D2 61 PUSH2 0x02dc 02D5 36 CALLDATASIZE 02D6 60 PUSH1 0x04 02D8 61 PUSH2 0x1d9f 02DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02CF stack[0] = 0x0245 // @02D2 stack[1] = 0x02dc // @02D5 stack[2] = msg.data.length // @02D6 stack[3] = 0x04 // } // Block ends with call to 0x1d9f, returns to 0x02DC label_02DC: // Incoming return from call to 0x1D9F at 0x02DB 02DC 5B JUMPDEST 02DD 61 PUSH2 0x06c9 02E0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06c9 label_02E1: // Incoming jump from 0x013B, if 0x42842e0e == stack[-1] // Inputs[1] { @02E8 msg.data.length } 02E1 5B JUMPDEST 02E2 61 PUSH2 0x0245 02E5 61 PUSH2 0x02ef 02E8 36 CALLDATASIZE 02E9 60 PUSH1 0x04 02EB 61 PUSH2 0x1cb1 02EE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E2 stack[0] = 0x0245 // @02E5 stack[1] = 0x02ef // @02E8 stack[2] = msg.data.length // @02E9 stack[3] = 0x04 // } // Block ends with call to 0x1cb1, returns to 0x02EF label_02EF: // Incoming return from call to 0x1CB1 at 0x02EE 02EF 5B JUMPDEST 02F0 61 PUSH2 0x071b 02F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x071b label_02F4: // Incoming jump from 0x0146, if 0x42966c68 == stack[-1] // Inputs[1] { @02FB msg.data.length } 02F4 5B JUMPDEST 02F5 61 PUSH2 0x0245 02F8 61 PUSH2 0x0302 02FB 36 CALLDATASIZE 02FC 60 PUSH1 0x04 02FE 61 PUSH2 0x1dc8 0301 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F5 stack[0] = 0x0245 // @02F8 stack[1] = 0x0302 // @02FB stack[2] = msg.data.length // @02FC stack[3] = 0x04 // } // Block ends with call to 0x1dc8, returns to 0x0302 label_0302: // Incoming return from call to 0x1DC8 at 0x0301 0302 5B JUMPDEST 0303 61 PUSH2 0x0736 0306 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0736 label_0307: // Incoming jump from 0x00E9, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @030E msg.data.length } 0307 5B JUMPDEST 0308 61 PUSH2 0x0262 030B 61 PUSH2 0x0315 030E 36 CALLDATASIZE 030F 60 PUSH1 0x04 0311 61 PUSH2 0x1dc8 0314 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0308 stack[0] = 0x0262 // @030B stack[1] = 0x0315 // @030E stack[2] = msg.data.length // @030F stack[3] = 0x04 // } // Block ends with call to 0x1dc8, returns to 0x0315 label_0315: // Incoming return from call to 0x1DC8 at 0x0314 0315 5B JUMPDEST 0316 61 PUSH2 0x0769 0319 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0769 label_031A: // Incoming jump from 0x00F4, if 0x55f804b3 == stack[-1] // Inputs[1] { @0321 msg.data.length } 031A 5B JUMPDEST 031B 61 PUSH2 0x0245 031E 61 PUSH2 0x0328 0321 36 CALLDATASIZE 0322 60 PUSH1 0x04 0324 61 PUSH2 0x1e5b 0327 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @031B stack[0] = 0x0245 // @031E stack[1] = 0x0328 // @0321 stack[2] = msg.data.length // @0322 stack[3] = 0x04 // } // Block ends with call to 0x1e5b, returns to 0x0328 label_0328: // Incoming return from call to 0x1E5B at 0x0327 0328 5B JUMPDEST 0329 61 PUSH2 0x07c4 032C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07c4 label_032D: // Incoming jump from 0x00FF, if 0x6352211e == stack[-1] // Inputs[1] { @0334 msg.data.length } 032D 5B JUMPDEST 032E 61 PUSH2 0x0225 0331 61 PUSH2 0x033b 0334 36 CALLDATASIZE 0335 60 PUSH1 0x04 0337 61 PUSH2 0x1dc8 033A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @032E stack[0] = 0x0225 // @0331 stack[1] = 0x033b // @0334 stack[2] = msg.data.length // @0335 stack[3] = 0x04 // } // Block ends with call to 0x1dc8, returns to 0x033B label_033B: // Incoming return from call to 0x1DC8 at 0x033A 033B 5B JUMPDEST 033C 61 PUSH2 0x0800 033F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0800 label_0340: // Incoming jump from 0x00B8, if 0x70a08231 == stack[-1] // Inputs[1] { @0347 msg.data.length } 0340 5B JUMPDEST 0341 61 PUSH2 0x0262 0344 61 PUSH2 0x034e 0347 36 CALLDATASIZE 0348 60 PUSH1 0x04 034A 61 PUSH2 0x1c65 034D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0341 stack[0] = 0x0262 // @0344 stack[1] = 0x034e // @0347 stack[2] = msg.data.length // @0348 stack[3] = 0x04 // } // Block ends with call to 0x1c65, returns to 0x034E label_034E: // Incoming return from call to 0x1C65 at 0x034D 034E 5B JUMPDEST 034F 61 PUSH2 0x0835 0352 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0835 label_0353: // Incoming jump from 0x00C3, if 0x9010d07c == stack[-1] // Inputs[1] { @035A msg.data.length } 0353 5B JUMPDEST 0354 61 PUSH2 0x0225 0357 61 PUSH2 0x0361 035A 36 CALLDATASIZE 035B 60 PUSH1 0x04 035D 61 PUSH2 0x1e02 0360 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0354 stack[0] = 0x0225 // @0357 stack[1] = 0x0361 // @035A stack[2] = msg.data.length // @035B stack[3] = 0x04 // } // Block ends with call to 0x1e02, returns to 0x0361 label_0361: // Incoming return from call to 0x1E02 at 0x0360 0361 5B JUMPDEST 0362 61 PUSH2 0x0879 0365 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0879 label_0366: // Incoming jump from 0x00CE, if 0x91d14854 == stack[-1] // Inputs[1] { @036D msg.data.length } 0366 5B JUMPDEST 0367 61 PUSH2 0x01e7 036A 61 PUSH2 0x0374 036D 36 CALLDATASIZE 036E 60 PUSH1 0x04 0370 61 PUSH2 0x1de0 0373 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0367 stack[0] = 0x01e7 // @036A stack[1] = 0x0374 // @036D stack[2] = msg.data.length // @036E stack[3] = 0x04 // } // Block ends with call to 0x1de0, returns to 0x0374 label_0374: // Incoming return from call to 0x0AC1 at 0x07D0 // Incoming return from call to 0x0AC1 at 0x05B2 // Incoming return from call to 0x0AC1 at 0x0D56 // Incoming return from call to 0x1DE0 at 0x0373 // Incoming return from call to 0x0AC1 at 0x06F4 0374 5B JUMPDEST 0375 61 PUSH2 0x0898 0378 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0898 label_0379: // Incoming jump from 0x00D9, if 0x95d89b41 == stack[-1] 0379 5B JUMPDEST 037A 61 PUSH2 0x0205 037D 61 PUSH2 0x08c1 0380 56 *JUMP // Stack delta = +1 // Outputs[1] { @037A stack[0] = 0x0205 } // Block ends with call to 0x08c1, returns to 0x0205 label_0381: // Incoming jump from 0x007C, if 0xa217fddf == stack[-1] 0381 5B JUMPDEST 0382 61 PUSH2 0x0262 0385 61 PUSH2 0x08d0 0388 56 *JUMP // Stack delta = +1 // Outputs[1] { @0382 stack[0] = 0x0262 } // Block ends with call to 0x08d0, returns to 0x0262 label_0389: // Incoming jump from 0x0087, if 0xa22cb465 == stack[-1] // Inputs[1] { @0390 msg.data.length } 0389 5B JUMPDEST 038A 61 PUSH2 0x0245 038D 61 PUSH2 0x0397 0390 36 CALLDATASIZE 0391 60 PUSH1 0x04 0393 61 PUSH2 0x1d65 0396 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @038A stack[0] = 0x0245 // @038D stack[1] = 0x0397 // @0390 stack[2] = msg.data.length // @0391 stack[3] = 0x04 // } // Block ends with call to 0x1d65, returns to 0x0397 label_0397: // Incoming return from call to 0x1D65 at 0x0396 0397 5B JUMPDEST 0398 61 PUSH2 0x08d5 039B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08d5 label_039C: // Incoming jump from 0x0092, if 0xb88d4fde == stack[-1] // Inputs[1] { @03A3 msg.data.length } 039C 5B JUMPDEST 039D 61 PUSH2 0x0245 03A0 61 PUSH2 0x03aa 03A3 36 CALLDATASIZE 03A4 60 PUSH1 0x04 03A6 61 PUSH2 0x1cec 03A9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @039D stack[0] = 0x0245 // @03A0 stack[1] = 0x03aa // @03A3 stack[2] = msg.data.length // @03A4 stack[3] = 0x04 // } // Block ends with call to 0x1cec, returns to 0x03AA label_03AA: // Incoming return from call to 0x1CEC at 0x03A9 03AA 5B JUMPDEST 03AB 61 PUSH2 0x09a3 03AE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09a3 label_03AF: // Incoming jump from 0x009D, if 0xc87b56dd == stack[-1] // Inputs[1] { @03B6 msg.data.length } 03AF 5B JUMPDEST 03B0 61 PUSH2 0x0205 03B3 61 PUSH2 0x03bd 03B6 36 CALLDATASIZE 03B7 60 PUSH1 0x04 03B9 61 PUSH2 0x1dc8 03BC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B0 stack[0] = 0x0205 // @03B3 stack[1] = 0x03bd // @03B6 stack[2] = msg.data.length // @03B7 stack[3] = 0x04 // } // Block ends with call to 0x1dc8, returns to 0x03BD label_03BD: // Incoming return from call to 0x1DC8 at 0x03BC 03BD 5B JUMPDEST 03BE 61 PUSH2 0x09e2 03C1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09e2 label_03C2: // Incoming jump from 0x004B, if 0xca15c873 == stack[-1] // Inputs[1] { @03C9 msg.data.length } 03C2 5B JUMPDEST 03C3 61 PUSH2 0x0262 03C6 61 PUSH2 0x03d0 03C9 36 CALLDATASIZE 03CA 60 PUSH1 0x04 03CC 61 PUSH2 0x1dc8 03CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C3 stack[0] = 0x0262 // @03C6 stack[1] = 0x03d0 // @03C9 stack[2] = msg.data.length // @03CA stack[3] = 0x04 // } // Block ends with call to 0x1dc8, returns to 0x03D0 label_03D0: // Incoming return from call to 0x1DC8 at 0x03CF 03D0 5B JUMPDEST 03D1 61 PUSH2 0x09ed 03D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09ed label_03D5: // Incoming jump from 0x0056, if 0xd5391393 == stack[-1] 03D5 5B JUMPDEST 03D6 61 PUSH2 0x0262 03D9 61 PUSH2 0x0a04 03DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @03D6 stack[0] = 0x0262 } // Block ends with call to 0x0a04, returns to 0x0262 label_03DD: // Incoming jump from 0x0061, if 0xd547741f == stack[-1] // Inputs[1] { @03E4 msg.data.length } 03DD 5B JUMPDEST 03DE 61 PUSH2 0x0245 03E1 61 PUSH2 0x03eb 03E4 36 CALLDATASIZE 03E5 60 PUSH1 0x04 03E7 61 PUSH2 0x1de0 03EA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03DE stack[0] = 0x0245 // @03E1 stack[1] = 0x03eb // @03E4 stack[2] = msg.data.length // @03E5 stack[3] = 0x04 // } // Block ends with call to 0x1de0, returns to 0x03EB label_03EB: // Incoming return from call to 0x1DE0 at 0x03EA 03EB 5B JUMPDEST 03EC 61 PUSH2 0x0a28 03EF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a28 label_03F0: // Incoming jump from 0x006C, if 0xe985e9c5 == stack[-1] // Inputs[1] { @03F7 msg.data.length } 03F0 5B JUMPDEST 03F1 61 PUSH2 0x01e7 03F4 61 PUSH2 0x03fe 03F7 36 CALLDATASIZE 03F8 60 PUSH1 0x04 03FA 61 PUSH2 0x1c7f 03FD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03F1 stack[0] = 0x01e7 // @03F4 stack[1] = 0x03fe // @03F7 stack[2] = msg.data.length // @03F8 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1c7f 03FE 5B JUMPDEST 03FF 61 PUSH2 0x0a32 0402 56 *JUMP label_0403: // Incoming jump from 0x01E6 // Inputs[1] { @040F stack[-1] } 0403 5B JUMPDEST 0404 60 PUSH1 0x00 0406 60 PUSH1 0x01 0408 60 PUSH1 0x01 040A 60 PUSH1 0xe0 040C 1B SHL 040D 03 SUB 040E 19 NOT 040F 82 DUP3 0410 16 AND 0411 63 PUSH4 0x780e9d63 0416 60 PUSH1 0xe0 0418 1B SHL 0419 14 EQ 041A 80 DUP1 041B 61 PUSH2 0x0428 041E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0404 stack[0] = 0x00 // @0419 stack[1] = 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0428, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_041F: // Incoming jump from 0x041E, if not 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0423 stack[-3] } 041F 50 POP 0420 61 PUSH2 0x0428 0423 82 DUP3 0424 61 PUSH2 0x0a7f 0427 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0420 stack[-1] = 0x0428 // @0423 stack[0] = stack[-3] // } // Block ends with unconditional jump to 0x0a7f label_0428: // Incoming jump from 0x081D, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x18B4, if 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1594 at 0x1021 // Incoming jump from 0x1181, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0A9A, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1ABC at 0x18BD // Incoming jump from 0x1181, if stack[-1] // Incoming jump from 0x15E4, if 0x5a05180f00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x041E, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[2] // { // @0429 stack[-2] // @0429 stack[-1] // } 0428 5B JUMPDEST 0429 90 SWAP1 042A 50 POP // Stack delta = -1 // Outputs[1] { @0429 stack[-2] = stack[-1] } // Block continues label_042B: // Incoming jump from 0x042A // Incoming jump from 0x1C41, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @042C stack[-1] // @042C stack[-3] // @042D stack[-2] // } 042B 5B JUMPDEST 042C 91 SWAP2 042D 90 SWAP1 042E 50 POP 042F 56 *JUMP // Stack delta = -2 // Outputs[1] { @042C stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0430: // Incoming call from 0x0204, returns to 0x0205 // Inputs[1] { @0436 storage[0x02] } 0430 5B JUMPDEST 0431 60 PUSH1 0x60 0433 60 PUSH1 0x02 0435 80 DUP1 0436 54 SLOAD 0437 61 PUSH2 0x043f 043A 90 SWAP1 043B 61 PUSH2 0x28f0 043E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0431 stack[0] = 0x60 // @0433 stack[1] = 0x02 // @043A stack[2] = 0x043f // @043A stack[3] = storage[0x02] // } // Block ends with call to 0x28f0, returns to 0x043F label_043F: // Incoming return from call to 0x28F0 at 0x043E // Incoming return from call to 0x28F0 at 0x08CF // Incoming return from call to 0x28F0 at 0x1511 // Inputs[4] // { // @0440 stack[-1] // @044F memory[0x40:0x60] // @0457 stack[-2] // @0462 storage[stack[-2]] // } 043F 5B JUMPDEST 0440 80 DUP1 0441 60 PUSH1 0x1f 0443 01 ADD 0444 60 PUSH1 0x20 0446 80 DUP1 0447 91 SWAP2 0448 04 DIV 0449 02 MUL 044A 60 PUSH1 0x20 044C 01 ADD 044D 60 PUSH1 0x40 044F 51 MLOAD 0450 90 SWAP1 0451 81 DUP2 0452 01 ADD 0453 60 PUSH1 0x40 0455 52 MSTORE 0456 80 DUP1 0457 92 SWAP3 0458 91 SWAP2 0459 90 SWAP1 045A 81 DUP2 045B 81 DUP2 045C 52 MSTORE 045D 60 PUSH1 0x20 045F 01 ADD 0460 82 DUP3 0461 80 DUP1 0462 54 SLOAD 0463 61 PUSH2 0x046b 0466 90 SWAP1 0467 61 PUSH2 0x28f0 046A 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0455 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0457 stack[-2] = memory[0x40:0x60] // @0458 stack[-1] = stack[-2] // @0459 stack[0] = stack[-1] // @045C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @045F stack[1] = 0x20 + memory[0x40:0x60] // @0460 stack[2] = stack[-2] // @0466 stack[4] = storage[stack[-2]] // @0466 stack[3] = 0x046b // } // Block ends with call to 0x28f0, returns to 0x046B label_046B: // Incoming return from call to 0x28F0 at 0x046A // Inputs[1] { @046C stack[-1] } 046B 5B JUMPDEST 046C 80 DUP1 046D 15 ISZERO 046E 61 PUSH2 0x04b8 0471 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b8, if !stack[-1] label_0472: // Incoming jump from 0x0471, if not !stack[-1] // Inputs[1] { @0472 stack[-1] } 0472 80 DUP1 0473 60 PUSH1 0x1f 0475 10 LT 0476 61 PUSH2 0x048d 0479 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048d, if 0x1f < stack[-1] label_047A: // Incoming jump from 0x0479, if not 0x1f < stack[-1] // Inputs[4] // { // @047E stack[-2] // @047F storage[stack[-2]] // @0482 stack[-3] // @0484 stack[-1] // } 047A 61 PUSH2 0x0100 047D 80 DUP1 047E 83 DUP4 047F 54 SLOAD 0480 04 DIV 0481 02 MUL 0482 83 DUP4 0483 52 MSTORE 0484 91 SWAP2 0485 60 PUSH1 0x20 0487 01 ADD 0488 91 SWAP2 0489 61 PUSH2 0x04b8 048C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0483 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0488 stack[-1] = stack[-1] // @0488 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04b8 label_048D: // Incoming jump from 0x0479, if 0x1f < stack[-1] // Inputs[5] // { // @048E stack[-3] // @048F stack[-1] // @0491 stack[-2] // @0499 memory[0x00:0x20] // @049D storage[keccak256(memory[0x00:0x20])] // } 048D 5B JUMPDEST 048E 82 DUP3 048F 01 ADD 0490 91 SWAP2 0491 90 SWAP1 0492 60 PUSH1 0x00 0494 52 MSTORE 0495 60 PUSH1 0x20 0497 60 PUSH1 0x00 0499 20 SHA3 049A 90 SWAP1 049B 5B JUMPDEST 049C 81 DUP2 049D 54 SLOAD 049E 81 DUP2 049F 52 MSTORE 04A0 90 SWAP1 04A1 60 PUSH1 0x01 04A3 01 ADD 04A4 90 SWAP1 04A5 60 PUSH1 0x20 04A7 01 ADD 04A8 80 DUP1 04A9 83 DUP4 04AA 11 GT 04AB 61 PUSH2 0x049b 04AE 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0490 stack[-3] = stack[-3] + stack[-1] // @0494 memory[0x00:0x20] = stack[-2] // @049F memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04A4 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04A7 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x049b, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04AF: // Incoming jump from 0x04AE, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x04AE, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @04AF stack[-3] // @04B0 stack[-1] // } 04AF 82 DUP3 04B0 90 SWAP1 04B1 03 SUB 04B2 60 PUSH1 0x1f 04B4 16 AND 04B5 82 DUP3 04B6 01 ADD 04B7 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04B7 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04B7 stack[-1] = stack[-3] // } // Block continues label_04B8: // Incoming jump from 0x04B7 // Incoming jump from 0x0471, if !stack[-1] // Incoming jump from 0x048C // Inputs[3] // { // @04BE stack[-7] // @04BE stack[-6] // @04C0 stack[-8] // } 04B8 5B JUMPDEST 04B9 50 POP 04BA 50 POP 04BB 50 POP 04BC 50 POP 04BD 50 POP 04BE 90 SWAP1 04BF 50 POP 04C0 90 SWAP1 04C1 56 *JUMP // Stack delta = -7 // Outputs[1] { @04C0 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_04C2: // Incoming jump from 0x0224 // Inputs[1] { @04C8 stack[-1] } 04C2 5B JUMPDEST 04C3 60 PUSH1 0x00 04C5 61 PUSH2 0x04cd 04C8 82 DUP3 04C9 61 PUSH2 0x0aa4 04CC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04C3 stack[0] = 0x00 // @04C5 stack[1] = 0x04cd // @04C8 stack[2] = stack[-1] // } // Block ends with call to 0x0aa4, returns to 0x04CD label_04CD: // Incoming return from call to 0x0AA4 at 0x04CC // Inputs[1] { @04D1 stack[-1] } 04CD 5B JUMPDEST 04CE 61 PUSH2 0x04f2 04D1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x04f2, if stack[-1] label_04D2: // Incoming jump from 0x04D1, if not stack[-1] // Inputs[1] { @04D4 memory[0x40:0x60] } 04D2 60 PUSH1 0x40 04D4 51 MLOAD 04D5 62 PUSH3 0x461bcd 04D9 60 PUSH1 0xe5 04DB 1B SHL 04DC 81 DUP2 04DD 52 MSTORE 04DE 60 PUSH1 0x04 04E0 01 ADD 04E1 61 PUSH2 0x04e9 04E4 90 SWAP1 04E5 61 PUSH2 0x2493 04E8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @04E4 stack[0] = 0x04e9 // @04E4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2493, returns to 0x04E9 label_04E9: // Incoming return from call to 0x1FA5 at 0x1398 // Incoming return from call to 0x2599 at 0x05CE // Incoming return from call to 0x21E4 at 0x0BAA // Incoming return from call to 0x2347 at 0x0834 // Incoming return from call to 0x27C7 at 0x0710 // Incoming return from call to 0x21AD at 0x090D // Incoming return from call to 0x2493 at 0x04E8 // Incoming return from call to 0x205F at 0x067A // Incoming return from call to 0x2436 at 0x0F24 // Incoming return from call to 0x26B0 at 0x07EC // Incoming return from call to 0x22EA at 0x085C // Incoming return from call to 0x2002 at 0x0D72 // Incoming return from call to 0x2824 at 0x0DAA // Incoming return from call to 0x23A4 at 0x0B64 // Incoming return from call to 0x2230 at 0x1049 // Incoming return from call to 0x2119 at 0x0E15 // Incoming return from call to 0x270D at 0x0790 // Incoming return from call to 0x2401 at 0x0DEF // Inputs[3] // { // @04EC memory[0x40:0x60] // @04EE stack[-1] // @04F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 04E9 5B JUMPDEST 04EA 60 PUSH1 0x40 04EC 51 MLOAD 04ED 80 DUP1 04EE 91 SWAP2 04EF 03 SUB 04F0 90 SWAP1 04F1 FD *REVERT // Stack delta = -1 // Outputs[1] { @04F1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_04F2: // Incoming jump from 0x04D1, if stack[-1] // Inputs[4] // { // @04F6 stack[-2] // @0501 memory[0x00:0x40] // @0502 storage[keccak256(memory[0x00:0x40])] // @050C stack[-3] // } 04F2 5B JUMPDEST 04F3 50 POP 04F4 60 PUSH1 0x00 04F6 90 SWAP1 04F7 81 DUP2 04F8 52 MSTORE 04F9 60 PUSH1 0x06 04FB 60 PUSH1 0x20 04FD 52 MSTORE 04FE 60 PUSH1 0x40 0500 90 SWAP1 0501 20 SHA3 0502 54 SLOAD 0503 60 PUSH1 0x01 0505 60 PUSH1 0x01 0507 60 PUSH1 0xa0 0509 1B SHL 050A 03 SUB 050B 16 AND 050C 90 SWAP1 050D 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @04F8 memory[0x00:0x20] = stack[-2] // @04FD memory[0x20:0x40] = 0x06 // @050C stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_050E: // Incoming jump from 0x0244 // Inputs[1] { @0514 stack[-1] } 050E 5B JUMPDEST 050F 60 PUSH1 0x00 0511 61 PUSH2 0x0519 0514 82 DUP3 0515 61 PUSH2 0x0800 0518 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @050F stack[0] = 0x00 // @0511 stack[1] = 0x0519 // @0514 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0800 0519 5B JUMPDEST 051A 90 SWAP1 051B 50 POP 051C 80 DUP1 051D 60 PUSH1 0x01 051F 60 PUSH1 0x01 0521 60 PUSH1 0xa0 0523 1B SHL 0524 03 SUB 0525 16 AND 0526 83 DUP4 0527 60 PUSH1 0x01 0529 60 PUSH1 0x01 052B 60 PUSH1 0xa0 052D 1B SHL 052E 03 SUB 052F 16 AND 0530 14 EQ 0531 15 ISZERO 0532 61 PUSH2 0x054d 0535 57 *JUMPI 0536 60 PUSH1 0x40 0538 51 MLOAD 0539 62 PUSH3 0x461bcd 053D 60 PUSH1 0xe5 053F 1B SHL 0540 81 DUP2 0541 52 MSTORE 0542 60 PUSH1 0x04 0544 01 ADD 0545 61 PUSH2 0x04e9 0548 90 SWAP1 0549 61 PUSH2 0x25f6 054C 56 *JUMP 054D 5B JUMPDEST 054E 80 DUP1 054F 60 PUSH1 0x01 0551 60 PUSH1 0x01 0553 60 PUSH1 0xa0 0555 1B SHL 0556 03 SUB 0557 16 AND 0558 61 PUSH2 0x055f 055B 61 PUSH2 0x0ac1 055E 56 *JUMP 055F 5B JUMPDEST 0560 60 PUSH1 0x01 0562 60 PUSH1 0x01 0564 60 PUSH1 0xa0 0566 1B SHL 0567 03 SUB 0568 16 AND 0569 14 EQ 056A 80 DUP1 056B 61 PUSH2 0x057b 056E 57 *JUMPI 056F 50 POP 0570 61 PUSH2 0x057b 0573 81 DUP2 0574 61 PUSH2 0x03fe 0577 61 PUSH2 0x0ac1 057A 56 *JUMP 057B 5B JUMPDEST 057C 61 PUSH2 0x0597 057F 57 *JUMPI 0580 60 PUSH1 0x40 0582 51 MLOAD 0583 62 PUSH3 0x461bcd 0587 60 PUSH1 0xe5 0589 1B SHL 058A 81 DUP2 058B 52 MSTORE 058C 60 PUSH1 0x04 058E 01 ADD 058F 61 PUSH2 0x04e9 0592 90 SWAP1 0593 61 PUSH2 0x228d 0596 56 *JUMP 0597 5B JUMPDEST 0598 61 PUSH2 0x05a1 059B 83 DUP4 059C 83 DUP4 059D 61 PUSH2 0x0ac5 05A0 56 *JUMP label_05A1: // Incoming call from 0x15F8, returns to 0x15F9 // Incoming jump from 0x166D, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Incoming return from call to 0x1A78 at 0x1676 // Incoming return from call to 0x15EE at 0x1195 // Incoming jump from 0x1653 // Inputs[1] { @05A5 stack[-4] } 05A1 5B JUMPDEST 05A2 50 POP 05A3 50 POP 05A4 50 POP 05A5 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_05A6: // Incoming jump from 0x0259 05A6 5B JUMPDEST 05A7 61 PUSH2 0x05b3 05AA 60 PUSH1 0x00 05AC 61 PUSH2 0x0374 05AF 61 PUSH2 0x0ac1 05B2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05A7 stack[0] = 0x05b3 // @05AA stack[1] = 0x00 // @05AC stack[2] = 0x0374 // } // Block ends with call to 0x0ac1, returns to 0x0374 label_05B3: // Incoming return from call to 0x0374 at 0x05B2 // Inputs[1] { @05B7 stack[-1] } 05B3 5B JUMPDEST 05B4 61 PUSH2 0x05cf 05B7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05cf, if stack[-1] label_05B8: // Incoming jump from 0x05B7, if not stack[-1] // Inputs[1] { @05BA memory[0x40:0x60] } 05B8 60 PUSH1 0x40 05BA 51 MLOAD 05BB 62 PUSH3 0x461bcd 05BF 60 PUSH1 0xe5 05C1 1B SHL 05C2 81 DUP2 05C3 52 MSTORE 05C4 60 PUSH1 0x04 05C6 01 ADD 05C7 61 PUSH2 0x04e9 05CA 90 SWAP1 05CB 61 PUSH2 0x2599 05CE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05CA stack[0] = 0x04e9 // @05CA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2599, returns to 0x04E9 label_05CF: // Incoming jump from 0x05B7, if stack[-1] // Inputs[2] // { // @05D3 stack[-2] // @05D4 stack[-1] // } 05CF 5B JUMPDEST 05D0 61 PUSH2 0x05d9 05D3 82 DUP3 05D4 82 DUP3 05D5 61 PUSH2 0x0b40 05D8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05D0 stack[0] = 0x05d9 // @05D3 stack[1] = stack[-2] // @05D4 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0b40 label_05D9: // Incoming return from call to 0x104A at 0x0A69 // Incoming return from call to 0x104A at 0x0A69 // Incoming jump from 0x1058, if stack[-1] // Incoming return from call to 0x1196 at 0x0DB4 // Incoming return from call to 0x1196 at 0x0DB4 // Incoming jump from 0x11A5, if !stack[-1] // Incoming return from call to 0x0DCA at 0x071A // Inputs[1] { @05DC stack[-3] } 05D9 5B JUMPDEST 05DA 50 POP 05DB 50 POP 05DC 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_05DD: // Incoming call from 0x0261, returns to 0x0262 // Incoming call from 0x0772, returns to 0x0773 // Inputs[2] // { // @05E0 storage[0x0a] // @05E1 stack[-1] // } 05DD 5B JUMPDEST 05DE 60 PUSH1 0x0a 05E0 54 SLOAD 05E1 90 SWAP1 05E2 56 *JUMP // Stack delta = +0 // Outputs[1] { @05E1 stack[-1] = storage[0x0a] } // Block ends with unconditional jump to stack[-1] label_05E3: // Incoming jump from 0x0281 05E3 5B JUMPDEST 05E4 61 PUSH2 0x05f4 05E7 61 PUSH2 0x05ee 05EA 61 PUSH2 0x0ac1 05ED 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @05E4 stack[0] = 0x05f4 // @05E7 stack[1] = 0x05ee // } // Block ends with call to 0x0ac1, returns to 0x05EE label_05EE: // Incoming return from call to 0x0AC1 at 0x05ED // Incoming return from call to 0x0AC1 at 0x0740 // Inputs[1] { @05EF stack[-3] } 05EE 5B JUMPDEST 05EF 82 DUP3 05F0 61 PUSH2 0x0b84 05F3 56 *JUMP // Stack delta = +1 // Outputs[1] { @05EF stack[0] = stack[-3] } // Block ends with unconditional jump to 0x0b84 05F4 5B JUMPDEST 05F5 61 PUSH2 0x0610 05F8 57 *JUMPI 05F9 60 PUSH1 0x40 05FB 51 MLOAD 05FC 62 PUSH3 0x461bcd 0600 60 PUSH1 0xe5 0602 1B SHL 0603 81 DUP2 0604 52 MSTORE 0605 60 PUSH1 0x04 0607 01 ADD 0608 61 PUSH2 0x04e9 060B 90 SWAP1 060C 61 PUSH2 0x2653 060F 56 *JUMP 0610 5B JUMPDEST 0611 61 PUSH2 0x05a1 0614 83 DUP4 0615 83 DUP4 0616 83 DUP4 0617 61 PUSH2 0x0c09 061A 56 *JUMP label_061B: // Incoming jump from 0x0294 // Incoming call from 0x0D4E, returns to 0x0D4F // Incoming call from 0x102D, returns to 0x0D4F // Inputs[4] // { // @061E stack[-1] // @0629 memory[0x00:0x40] // @062D storage[0x01 + keccak256(memory[0x00:0x40])] // @062E stack[-2] // } 061B 5B JUMPDEST 061C 60 PUSH1 0x00 061E 90 SWAP1 061F 81 DUP2 0620 52 MSTORE 0621 60 PUSH1 0x20 0623 81 DUP2 0624 90 SWAP1 0625 52 MSTORE 0626 60 PUSH1 0x40 0628 90 SWAP1 0629 20 SHA3 062A 60 PUSH1 0x01 062C 01 ADD 062D 54 SLOAD 062E 90 SWAP1 062F 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0620 memory[0x00:0x20] = stack[-1] // @0625 memory[0x20:0x40] = 0x00 // @062E stack[-2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0630: // Incoming jump from 0x02A7 // Inputs[2] // { // @0634 stack[-2] // @0635 stack[-1] // } 0630 5B JUMPDEST 0631 61 PUSH2 0x063a 0634 82 DUP3 0635 82 DUP3 0636 61 PUSH2 0x0d43 0639 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0631 stack[0] = 0x063a // @0634 stack[1] = stack[-2] // @0635 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0d43 063A 5B JUMPDEST 063B 60 PUSH1 0x00 063D 82 DUP3 063E 81 DUP2 063F 52 MSTORE 0640 60 PUSH1 0x01 0642 60 PUSH1 0x20 0644 52 MSTORE 0645 60 PUSH1 0x40 0647 90 SWAP1 0648 20 SHA3 0649 61 PUSH2 0x05a1 064C 90 SWAP1 064D 82 DUP3 064E 61 PUSH2 0x0a6a 0651 56 *JUMP label_0652: // Incoming jump from 0x02BA // Inputs[1] { @0658 stack[-2] } 0652 5B JUMPDEST 0653 60 PUSH1 0x00 0655 61 PUSH2 0x065d 0658 83 DUP4 0659 61 PUSH2 0x0835 065C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0653 stack[0] = 0x00 // @0655 stack[1] = 0x065d // @0658 stack[2] = stack[-2] // } // Block ends with call to 0x0835, returns to 0x065D label_065D: // Incoming return from call to 0x0835 at 0x065C // Inputs[2] // { // @065E stack[-3] // @065F stack[-1] // } 065D 5B JUMPDEST 065E 82 DUP3 065F 10 LT 0660 61 PUSH2 0x067b 0663 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x067b, if stack[-3] < stack[-1] label_0664: // Incoming jump from 0x0663, if not stack[-3] < stack[-1] // Inputs[1] { @0666 memory[0x40:0x60] } 0664 60 PUSH1 0x40 0666 51 MLOAD 0667 62 PUSH3 0x461bcd 066B 60 PUSH1 0xe5 066D 1B SHL 066E 81 DUP2 066F 52 MSTORE 0670 60 PUSH1 0x04 0672 01 ADD 0673 61 PUSH2 0x04e9 0676 90 SWAP1 0677 61 PUSH2 0x205f 067A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @066F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0676 stack[0] = 0x04e9 // @0676 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x205f, returns to 0x04E9 label_067B: // Incoming jump from 0x0663, if stack[-3] < stack[-1] // Inputs[6] // { // @0685 stack[-3] // @0697 memory[0x00:0x40] // @0698 stack[-2] // @069F memory[0x00:0x40] // @06A0 storage[keccak256(memory[0x00:0x40])] // @06A2 stack[-4] // } 067B 5B JUMPDEST 067C 50 POP 067D 60 PUSH1 0x01 067F 60 PUSH1 0x01 0681 60 PUSH1 0xa0 0683 1B SHL 0684 03 SUB 0685 82 DUP3 0686 16 AND 0687 60 PUSH1 0x00 0689 90 SWAP1 068A 81 DUP2 068B 52 MSTORE 068C 60 PUSH1 0x08 068E 60 PUSH1 0x20 0690 90 SWAP1 0691 81 DUP2 0692 52 MSTORE 0693 60 PUSH1 0x40 0695 80 DUP1 0696 83 DUP4 0697 20 SHA3 0698 84 DUP5 0699 84 DUP5 069A 52 MSTORE 069B 90 SWAP1 069C 91 SWAP2 069D 52 MSTORE 069E 90 SWAP1 069F 20 SHA3 06A0 54 SLOAD 06A1 5B JUMPDEST 06A2 92 SWAP3 06A3 91 SWAP2 06A4 50 POP 06A5 50 POP 06A6 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @068B memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0692 memory[0x20:0x40] = 0x08 // @069A memory[0x00:0x20] = stack[-2] // @069D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06A2 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_06A7: // Incoming jump from 0x02CD // Inputs[2] // { // @06AB stack[-2] // @06AC stack[-1] // } 06A7 5B JUMPDEST 06A8 61 PUSH2 0x06b1 06AB 82 DUP3 06AC 82 DUP3 06AD 61 PUSH2 0x0d73 06B0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06A8 stack[0] = 0x06b1 // @06AB stack[1] = stack[-2] // @06AC stack[2] = stack[-1] // } // Block ends with call to 0x0d73, returns to 0x06B1 label_06B1: // Incoming return from call to 0x1022 at 0x0A31 // Incoming return from call to 0x0D73 at 0x06B0 // Inputs[3] // { // @06B4 stack[-2] // @06BF memory[0x00:0x40] // @06C4 stack[-1] // } 06B1 5B JUMPDEST 06B2 60 PUSH1 0x00 06B4 82 DUP3 06B5 81 DUP2 06B6 52 MSTORE 06B7 60 PUSH1 0x01 06B9 60 PUSH1 0x20 06BB 52 MSTORE 06BC 60 PUSH1 0x40 06BE 90 SWAP1 06BF 20 SHA3 06C0 61 PUSH2 0x05a1 06C3 90 SWAP1 06C4 82 DUP3 06C5 61 PUSH2 0x0db5 06C8 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @06B6 memory[0x00:0x20] = stack[-2] // @06BB memory[0x20:0x40] = 0x01 // @06C3 stack[0] = 0x05a1 // @06C3 stack[1] = keccak256(memory[0x00:0x40]) // @06C4 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0db5 label_06C9: // Incoming jump from 0x02E0 06C9 5B JUMPDEST 06CA 61 PUSH2 0x06f5 06CD 7F PUSH32 0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6 06EE 61 PUSH2 0x0374 06F1 61 PUSH2 0x0ac1 06F4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06CA stack[0] = 0x06f5 // @06CD stack[1] = 0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6 // @06EE stack[2] = 0x0374 // } // Block ends with call to 0x0ac1, returns to 0x0374 label_06F5: // Incoming return from call to 0x0374 at 0x06F4 // Inputs[1] { @06F9 stack[-1] } 06F5 5B JUMPDEST 06F6 61 PUSH2 0x0711 06F9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0711, if stack[-1] label_06FA: // Incoming jump from 0x06F9, if not stack[-1] // Inputs[1] { @06FC memory[0x40:0x60] } 06FA 60 PUSH1 0x40 06FC 51 MLOAD 06FD 62 PUSH3 0x461bcd 0701 60 PUSH1 0xe5 0703 1B SHL 0704 81 DUP2 0705 52 MSTORE 0706 60 PUSH1 0x04 0708 01 ADD 0709 61 PUSH2 0x04e9 070C 90 SWAP1 070D 61 PUSH2 0x27c7 0710 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0705 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @070C stack[0] = 0x04e9 // @070C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x27c7, returns to 0x04E9 label_0711: // Incoming jump from 0x06F9, if stack[-1] // Inputs[2] // { // @0715 stack[-2] // @0716 stack[-1] // } 0711 5B JUMPDEST 0712 61 PUSH2 0x05d9 0715 82 DUP3 0716 82 DUP3 0717 61 PUSH2 0x0dca 071A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0712 stack[0] = 0x05d9 // @0715 stack[1] = stack[-2] // @0716 stack[2] = stack[-1] // } // Block ends with call to 0x0dca, returns to 0x05D9 label_071B: // Incoming jump from 0x02F3 // Inputs[4] // { // @071F stack[-3] // @0720 stack[-2] // @0721 stack[-1] // @0724 memory[0x40:0x60] // } 071B 5B JUMPDEST 071C 61 PUSH2 0x05a1 071F 83 DUP4 0720 83 DUP4 0721 83 DUP4 0722 60 PUSH1 0x40 0724 51 MLOAD 0725 80 DUP1 0726 60 PUSH1 0x20 0728 01 ADD 0729 60 PUSH1 0x40 072B 52 MSTORE 072C 80 DUP1 072D 60 PUSH1 0x00 072F 81 DUP2 0730 52 MSTORE 0731 50 POP 0732 61 PUSH2 0x09a3 0735 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @071C stack[0] = 0x05a1 // @071F stack[1] = stack[-3] // @0720 stack[2] = stack[-2] // @0721 stack[3] = stack[-1] // @0724 stack[4] = memory[0x40:0x60] // @072B memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0730 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x09a3 label_0736: // Incoming jump from 0x0306 0736 5B JUMPDEST 0737 61 PUSH2 0x0741 073A 61 PUSH2 0x05ee 073D 61 PUSH2 0x0ac1 0740 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0737 stack[0] = 0x0741 // @073A stack[1] = 0x05ee // } // Block ends with call to 0x0ac1, returns to 0x05EE 0741 5B JUMPDEST 0742 61 PUSH2 0x075d 0745 57 *JUMPI 0746 60 PUSH1 0x40 0748 51 MLOAD 0749 62 PUSH3 0x461bcd 074D 60 PUSH1 0xe5 074F 1B SHL 0750 81 DUP2 0751 52 MSTORE 0752 60 PUSH1 0x04 0754 01 ADD 0755 61 PUSH2 0x04e9 0758 90 SWAP1 0759 61 PUSH2 0x276a 075C 56 *JUMP 075D 5B JUMPDEST 075E 61 PUSH2 0x0766 0761 81 DUP2 0762 61 PUSH2 0x0eb6 0765 56 *JUMP label_0766: // Incoming jump from 0x29AD, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0768 stack[-2] } 0766 5B JUMPDEST 0767 50 POP 0768 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0769: // Incoming jump from 0x0319 0769 5B JUMPDEST 076A 60 PUSH1 0x00 076C 61 PUSH2 0x0773 076F 61 PUSH2 0x05dd 0772 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @076A stack[0] = 0x00 // @076C stack[1] = 0x0773 // } // Block ends with call to 0x05dd, returns to 0x0773 label_0773: // Incoming return from call to 0x05DD at 0x0772 // Inputs[2] // { // @0774 stack[-3] // @0775 stack[-1] // } 0773 5B JUMPDEST 0774 82 DUP3 0775 10 LT 0776 61 PUSH2 0x0791 0779 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0791, if stack[-3] < stack[-1] label_077A: // Incoming jump from 0x0779, if not stack[-3] < stack[-1] // Inputs[1] { @077C memory[0x40:0x60] } 077A 60 PUSH1 0x40 077C 51 MLOAD 077D 62 PUSH3 0x461bcd 0781 60 PUSH1 0xe5 0783 1B SHL 0784 81 DUP2 0785 52 MSTORE 0786 60 PUSH1 0x04 0788 01 ADD 0789 61 PUSH2 0x04e9 078C 90 SWAP1 078D 61 PUSH2 0x270d 0790 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0785 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @078C stack[0] = 0x04e9 // @078C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x270d, returns to 0x04E9 label_0791: // Incoming jump from 0x0779, if stack[-3] < stack[-1] // Inputs[2] // { // @0794 stack[-2] // @0796 storage[0x0a] // } 0791 5B JUMPDEST 0792 60 PUSH1 0x0a 0794 82 DUP3 0795 81 DUP2 0796 54 SLOAD 0797 81 DUP2 0798 10 LT 0799 61 PUSH2 0x07b2 079C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0792 stack[0] = 0x0a // @0794 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x07b2, if stack[-2] < storage[0x0a] label_079D: // Incoming jump from 0x079C, if not stack[-2] < storage[0x0a] // Inputs[1] { @07B1 memory[0x00:0x24] } 079D 63 PUSH4 0x4e487b71 07A2 60 PUSH1 0xe0 07A4 1B SHL 07A5 60 PUSH1 0x00 07A7 52 MSTORE 07A8 60 PUSH1 0x32 07AA 60 PUSH1 0x04 07AC 52 MSTORE 07AD 60 PUSH1 0x24 07AF 60 PUSH1 0x00 07B1 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @07A7 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @07AC memory[0x04:0x24] = 0x32 // @07B1 revert(memory[0x00:0x24]); // } // Block terminates label_07B2: // Incoming jump from 0x079C, if stack[-2] < storage[0x0a] // Inputs[7] // { // @07B3 stack[-2] // @07B3 stack[-1] // @07BB memory[0x00:0x20] // @07BD storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @07BE stack[-3] // @07C0 stack[-5] // @07C1 stack[-4] // } 07B2 5B JUMPDEST 07B3 90 SWAP1 07B4 60 PUSH1 0x00 07B6 52 MSTORE 07B7 60 PUSH1 0x20 07B9 60 PUSH1 0x00 07BB 20 SHA3 07BC 01 ADD 07BD 54 SLOAD 07BE 90 SWAP1 07BF 50 POP 07C0 91 SWAP2 07C1 90 SWAP1 07C2 50 POP 07C3 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @07B6 memory[0x00:0x20] = stack[-2] // @07C0 stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_07C4: // Incoming jump from 0x032C 07C4 5B JUMPDEST 07C5 61 PUSH2 0x07d1 07C8 60 PUSH1 0x00 07CA 61 PUSH2 0x0374 07CD 61 PUSH2 0x0ac1 07D0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07C5 stack[0] = 0x07d1 // @07C8 stack[1] = 0x00 // @07CA stack[2] = 0x0374 // } // Block ends with call to 0x0ac1, returns to 0x0374 label_07D1: // Incoming return from call to 0x0374 at 0x07D0 // Inputs[1] { @07D5 stack[-1] } 07D1 5B JUMPDEST 07D2 61 PUSH2 0x07ed 07D5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07ed, if stack[-1] label_07D6: // Incoming jump from 0x07D5, if not stack[-1] // Inputs[1] { @07D8 memory[0x40:0x60] } 07D6 60 PUSH1 0x40 07D8 51 MLOAD 07D9 62 PUSH3 0x461bcd 07DD 60 PUSH1 0xe5 07DF 1B SHL 07E0 81 DUP2 07E1 52 MSTORE 07E2 60 PUSH1 0x04 07E4 01 ADD 07E5 61 PUSH2 0x04e9 07E8 90 SWAP1 07E9 61 PUSH2 0x26b0 07EC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07E8 stack[0] = 0x04e9 // @07E8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x26b0, returns to 0x04E9 label_07ED: // Incoming jump from 0x07D5, if stack[-1] // Inputs[2] // { // @07EE stack[-1] // @07EF memory[stack[-1]:stack[-1] + 0x20] // } 07ED 5B JUMPDEST 07EE 80 DUP1 07EF 51 MLOAD 07F0 61 PUSH2 0x05d9 07F3 90 SWAP1 07F4 60 PUSH1 0x0d 07F6 90 SWAP1 07F7 60 PUSH1 0x20 07F9 84 DUP5 07FA 01 ADD 07FB 90 SWAP1 07FC 61 PUSH2 0x1aee 07FF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07F3 stack[0] = 0x05d9 // @07F6 stack[1] = 0x0d // @07FB stack[2] = stack[-1] + 0x20 // @07FB stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1aee label_0800: // Incoming jump from 0x0BB5 // Incoming jump from 0x033F // Incoming jump from 0x0518 // Inputs[3] // { // @0803 stack[-1] // @080E memory[0x00:0x40] // @080F storage[keccak256(memory[0x00:0x40])] // } 0800 5B JUMPDEST 0801 60 PUSH1 0x00 0803 81 DUP2 0804 81 DUP2 0805 52 MSTORE 0806 60 PUSH1 0x04 0808 60 PUSH1 0x20 080A 52 MSTORE 080B 60 PUSH1 0x40 080D 81 DUP2 080E 20 SHA3 080F 54 SLOAD 0810 60 PUSH1 0x01 0812 60 PUSH1 0x01 0814 60 PUSH1 0xa0 0816 1B SHL 0817 03 SUB 0818 16 AND 0819 80 DUP1 081A 61 PUSH2 0x0428 081D 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0801 stack[0] = 0x00 // @0805 memory[0x00:0x20] = stack[-1] // @080A memory[0x20:0x40] = 0x04 // @0818 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0428, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_081E: // Incoming jump from 0x081D, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0820 memory[0x40:0x60] } 081E 60 PUSH1 0x40 0820 51 MLOAD 0821 62 PUSH3 0x461bcd 0825 60 PUSH1 0xe5 0827 1B SHL 0828 81 DUP2 0829 52 MSTORE 082A 60 PUSH1 0x04 082C 01 ADD 082D 61 PUSH2 0x04e9 0830 90 SWAP1 0831 61 PUSH2 0x2347 0834 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0829 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0830 stack[0] = 0x04e9 // @0830 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2347, returns to 0x04E9 label_0835: // Incoming call from 0x065C, returns to 0x065D // Incoming call from 0x1A82, returns to 0x1A83 // Incoming call from 0x190E, returns to 0x190F // Incoming jump from 0x0352 // Inputs[1] { @0840 stack[-1] } 0835 5B JUMPDEST 0836 60 PUSH1 0x00 0838 60 PUSH1 0x01 083A 60 PUSH1 0x01 083C 60 PUSH1 0xa0 083E 1B SHL 083F 03 SUB 0840 82 DUP3 0841 16 AND 0842 61 PUSH2 0x085d 0845 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0836 stack[0] = 0x00 } // Block ends with conditional jump to 0x085d, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0846: // Incoming jump from 0x0845, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0848 memory[0x40:0x60] } 0846 60 PUSH1 0x40 0848 51 MLOAD 0849 62 PUSH3 0x461bcd 084D 60 PUSH1 0xe5 084F 1B SHL 0850 81 DUP2 0851 52 MSTORE 0852 60 PUSH1 0x04 0854 01 ADD 0855 61 PUSH2 0x04e9 0858 90 SWAP1 0859 61 PUSH2 0x22ea 085C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0851 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0858 stack[0] = 0x04e9 // @0858 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x22ea, returns to 0x04E9 label_085D: // Incoming jump from 0x0845, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0867 stack[-2] // @0875 memory[0x00:0x40] // @0876 storage[keccak256(memory[0x00:0x40])] // @0877 stack[-3] // } 085D 5B JUMPDEST 085E 50 POP 085F 60 PUSH1 0x01 0861 60 PUSH1 0x01 0863 60 PUSH1 0xa0 0865 1B SHL 0866 03 SUB 0867 16 AND 0868 60 PUSH1 0x00 086A 90 SWAP1 086B 81 DUP2 086C 52 MSTORE 086D 60 PUSH1 0x05 086F 60 PUSH1 0x20 0871 52 MSTORE 0872 60 PUSH1 0x40 0874 90 SWAP1 0875 20 SHA3 0876 54 SLOAD 0877 90 SWAP1 0878 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @086C memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0871 memory[0x20:0x40] = 0x05 // @0877 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0879: // Incoming jump from 0x0365 // Inputs[3] // { // @087C stack[-2] // @0887 memory[0x00:0x40] // @088C stack[-1] // } 0879 5B JUMPDEST 087A 60 PUSH1 0x00 087C 82 DUP3 087D 81 DUP2 087E 52 MSTORE 087F 60 PUSH1 0x01 0881 60 PUSH1 0x20 0883 52 MSTORE 0884 60 PUSH1 0x40 0886 81 DUP2 0887 20 SHA3 0888 61 PUSH2 0x0891 088B 90 SWAP1 088C 83 DUP4 088D 61 PUSH2 0x0ebf 0890 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @087A stack[0] = 0x00 // @087E memory[0x00:0x20] = stack[-2] // @0883 memory[0x20:0x40] = 0x01 // @088B stack[2] = keccak256(memory[0x00:0x40]) // @088B stack[1] = 0x0891 // @088C stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x0ebf label_0891: // Incoming return from call to 0x1BBF at 0x1C64 // Incoming return from call to 0x1376 at 0x0ECA // Incoming return from call to 0x1ED3 at 0x1FA4 // Incoming return from call to 0x1219 at 0x0DC9 // Incoming return from call to 0x299C at 0x1E3E // Incoming return from call to 0x1C2F at 0x1C7E // Inputs[3] // { // @0892 stack[-5] // @0892 stack[-1] // @0893 stack[-4] // } 0891 5B JUMPDEST 0892 93 SWAP4 0893 92 SWAP3 0894 50 POP 0895 50 POP 0896 50 POP 0897 56 *JUMP // Stack delta = -4 // Outputs[1] { @0892 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0898: // Incoming jump from 0x0378 // Incoming call from 0x1053, returns to 0x1054 // Incoming call from 0x119F, returns to 0x11A0 // Inputs[6] // { // @089B stack[-2] // @08A7 memory[0x00:0x40] // @08B0 stack[-1] // @08BA memory[0x00:0x40] // @08BB storage[keccak256(memory[0x00:0x40])] // @08BF stack[-3] // } 0898 5B JUMPDEST 0899 60 PUSH1 0x00 089B 91 SWAP2 089C 82 DUP3 089D 52 MSTORE 089E 60 PUSH1 0x20 08A0 82 DUP3 08A1 81 DUP2 08A2 52 MSTORE 08A3 60 PUSH1 0x40 08A5 80 DUP1 08A6 84 DUP5 08A7 20 SHA3 08A8 60 PUSH1 0x01 08AA 60 PUSH1 0x01 08AC 60 PUSH1 0xa0 08AE 1B SHL 08AF 03 SUB 08B0 93 SWAP4 08B1 90 SWAP1 08B2 93 SWAP4 08B3 16 AND 08B4 84 DUP5 08B5 52 MSTORE 08B6 91 SWAP2 08B7 90 SWAP1 08B8 52 MSTORE 08B9 90 SWAP1 08BA 20 SHA3 08BB 54 SLOAD 08BC 60 PUSH1 0xff 08BE 16 AND 08BF 90 SWAP1 08C0 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @089D memory[0x00:0x20] = stack[-2] // @08A2 memory[0x20:0x40] = 0x00 // @08B5 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @08B8 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @08BF stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_08C1: // Incoming call from 0x0380, returns to 0x0205 // Inputs[1] { @08C7 storage[0x03] } 08C1 5B JUMPDEST 08C2 60 PUSH1 0x60 08C4 60 PUSH1 0x03 08C6 80 DUP1 08C7 54 SLOAD 08C8 61 PUSH2 0x043f 08CB 90 SWAP1 08CC 61 PUSH2 0x28f0 08CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08C2 stack[0] = 0x60 // @08C4 stack[1] = 0x03 // @08CB stack[2] = 0x043f // @08CB stack[3] = storage[0x03] // } // Block ends with call to 0x28f0, returns to 0x043F label_08D0: // Incoming call from 0x0388, returns to 0x0262 // Inputs[1] { @08D3 stack[-1] } 08D0 5B JUMPDEST 08D1 60 PUSH1 0x00 08D3 81 DUP2 08D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @08D1 stack[0] = 0x00 } // Block ends with unconditional jump to stack[-1] label_08D5: // Incoming jump from 0x039B 08D5 5B JUMPDEST 08D6 61 PUSH2 0x08dd 08D9 61 PUSH2 0x0ac1 08DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @08D6 stack[0] = 0x08dd } // Block ends with call to 0x0ac1, returns to 0x08DD label_08DD: // Incoming return from call to 0x0AC1 at 0x08DC // Inputs[2] // { // @08E6 stack[-1] // @08E7 stack[-3] // } 08DD 5B JUMPDEST 08DE 60 PUSH1 0x01 08E0 60 PUSH1 0x01 08E2 60 PUSH1 0xa0 08E4 1B SHL 08E5 03 SUB 08E6 16 AND 08E7 82 DUP3 08E8 60 PUSH1 0x01 08EA 60 PUSH1 0x01 08EC 60 PUSH1 0xa0 08EE 1B SHL 08EF 03 SUB 08F0 16 AND 08F1 14 EQ 08F2 15 ISZERO 08F3 61 PUSH2 0x090e 08F6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x090e, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_08F7: // Incoming jump from 0x08F6, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @08F9 memory[0x40:0x60] } 08F7 60 PUSH1 0x40 08F9 51 MLOAD 08FA 62 PUSH3 0x461bcd 08FE 60 PUSH1 0xe5 0900 1B SHL 0901 81 DUP2 0902 52 MSTORE 0903 60 PUSH1 0x04 0905 01 ADD 0906 61 PUSH2 0x04e9 0909 90 SWAP1 090A 61 PUSH2 0x21ad 090D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0902 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0909 stack[0] = 0x04e9 // @0909 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x21ad, returns to 0x04E9 label_090E: // Incoming jump from 0x08F6, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @090F stack[-1] } 090E 5B JUMPDEST 090F 80 DUP1 0910 60 PUSH1 0x07 0912 60 PUSH1 0x00 0914 61 PUSH2 0x091b 0917 61 PUSH2 0x0ac1 091A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @090F stack[0] = stack[-1] // @0910 stack[1] = 0x07 // @0912 stack[2] = 0x00 // @0914 stack[3] = 0x091b // } // Block ends with call to 0x0ac1, returns to 0x091B label_091B: // Incoming return from call to 0x0AC1 at 0x091A // Inputs[8] // { // @0924 stack[-1] // @0927 stack[-2] // @092E stack[-3] // @093B memory[0x00:0x00 + 0x40 + stack[-2]] // @093D stack[-6] // @0947 memory[0x00:0x40] // @0949 storage[keccak256(memory[0x00:0x40])] // @094E stack[-4] // } 091B 5B JUMPDEST 091C 60 PUSH1 0x01 091E 60 PUSH1 0x01 0920 60 PUSH1 0xa0 0922 1B SHL 0923 03 SUB 0924 90 SWAP1 0925 81 DUP2 0926 16 AND 0927 82 DUP3 0928 52 MSTORE 0929 60 PUSH1 0x20 092B 80 DUP1 092C 83 DUP4 092D 01 ADD 092E 93 SWAP4 092F 90 SWAP1 0930 93 SWAP4 0931 52 MSTORE 0932 60 PUSH1 0x40 0934 91 SWAP2 0935 82 DUP3 0936 01 ADD 0937 60 PUSH1 0x00 0939 90 SWAP1 093A 81 DUP2 093B 20 SHA3 093C 91 SWAP2 093D 87 DUP8 093E 16 AND 093F 80 DUP1 0940 82 DUP3 0941 52 MSTORE 0942 91 SWAP2 0943 90 SWAP1 0944 93 SWAP4 0945 52 MSTORE 0946 91 SWAP2 0947 20 SHA3 0948 80 DUP1 0949 54 SLOAD 094A 60 PUSH1 0xff 094C 19 NOT 094D 16 AND 094E 92 SWAP3 094F 15 ISZERO 0950 15 ISZERO 0951 92 SWAP3 0952 90 SWAP1 0953 92 SWAP3 0954 17 OR 0955 90 SWAP1 0956 91 SWAP2 0957 55 SSTORE 0958 61 PUSH2 0x095f 095B 61 PUSH2 0x0ac1 095E 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @0928 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0931 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @0941 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0945 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @0956 stack[-4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0957 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0958 stack[-3] = 0x095f // } // Block ends with call to 0x0ac1, returns to 0x095F label_095F: // Incoming return from call to 0x0AC1 at 0x095E // Inputs[3] // { // @0968 stack[-1] // @098A stack[-3] // @098D memory[0x40:0x60] // } 095F 5B JUMPDEST 0960 60 PUSH1 0x01 0962 60 PUSH1 0x01 0964 60 PUSH1 0xa0 0966 1B SHL 0967 03 SUB 0968 16 AND 0969 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 098A 83 DUP4 098B 60 PUSH1 0x40 098D 51 MLOAD 098E 61 PUSH2 0x0997 0991 91 SWAP2 0992 90 SWAP1 0993 61 PUSH2 0x1f7e 0996 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0968 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0969 stack[0] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @0991 stack[1] = 0x0997 // @0992 stack[3] = memory[0x40:0x60] // @0992 stack[2] = stack[-3] // } // Block ends with call to 0x1f7e, returns to 0x0997 label_0997: // Incoming return from call to 0x1F7E at 0x0996 // Inputs[7] // { // @099A memory[0x40:0x60] // @099C stack[-1] // @099F stack[-2] // @099F stack[-3] // @099F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @099F stack[-4] // @09A2 stack[-7] // } 0997 5B JUMPDEST 0998 60 PUSH1 0x40 099A 51 MLOAD 099B 80 DUP1 099C 91 SWAP2 099D 03 SUB 099E 90 SWAP1 099F A3 LOG3 09A0 50 POP 09A1 50 POP 09A2 56 *JUMP // Stack delta = -7 // Outputs[1] { @099F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_09A3: // Incoming jump from 0x0735 // Incoming jump from 0x03AE 09A3 5B JUMPDEST 09A4 61 PUSH2 0x09b4 09A7 61 PUSH2 0x09ae 09AA 61 PUSH2 0x0ac1 09AD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09A4 stack[0] = 0x09b4 // @09A7 stack[1] = 0x09ae // } // Block ends with call to 0x0ac1, returns to 0x09AE label_09AE: // Incoming return from call to 0x0AC1 at 0x09AD // Inputs[1] { @09AF stack[-4] } 09AE 5B JUMPDEST 09AF 83 DUP4 09B0 61 PUSH2 0x0b84 09B3 56 *JUMP // Stack delta = +1 // Outputs[1] { @09AF stack[0] = stack[-4] } // Block ends with unconditional jump to 0x0b84 09B4 5B JUMPDEST 09B5 61 PUSH2 0x09d0 09B8 57 *JUMPI 09B9 60 PUSH1 0x40 09BB 51 MLOAD 09BC 62 PUSH3 0x461bcd 09C0 60 PUSH1 0xe5 09C2 1B SHL 09C3 81 DUP2 09C4 52 MSTORE 09C5 60 PUSH1 0x04 09C7 01 ADD 09C8 61 PUSH2 0x04e9 09CB 90 SWAP1 09CC 61 PUSH2 0x2653 09CF 56 *JUMP 09D0 5B JUMPDEST 09D1 61 PUSH2 0x09dc 09D4 84 DUP5 09D5 84 DUP5 09D6 84 DUP5 09D7 84 DUP5 09D8 61 PUSH2 0x0ecb 09DB 56 *JUMP label_09DC: // Incoming jump from 0x28E7, if !(stack[-1] > stack[-4]) // Inputs[1] { @09E1 stack[-5] } 09DC 5B JUMPDEST 09DD 50 POP 09DE 50 POP 09DF 50 POP 09E0 50 POP 09E1 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_09E2: // Incoming jump from 0x03C1 // Inputs[1] { @09E8 stack[-1] } 09E2 5B JUMPDEST 09E3 60 PUSH1 0x60 09E5 61 PUSH2 0x0428 09E8 82 DUP3 09E9 61 PUSH2 0x0efe 09EC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09E3 stack[0] = 0x60 // @09E5 stack[1] = 0x0428 // @09E8 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0efe label_09ED: // Incoming jump from 0x03D4 // Inputs[2] // { // @09F0 stack[-1] // @09FB memory[0x00:0x40] // } 09ED 5B JUMPDEST 09EE 60 PUSH1 0x00 09F0 81 DUP2 09F1 81 DUP2 09F2 52 MSTORE 09F3 60 PUSH1 0x01 09F5 60 PUSH1 0x20 09F7 52 MSTORE 09F8 60 PUSH1 0x40 09FA 81 DUP2 09FB 20 SHA3 09FC 61 PUSH2 0x0428 09FF 90 SWAP1 0A00 61 PUSH2 0x1017 0A03 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @09EE stack[0] = 0x00 // @09F2 memory[0x00:0x20] = stack[-1] // @09F7 memory[0x20:0x40] = 0x01 // @09FF stack[1] = 0x0428 // @09FF stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x1017 label_0A04: // Incoming call from 0x03DC, returns to 0x0262 // Inputs[1] { @0A26 stack[-1] } 0A04 5B JUMPDEST 0A05 7F PUSH32 0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6 0A26 81 DUP2 0A27 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A05 stack[0] = 0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6 } // Block ends with unconditional jump to stack[-1] label_0A28: // Incoming jump from 0x03EF // Inputs[2] // { // @0A2C stack[-2] // @0A2D stack[-1] // } 0A28 5B JUMPDEST 0A29 61 PUSH2 0x06b1 0A2C 82 DUP3 0A2D 82 DUP3 0A2E 61 PUSH2 0x1022 0A31 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A29 stack[0] = 0x06b1 // @0A2C stack[1] = stack[-2] // @0A2D stack[2] = stack[-1] // } // Block ends with call to 0x1022, returns to 0x06B1 0A32 5B JUMPDEST 0A33 60 PUSH1 0x01 0A35 60 PUSH1 0x01 0A37 60 PUSH1 0xa0 0A39 1B SHL 0A3A 03 SUB 0A3B 91 SWAP2 0A3C 82 DUP3 0A3D 16 AND 0A3E 60 PUSH1 0x00 0A40 90 SWAP1 0A41 81 DUP2 0A42 52 MSTORE 0A43 60 PUSH1 0x07 0A45 60 PUSH1 0x20 0A47 90 SWAP1 0A48 81 DUP2 0A49 52 MSTORE 0A4A 60 PUSH1 0x40 0A4C 80 DUP1 0A4D 83 DUP4 0A4E 20 SHA3 0A4F 93 SWAP4 0A50 90 SWAP1 0A51 94 SWAP5 0A52 16 AND 0A53 82 DUP3 0A54 52 MSTORE 0A55 91 SWAP2 0A56 90 SWAP1 0A57 91 SWAP2 0A58 52 MSTORE 0A59 20 SHA3 0A5A 54 SLOAD 0A5B 60 PUSH1 0xff 0A5D 16 AND 0A5E 90 SWAP1 0A5F 56 *JUMP label_0A60: // Incoming jump from 0x0D5B, if stack[-1] // Inputs[2] // { // @0A64 stack[-2] // @0A65 stack[-1] // } 0A60 5B JUMPDEST 0A61 61 PUSH2 0x05d9 0A64 82 DUP3 0A65 82 DUP3 0A66 61 PUSH2 0x104a 0A69 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A61 stack[0] = 0x05d9 // @0A64 stack[1] = stack[-2] // @0A65 stack[2] = stack[-1] // } // Block ends with call to 0x104a, returns to 0x05D9 0A6A 5B JUMPDEST 0A6B 60 PUSH1 0x00 0A6D 61 PUSH2 0x0891 0A70 83 DUP4 0A71 60 PUSH1 0x01 0A73 60 PUSH1 0x01 0A75 60 PUSH1 0xa0 0A77 1B SHL 0A78 03 SUB 0A79 84 DUP5 0A7A 16 AND 0A7B 61 PUSH2 0x10cf 0A7E 56 *JUMP label_0A7F: // Incoming jump from 0x0427 // Inputs[1] { @0A8B stack[-1] } 0A7F 5B JUMPDEST 0A80 60 PUSH1 0x00 0A82 60 PUSH1 0x01 0A84 60 PUSH1 0x01 0A86 60 PUSH1 0xe0 0A88 1B SHL 0A89 03 SUB 0A8A 19 NOT 0A8B 82 DUP3 0A8C 16 AND 0A8D 63 PUSH4 0x780e9d63 0A92 60 PUSH1 0xe0 0A94 1B SHL 0A95 14 EQ 0A96 80 DUP1 0A97 61 PUSH2 0x0428 0A9A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0A80 stack[0] = 0x00 // @0A95 stack[1] = 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0428, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0A9B: // Incoming jump from 0x0A9A, if not 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0A9F stack[-3] } 0A9B 50 POP 0A9C 61 PUSH2 0x0428 0A9F 82 DUP3 0AA0 61 PUSH2 0x1119 0AA3 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0A9C stack[-1] = 0x0428 // @0A9F stack[0] = stack[-3] // } // Block ends with unconditional jump to 0x1119 label_0AA4: // Incoming call from 0x0B8E, returns to 0x0B8F // Incoming call from 0x04CC, returns to 0x04CD // Incoming call from 0x0F08, returns to 0x0F09 // Incoming call from 0x0DF8, returns to 0x0DF9 // Incoming call from 0x0B48, returns to 0x0B49 // Inputs[4] // { // @0AA7 stack[-1] // @0AB2 memory[0x00:0x40] // @0AB3 storage[keccak256(memory[0x00:0x40])] // @0ABF stack[-2] // } 0AA4 5B JUMPDEST 0AA5 60 PUSH1 0x00 0AA7 90 SWAP1 0AA8 81 DUP2 0AA9 52 MSTORE 0AAA 60 PUSH1 0x04 0AAC 60 PUSH1 0x20 0AAE 52 MSTORE 0AAF 60 PUSH1 0x40 0AB1 90 SWAP1 0AB2 20 SHA3 0AB3 54 SLOAD 0AB4 60 PUSH1 0x01 0AB6 60 PUSH1 0x01 0AB8 60 PUSH1 0xa0 0ABA 1B SHL 0ABB 03 SUB 0ABC 16 AND 0ABD 15 ISZERO 0ABE 15 ISZERO 0ABF 90 SWAP1 0AC0 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0AA9 memory[0x00:0x20] = stack[-1] // @0AAE memory[0x20:0x40] = 0x04 // @0ABF stack[-2] = !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_0AC1: // Incoming call from 0x07D0, returns to 0x0374 // Incoming call from 0x095E, returns to 0x095F // Incoming call from 0x11D4, returns to 0x11D5 // Incoming call from 0x08DC, returns to 0x08DD // Incoming call from 0x0740, returns to 0x05EE // Incoming call from 0x108A, returns to 0x108B // Incoming call from 0x0D56, returns to 0x0374 // Incoming call from 0x091A, returns to 0x091B // Incoming call from 0x09AD, returns to 0x09AE // Incoming call from 0x05ED, returns to 0x05EE // Incoming call from 0x05B2, returns to 0x0374 // Incoming call from 0x0D7A, returns to 0x0D7B // Incoming call from 0x06F4, returns to 0x0374 // Inputs[2] // { // @0AC2 msg.sender // @0AC3 stack[-1] // } 0AC1 5B JUMPDEST 0AC2 33 CALLER 0AC3 90 SWAP1 0AC4 56 *JUMP // Stack delta = +0 // Outputs[1] { @0AC3 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] 0AC5 5B JUMPDEST 0AC6 60 PUSH1 0x00 0AC8 81 DUP2 0AC9 81 DUP2 0ACA 52 MSTORE 0ACB 60 PUSH1 0x06 0ACD 60 PUSH1 0x20 0ACF 52 MSTORE 0AD0 60 PUSH1 0x40 0AD2 90 SWAP1 0AD3 20 SHA3 0AD4 80 DUP1 0AD5 54 SLOAD 0AD6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AEB 19 NOT 0AEC 16 AND 0AED 60 PUSH1 0x01 0AEF 60 PUSH1 0x01 0AF1 60 PUSH1 0xa0 0AF3 1B SHL 0AF4 03 SUB 0AF5 84 DUP5 0AF6 16 AND 0AF7 90 SWAP1 0AF8 81 DUP2 0AF9 17 OR 0AFA 90 SWAP1 0AFB 91 SWAP2 0AFC 55 SSTORE 0AFD 81 DUP2 0AFE 90 SWAP1 0AFF 61 PUSH2 0x0b07 0B02 82 DUP3 0B03 61 PUSH2 0x0800 0B06 56 *JUMP 0B07 5B JUMPDEST 0B08 60 PUSH1 0x01 0B0A 60 PUSH1 0x01 0B0C 60 PUSH1 0xa0 0B0E 1B SHL 0B0F 03 SUB 0B10 16 AND 0B11 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0B32 60 PUSH1 0x40 0B34 51 MLOAD 0B35 60 PUSH1 0x40 0B37 51 MLOAD 0B38 80 DUP1 0B39 91 SWAP2 0B3A 03 SUB 0B3B 90 SWAP1 0B3C A4 LOG4 0B3D 50 POP 0B3E 50 POP 0B3F 56 *JUMP label_0B40: // Incoming jump from 0x05D8 // Inputs[1] { @0B44 stack[-2] } 0B40 5B JUMPDEST 0B41 61 PUSH2 0x0b49 0B44 82 DUP3 0B45 61 PUSH2 0x0aa4 0B48 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B41 stack[0] = 0x0b49 // @0B44 stack[1] = stack[-2] // } // Block ends with call to 0x0aa4, returns to 0x0B49 label_0B49: // Incoming return from call to 0x0AA4 at 0x0B48 // Inputs[1] { @0B4D stack[-1] } 0B49 5B JUMPDEST 0B4A 61 PUSH2 0x0b65 0B4D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b65, if stack[-1] label_0B4E: // Incoming jump from 0x0B4D, if not stack[-1] // Inputs[1] { @0B50 memory[0x40:0x60] } 0B4E 60 PUSH1 0x40 0B50 51 MLOAD 0B51 62 PUSH3 0x461bcd 0B55 60 PUSH1 0xe5 0B57 1B SHL 0B58 81 DUP2 0B59 52 MSTORE 0B5A 60 PUSH1 0x04 0B5C 01 ADD 0B5D 61 PUSH2 0x04e9 0B60 90 SWAP1 0B61 61 PUSH2 0x23a4 0B64 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B59 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B60 stack[0] = 0x04e9 // @0B60 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23a4, returns to 0x04E9 label_0B65: // Incoming jump from 0x0B4D, if stack[-1] // Inputs[4] // { // @0B68 stack[-2] // @0B76 memory[0x00:0x40] // @0B77 stack[-1] // @0B78 memory[stack[-1]:stack[-1] + 0x20] // } 0B65 5B JUMPDEST 0B66 60 PUSH1 0x00 0B68 82 DUP3 0B69 81 DUP2 0B6A 52 MSTORE 0B6B 60 PUSH1 0x0c 0B6D 60 PUSH1 0x20 0B6F 90 SWAP1 0B70 81 DUP2 0B71 52 MSTORE 0B72 60 PUSH1 0x40 0B74 90 SWAP1 0B75 91 SWAP2 0B76 20 SHA3 0B77 82 DUP3 0B78 51 MLOAD 0B79 61 PUSH2 0x05a1 0B7C 92 SWAP3 0B7D 84 DUP5 0B7E 01 ADD 0B7F 90 SWAP1 0B80 61 PUSH2 0x1aee 0B83 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0B6A memory[0x00:0x20] = stack[-2] // @0B71 memory[0x20:0x40] = 0x0c // @0B76 stack[1] = keccak256(memory[0x00:0x40]) // @0B7C stack[0] = 0x05a1 // @0B7F stack[2] = stack[-1] + 0x20 // @0B7F stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1aee label_0B84: // Incoming jump from 0x09B3 // Incoming jump from 0x05F3 // Inputs[1] { @0B8A stack[-1] } 0B84 5B JUMPDEST 0B85 60 PUSH1 0x00 0B87 61 PUSH2 0x0b8f 0B8A 82 DUP3 0B8B 61 PUSH2 0x0aa4 0B8E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B85 stack[0] = 0x00 // @0B87 stack[1] = 0x0b8f // @0B8A stack[2] = stack[-1] // } // Block ends with call to 0x0aa4, returns to 0x0B8F label_0B8F: // Incoming return from call to 0x0AA4 at 0x0B8E // Inputs[1] { @0B93 stack[-1] } 0B8F 5B JUMPDEST 0B90 61 PUSH2 0x0bab 0B93 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bab, if stack[-1] label_0B94: // Incoming jump from 0x0B93, if not stack[-1] // Inputs[1] { @0B96 memory[0x40:0x60] } 0B94 60 PUSH1 0x40 0B96 51 MLOAD 0B97 62 PUSH3 0x461bcd 0B9B 60 PUSH1 0xe5 0B9D 1B SHL 0B9E 81 DUP2 0B9F 52 MSTORE 0BA0 60 PUSH1 0x04 0BA2 01 ADD 0BA3 61 PUSH2 0x04e9 0BA6 90 SWAP1 0BA7 61 PUSH2 0x21e4 0BAA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BA6 stack[0] = 0x04e9 // @0BA6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x21e4, returns to 0x04E9 label_0BAB: // Incoming jump from 0x0B93, if stack[-1] // Inputs[1] { @0BB1 stack[-2] } 0BAB 5B JUMPDEST 0BAC 60 PUSH1 0x00 0BAE 61 PUSH2 0x0bb6 0BB1 83 DUP4 0BB2 61 PUSH2 0x0800 0BB5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BAC stack[0] = 0x00 // @0BAE stack[1] = 0x0bb6 // @0BB1 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x0800 0BB6 5B JUMPDEST 0BB7 90 SWAP1 0BB8 50 POP 0BB9 80 DUP1 0BBA 60 PUSH1 0x01 0BBC 60 PUSH1 0x01 0BBE 60 PUSH1 0xa0 0BC0 1B SHL 0BC1 03 SUB 0BC2 16 AND 0BC3 84 DUP5 0BC4 60 PUSH1 0x01 0BC6 60 PUSH1 0x01 0BC8 60 PUSH1 0xa0 0BCA 1B SHL 0BCB 03 SUB 0BCC 16 AND 0BCD 14 EQ 0BCE 80 DUP1 0BCF 61 PUSH2 0x0bf1 0BD2 57 *JUMPI 0BD3 50 POP 0BD4 83 DUP4 0BD5 60 PUSH1 0x01 0BD7 60 PUSH1 0x01 0BD9 60 PUSH1 0xa0 0BDB 1B SHL 0BDC 03 SUB 0BDD 16 AND 0BDE 61 PUSH2 0x0be6 0BE1 84 DUP5 0BE2 61 PUSH2 0x04c2 0BE5 56 *JUMP 0BE6 5B JUMPDEST 0BE7 60 PUSH1 0x01 0BE9 60 PUSH1 0x01 0BEB 60 PUSH1 0xa0 0BED 1B SHL 0BEE 03 SUB 0BEF 16 AND 0BF0 14 EQ 0BF1 5B JUMPDEST 0BF2 80 DUP1 0BF3 61 PUSH2 0x0c01 0BF6 57 *JUMPI 0BF7 50 POP 0BF8 61 PUSH2 0x0c01 0BFB 81 DUP2 0BFC 85 DUP6 0BFD 61 PUSH2 0x0a32 0C00 56 *JUMP label_0C01: // Incoming return from call to 0x1C46 at 0x1E8D // Inputs[3] // { // @0C02 stack[-6] // @0C02 stack[-1] // @0C03 stack[-5] // } 0C01 5B JUMPDEST 0C02 94 SWAP5 0C03 93 SWAP4 0C04 50 POP 0C05 50 POP 0C06 50 POP 0C07 50 POP 0C08 56 *JUMP // Stack delta = -5 // Outputs[1] { @0C02 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 0C09 5B JUMPDEST 0C0A 82 DUP3 0C0B 60 PUSH1 0x01 0C0D 60 PUSH1 0x01 0C0F 60 PUSH1 0xa0 0C11 1B SHL 0C12 03 SUB 0C13 16 AND 0C14 61 PUSH2 0x0c1c 0C17 82 DUP3 0C18 61 PUSH2 0x0800 0C1B 56 *JUMP 0C1C 5B JUMPDEST 0C1D 60 PUSH1 0x01 0C1F 60 PUSH1 0x01 0C21 60 PUSH1 0xa0 0C23 1B SHL 0C24 03 SUB 0C25 16 AND 0C26 14 EQ 0C27 61 PUSH2 0x0c42 0C2A 57 *JUMPI 0C2B 60 PUSH1 0x40 0C2D 51 MLOAD 0C2E 62 PUSH3 0x461bcd 0C32 60 PUSH1 0xe5 0C34 1B SHL 0C35 81 DUP2 0C36 52 MSTORE 0C37 60 PUSH1 0x04 0C39 01 ADD 0C3A 61 PUSH2 0x04e9 0C3D 90 SWAP1 0C3E 61 PUSH2 0x24df 0C41 56 *JUMP 0C42 5B JUMPDEST 0C43 60 PUSH1 0x01 0C45 60 PUSH1 0x01 0C47 60 PUSH1 0xa0 0C49 1B SHL 0C4A 03 SUB 0C4B 82 DUP3 0C4C 16 AND 0C4D 61 PUSH2 0x0c68 0C50 57 *JUMPI 0C51 60 PUSH1 0x40 0C53 51 MLOAD 0C54 62 PUSH3 0x461bcd 0C58 60 PUSH1 0xe5 0C5A 1B SHL 0C5B 81 DUP2 0C5C 52 MSTORE 0C5D 60 PUSH1 0x04 0C5F 01 ADD 0C60 61 PUSH2 0x04e9 0C63 90 SWAP1 0C64 61 PUSH2 0x2150 0C67 56 *JUMP 0C68 5B JUMPDEST 0C69 61 PUSH2 0x0c73 0C6C 83 DUP4 0C6D 83 DUP4 0C6E 83 DUP4 0C6F 61 PUSH2 0x118b 0C72 56 *JUMP 0C73 5B JUMPDEST 0C74 61 PUSH2 0x0c7e 0C77 60 PUSH1 0x00 0C79 82 DUP3 0C7A 61 PUSH2 0x0ac5 0C7D 56 *JUMP 0C7E 5B JUMPDEST 0C7F 60 PUSH1 0x01 0C81 60 PUSH1 0x01 0C83 60 PUSH1 0xa0 0C85 1B SHL 0C86 03 SUB 0C87 83 DUP4 0C88 16 AND 0C89 60 PUSH1 0x00 0C8B 90 SWAP1 0C8C 81 DUP2 0C8D 52 MSTORE 0C8E 60 PUSH1 0x05 0C90 60 PUSH1 0x20 0C92 52 MSTORE 0C93 60 PUSH1 0x40 0C95 81 DUP2 0C96 20 SHA3 0C97 80 DUP1 0C98 54 SLOAD 0C99 60 PUSH1 0x01 0C9B 92 SWAP3 0C9C 90 SWAP1 0C9D 61 PUSH2 0x0ca7 0CA0 90 SWAP1 0CA1 84 DUP5 0CA2 90 SWAP1 0CA3 61 PUSH2 0x28ad 0CA6 56 *JUMP 0CA7 5B JUMPDEST 0CA8 90 SWAP1 0CA9 91 SWAP2 0CAA 55 SSTORE 0CAB 50 POP 0CAC 50 POP 0CAD 60 PUSH1 0x01 0CAF 60 PUSH1 0x01 0CB1 60 PUSH1 0xa0 0CB3 1B SHL 0CB4 03 SUB 0CB5 82 DUP3 0CB6 16 AND 0CB7 60 PUSH1 0x00 0CB9 90 SWAP1 0CBA 81 DUP2 0CBB 52 MSTORE 0CBC 60 PUSH1 0x05 0CBE 60 PUSH1 0x20 0CC0 52 MSTORE 0CC1 60 PUSH1 0x40 0CC3 81 DUP2 0CC4 20 SHA3 0CC5 80 DUP1 0CC6 54 SLOAD 0CC7 60 PUSH1 0x01 0CC9 92 SWAP3 0CCA 90 SWAP1 0CCB 61 PUSH2 0x0cd5 0CCE 90 SWAP1 0CCF 84 DUP5 0CD0 90 SWAP1 0CD1 61 PUSH2 0x2881 0CD4 56 *JUMP 0CD5 5B JUMPDEST 0CD6 90 SWAP1 0CD7 91 SWAP2 0CD8 55 SSTORE 0CD9 50 POP 0CDA 50 POP 0CDB 60 PUSH1 0x00 0CDD 81 DUP2 0CDE 81 DUP2 0CDF 52 MSTORE 0CE0 60 PUSH1 0x04 0CE2 60 PUSH1 0x20 0CE4 52 MSTORE 0CE5 60 PUSH1 0x40 0CE7 80 DUP1 0CE8 82 DUP3 0CE9 20 SHA3 0CEA 80 DUP1 0CEB 54 SLOAD 0CEC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D01 19 NOT 0D02 16 AND 0D03 60 PUSH1 0x01 0D05 60 PUSH1 0x01 0D07 60 PUSH1 0xa0 0D09 1B SHL 0D0A 03 SUB 0D0B 86 DUP7 0D0C 81 DUP2 0D0D 16 AND 0D0E 91 SWAP2 0D0F 82 DUP3 0D10 17 OR 0D11 90 SWAP1 0D12 92 SWAP3 0D13 55 SSTORE 0D14 91 SWAP2 0D15 51 MLOAD 0D16 84 DUP5 0D17 93 SWAP4 0D18 91 SWAP2 0D19 87 DUP8 0D1A 16 AND 0D1B 91 SWAP2 0D1C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0D3D 91 SWAP2 0D3E A4 LOG4 0D3F 50 POP 0D40 50 POP 0D41 50 POP 0D42 56 *JUMP label_0D43: // Incoming jump from 0x0639 // Inputs[1] { @0D4A stack[-2] } 0D43 5B JUMPDEST 0D44 61 PUSH2 0x0d57 0D47 61 PUSH2 0x0d4f 0D4A 83 DUP4 0D4B 61 PUSH2 0x061b 0D4E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D44 stack[0] = 0x0d57 // @0D47 stack[1] = 0x0d4f // @0D4A stack[2] = stack[-2] // } // Block ends with call to 0x061b, returns to 0x0D4F label_0D4F: // Incoming return from call to 0x061B at 0x0D4E // Incoming return from call to 0x061B at 0x102D 0D4F 5B JUMPDEST 0D50 61 PUSH2 0x0374 0D53 61 PUSH2 0x0ac1 0D56 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D50 stack[0] = 0x0374 } // Block ends with call to 0x0ac1, returns to 0x0374 label_0D57: // Incoming return from call to 0x0D4F at 0x0D4E // Inputs[1] { @0D5B stack[-1] } 0D57 5B JUMPDEST 0D58 61 PUSH2 0x0a60 0D5B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a60, if stack[-1] label_0D5C: // Incoming jump from 0x0D5B, if not stack[-1] // Inputs[1] { @0D5E memory[0x40:0x60] } 0D5C 60 PUSH1 0x40 0D5E 51 MLOAD 0D5F 62 PUSH3 0x461bcd 0D63 60 PUSH1 0xe5 0D65 1B SHL 0D66 81 DUP2 0D67 52 MSTORE 0D68 60 PUSH1 0x04 0D6A 01 ADD 0D6B 61 PUSH2 0x04e9 0D6E 90 SWAP1 0D6F 61 PUSH2 0x2002 0D72 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D67 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D6E stack[0] = 0x04e9 // @0D6E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2002, returns to 0x04E9 label_0D73: // Incoming call from 0x06B0, returns to 0x06B1 0D73 5B JUMPDEST 0D74 61 PUSH2 0x0d7b 0D77 61 PUSH2 0x0ac1 0D7A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D74 stack[0] = 0x0d7b } // Block ends with call to 0x0ac1, returns to 0x0D7B label_0D7B: // Incoming return from call to 0x0AC1 at 0x0D7A // Inputs[2] // { // @0D84 stack[-1] // @0D85 stack[-2] // } 0D7B 5B JUMPDEST 0D7C 60 PUSH1 0x01 0D7E 60 PUSH1 0x01 0D80 60 PUSH1 0xa0 0D82 1B SHL 0D83 03 SUB 0D84 16 AND 0D85 81 DUP2 0D86 60 PUSH1 0x01 0D88 60 PUSH1 0x01 0D8A 60 PUSH1 0xa0 0D8C 1B SHL 0D8D 03 SUB 0D8E 16 AND 0D8F 14 EQ 0D90 61 PUSH2 0x0dab 0D93 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dab, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] label_0D94: // Incoming jump from 0x0D93, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @0D96 memory[0x40:0x60] } 0D94 60 PUSH1 0x40 0D96 51 MLOAD 0D97 62 PUSH3 0x461bcd 0D9B 60 PUSH1 0xe5 0D9D 1B SHL 0D9E 81 DUP2 0D9F 52 MSTORE 0DA0 60 PUSH1 0x04 0DA2 01 ADD 0DA3 61 PUSH2 0x04e9 0DA6 90 SWAP1 0DA7 61 PUSH2 0x2824 0DAA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DA6 stack[0] = 0x04e9 // @0DA6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2824, returns to 0x04E9 label_0DAB: // Incoming jump from 0x0D93, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x1032, if stack[-1] // Inputs[2] // { // @0DAF stack[-2] // @0DB0 stack[-1] // } 0DAB 5B JUMPDEST 0DAC 61 PUSH2 0x05d9 0DAF 82 DUP3 0DB0 82 DUP3 0DB1 61 PUSH2 0x1196 0DB4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DAC stack[0] = 0x05d9 // @0DAF stack[1] = stack[-2] // @0DB0 stack[2] = stack[-1] // } // Block ends with call to 0x1196, returns to 0x05D9 label_0DB5: // Incoming jump from 0x06C8 // Inputs[2] // { // @0DBB stack[-2] // @0DC4 stack[-1] // } 0DB5 5B JUMPDEST 0DB6 60 PUSH1 0x00 0DB8 61 PUSH2 0x0891 0DBB 83 DUP4 0DBC 60 PUSH1 0x01 0DBE 60 PUSH1 0x01 0DC0 60 PUSH1 0xa0 0DC2 1B SHL 0DC3 03 SUB 0DC4 84 DUP5 0DC5 16 AND 0DC6 61 PUSH2 0x1219 0DC9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DB6 stack[0] = 0x00 // @0DB8 stack[1] = 0x0891 // @0DBB stack[2] = stack[-2] // @0DC5 stack[3] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with call to 0x1219, returns to 0x0891 label_0DCA: // Incoming call from 0x071A, returns to 0x05D9 // Inputs[1] { @0DD3 stack[-2] } 0DCA 5B JUMPDEST 0DCB 60 PUSH1 0x01 0DCD 60 PUSH1 0x01 0DCF 60 PUSH1 0xa0 0DD1 1B SHL 0DD2 03 SUB 0DD3 82 DUP3 0DD4 16 AND 0DD5 61 PUSH2 0x0df0 0DD8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0df0, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0DD9: // Incoming jump from 0x0DD8, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0DDB memory[0x40:0x60] } 0DD9 60 PUSH1 0x40 0DDB 51 MLOAD 0DDC 62 PUSH3 0x461bcd 0DE0 60 PUSH1 0xe5 0DE2 1B SHL 0DE3 81 DUP2 0DE4 52 MSTORE 0DE5 60 PUSH1 0x04 0DE7 01 ADD 0DE8 61 PUSH2 0x04e9 0DEB 90 SWAP1 0DEC 61 PUSH2 0x2401 0DEF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DEB stack[0] = 0x04e9 // @0DEB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2401, returns to 0x04E9 label_0DF0: // Incoming jump from 0x0DD8, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0DF4 stack[-1] } 0DF0 5B JUMPDEST 0DF1 61 PUSH2 0x0df9 0DF4 81 DUP2 0DF5 61 PUSH2 0x0aa4 0DF8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DF1 stack[0] = 0x0df9 // @0DF4 stack[1] = stack[-1] // } // Block ends with call to 0x0aa4, returns to 0x0DF9 label_0DF9: // Incoming return from call to 0x0AA4 at 0x0DF8 // Inputs[1] { @0DFA stack[-1] } 0DF9 5B JUMPDEST 0DFA 15 ISZERO 0DFB 61 PUSH2 0x0e16 0DFE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e16, if !stack[-1] label_0DFF: // Incoming jump from 0x0DFE, if not !stack[-1] // Inputs[1] { @0E01 memory[0x40:0x60] } 0DFF 60 PUSH1 0x40 0E01 51 MLOAD 0E02 62 PUSH3 0x461bcd 0E06 60 PUSH1 0xe5 0E08 1B SHL 0E09 81 DUP2 0E0A 52 MSTORE 0E0B 60 PUSH1 0x04 0E0D 01 ADD 0E0E 61 PUSH2 0x04e9 0E11 90 SWAP1 0E12 61 PUSH2 0x2119 0E15 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E0A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E11 stack[0] = 0x04e9 // @0E11 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2119, returns to 0x04E9 label_0E16: // Incoming jump from 0x0DFE, if !stack[-1] // Inputs[2] // { // @0E1C stack[-2] // @0E1D stack[-1] // } 0E16 5B JUMPDEST 0E17 61 PUSH2 0x0e22 0E1A 60 PUSH1 0x00 0E1C 83 DUP4 0E1D 83 DUP4 0E1E 61 PUSH2 0x118b 0E21 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E17 stack[0] = 0x0e22 // @0E1A stack[1] = 0x00 // @0E1C stack[2] = stack[-2] // @0E1D stack[3] = stack[-1] // } // Block ends with call to 0x118b, returns to 0x0E22 label_0E22: // Incoming return from call to 0x118B at 0x0E21 // Inputs[3] // { // @0E2B stack[-2] // @0E3A memory[0x00:0x40] // @0E3C storage[keccak256(memory[0x00:0x40])] // } 0E22 5B JUMPDEST 0E23 60 PUSH1 0x01 0E25 60 PUSH1 0x01 0E27 60 PUSH1 0xa0 0E29 1B SHL 0E2A 03 SUB 0E2B 82 DUP3 0E2C 16 AND 0E2D 60 PUSH1 0x00 0E2F 90 SWAP1 0E30 81 DUP2 0E31 52 MSTORE 0E32 60 PUSH1 0x05 0E34 60 PUSH1 0x20 0E36 52 MSTORE 0E37 60 PUSH1 0x40 0E39 81 DUP2 0E3A 20 SHA3 0E3B 80 DUP1 0E3C 54 SLOAD 0E3D 60 PUSH1 0x01 0E3F 92 SWAP3 0E40 90 SWAP1 0E41 61 PUSH2 0x0e4b 0E44 90 SWAP1 0E45 84 DUP5 0E46 90 SWAP1 0E47 61 PUSH2 0x2881 0E4A 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0E31 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0E36 memory[0x20:0x40] = 0x05 // @0E3A stack[1] = keccak256(memory[0x00:0x40]) // @0E3F stack[0] = 0x01 // @0E40 stack[2] = 0x00 // @0E44 stack[3] = 0x0e4b // @0E46 stack[4] = 0x01 // @0E46 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2881, returns to 0x0E4B label_0E4B: // Incoming return from call to 0x2881 at 0x0E4A // Inputs[10] // { // @0E4C stack[-1] // @0E4C stack[-2] // @0E4D stack[-3] // @0E53 stack[-5] // @0E5F memory[0x00:0x40] // @0E61 storage[keccak256(memory[0x00:0x40])] // @0E81 stack[-6] // @0E8A memory[0x40:0x60] // @0EB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0EB5 stack[-7] // } 0E4B 5B JUMPDEST 0E4C 90 SWAP1 0E4D 91 SWAP2 0E4E 55 SSTORE 0E4F 50 POP 0E50 50 POP 0E51 60 PUSH1 0x00 0E53 81 DUP2 0E54 81 DUP2 0E55 52 MSTORE 0E56 60 PUSH1 0x04 0E58 60 PUSH1 0x20 0E5A 52 MSTORE 0E5B 60 PUSH1 0x40 0E5D 80 DUP1 0E5E 82 DUP3 0E5F 20 SHA3 0E60 80 DUP1 0E61 54 SLOAD 0E62 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E77 19 NOT 0E78 16 AND 0E79 60 PUSH1 0x01 0E7B 60 PUSH1 0x01 0E7D 60 PUSH1 0xa0 0E7F 1B SHL 0E80 03 SUB 0E81 86 DUP7 0E82 16 AND 0E83 90 SWAP1 0E84 81 DUP2 0E85 17 OR 0E86 90 SWAP1 0E87 91 SWAP2 0E88 55 SSTORE 0E89 90 SWAP1 0E8A 51 MLOAD 0E8B 83 DUP4 0E8C 92 SWAP3 0E8D 90 SWAP1 0E8E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0EAF 90 SWAP1 0EB0 82 DUP3 0EB1 90 SWAP1 0EB2 A4 LOG4 0EB3 50 POP 0EB4 50 POP 0EB5 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @0E4E storage[stack[-3]] = stack[-1] // @0E55 memory[0x00:0x20] = stack[-5] // @0E5A memory[0x20:0x40] = 0x04 // @0E88 storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @0EB2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] 0EB6 5B JUMPDEST 0EB7 61 PUSH2 0x0766 0EBA 81 DUP2 0EBB 61 PUSH2 0x1336 0EBE 56 *JUMP label_0EBF: // Incoming jump from 0x0890 // Inputs[2] // { // @0EC5 stack[-2] // @0EC6 stack[-1] // } 0EBF 5B JUMPDEST 0EC0 60 PUSH1 0x00 0EC2 61 PUSH2 0x0891 0EC5 83 DUP4 0EC6 83 DUP4 0EC7 61 PUSH2 0x1376 0ECA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EC0 stack[0] = 0x00 // @0EC2 stack[1] = 0x0891 // @0EC5 stack[2] = stack[-2] // @0EC6 stack[3] = stack[-1] // } // Block ends with call to 0x1376, returns to 0x0891 0ECB 5B JUMPDEST 0ECC 61 PUSH2 0x0ed6 0ECF 84 DUP5 0ED0 84 DUP5 0ED1 84 DUP5 0ED2 61 PUSH2 0x0c09 0ED5 56 *JUMP 0ED6 5B JUMPDEST 0ED7 61 PUSH2 0x0ee2 0EDA 84 DUP5 0EDB 84 DUP5 0EDC 84 DUP5 0EDD 84 DUP5 0EDE 61 PUSH2 0x13cf 0EE1 56 *JUMP 0EE2 5B JUMPDEST 0EE3 61 PUSH2 0x09dc 0EE6 57 *JUMPI 0EE7 60 PUSH1 0x40 0EE9 51 MLOAD 0EEA 62 PUSH3 0x461bcd 0EEE 60 PUSH1 0xe5 0EF0 1B SHL 0EF1 81 DUP2 0EF2 52 MSTORE 0EF3 60 PUSH1 0x04 0EF5 01 ADD 0EF6 61 PUSH2 0x04e9 0EF9 90 SWAP1 0EFA 61 PUSH2 0x20bc 0EFD 56 *JUMP label_0EFE: // Incoming jump from 0x09EC // Inputs[1] { @0F04 stack[-1] } 0EFE 5B JUMPDEST 0EFF 60 PUSH1 0x60 0F01 61 PUSH2 0x0f09 0F04 82 DUP3 0F05 61 PUSH2 0x0aa4 0F08 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EFF stack[0] = 0x60 // @0F01 stack[1] = 0x0f09 // @0F04 stack[2] = stack[-1] // } // Block ends with call to 0x0aa4, returns to 0x0F09 label_0F09: // Incoming return from call to 0x0AA4 at 0x0F08 // Inputs[1] { @0F0D stack[-1] } 0F09 5B JUMPDEST 0F0A 61 PUSH2 0x0f25 0F0D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f25, if stack[-1] label_0F0E: // Incoming jump from 0x0F0D, if not stack[-1] // Inputs[1] { @0F10 memory[0x40:0x60] } 0F0E 60 PUSH1 0x40 0F10 51 MLOAD 0F11 62 PUSH3 0x461bcd 0F15 60 PUSH1 0xe5 0F17 1B SHL 0F18 81 DUP2 0F19 52 MSTORE 0F1A 60 PUSH1 0x04 0F1C 01 ADD 0F1D 61 PUSH2 0x04e9 0F20 90 SWAP1 0F21 61 PUSH2 0x2436 0F24 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F19 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F20 stack[0] = 0x04e9 // @0F20 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2436, returns to 0x04E9 label_0F25: // Incoming jump from 0x0F0D, if stack[-1] // Inputs[3] // { // @0F28 stack[-2] // @0F33 memory[0x00:0x40] // @0F35 storage[keccak256(memory[0x00:0x40])] // } 0F25 5B JUMPDEST 0F26 60 PUSH1 0x00 0F28 82 DUP3 0F29 81 DUP2 0F2A 52 MSTORE 0F2B 60 PUSH1 0x0c 0F2D 60 PUSH1 0x20 0F2F 52 MSTORE 0F30 60 PUSH1 0x40 0F32 81 DUP2 0F33 20 SHA3 0F34 80 DUP1 0F35 54 SLOAD 0F36 61 PUSH2 0x0f3e 0F39 90 SWAP1 0F3A 61 PUSH2 0x28f0 0F3D 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0F26 stack[0] = 0x00 // @0F2A memory[0x00:0x20] = stack[-2] // @0F2F memory[0x20:0x40] = 0x0c // @0F33 stack[1] = keccak256(memory[0x00:0x40]) // @0F39 stack[2] = 0x0f3e // @0F39 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x28f0, returns to 0x0F3E label_0F3E: // Incoming return from call to 0x28F0 at 0x0F3D // Inputs[4] // { // @0F3F stack[-1] // @0F4E memory[0x40:0x60] // @0F56 stack[-2] // @0F61 storage[stack[-2]] // } 0F3E 5B JUMPDEST 0F3F 80 DUP1 0F40 60 PUSH1 0x1f 0F42 01 ADD 0F43 60 PUSH1 0x20 0F45 80 DUP1 0F46 91 SWAP2 0F47 04 DIV 0F48 02 MUL 0F49 60 PUSH1 0x20 0F4B 01 ADD 0F4C 60 PUSH1 0x40 0F4E 51 MLOAD 0F4F 90 SWAP1 0F50 81 DUP2 0F51 01 ADD 0F52 60 PUSH1 0x40 0F54 52 MSTORE 0F55 80 DUP1 0F56 92 SWAP3 0F57 91 SWAP2 0F58 90 SWAP1 0F59 81 DUP2 0F5A 81 DUP2 0F5B 52 MSTORE 0F5C 60 PUSH1 0x20 0F5E 01 ADD 0F5F 82 DUP3 0F60 80 DUP1 0F61 54 SLOAD 0F62 61 PUSH2 0x0f6a 0F65 90 SWAP1 0F66 61 PUSH2 0x28f0 0F69 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0F54 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0F56 stack[-2] = memory[0x40:0x60] // @0F57 stack[-1] = stack[-2] // @0F58 stack[0] = stack[-1] // @0F5B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0F5E stack[1] = 0x20 + memory[0x40:0x60] // @0F5F stack[2] = stack[-2] // @0F65 stack[4] = storage[stack[-2]] // @0F65 stack[3] = 0x0f6a // } // Block ends with call to 0x28f0, returns to 0x0F6A label_0F6A: // Incoming return from call to 0x28F0 at 0x0F69 // Inputs[1] { @0F6B stack[-1] } 0F6A 5B JUMPDEST 0F6B 80 DUP1 0F6C 15 ISZERO 0F6D 61 PUSH2 0x0fb7 0F70 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fb7, if !stack[-1] label_0F71: // Incoming jump from 0x0F70, if not !stack[-1] // Inputs[1] { @0F71 stack[-1] } 0F71 80 DUP1 0F72 60 PUSH1 0x1f 0F74 10 LT 0F75 61 PUSH2 0x0f8c 0F78 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f8c, if 0x1f < stack[-1] label_0F79: // Incoming jump from 0x0F78, if not 0x1f < stack[-1] // Inputs[4] // { // @0F7D stack[-2] // @0F7E storage[stack[-2]] // @0F81 stack[-3] // @0F83 stack[-1] // } 0F79 61 PUSH2 0x0100 0F7C 80 DUP1 0F7D 83 DUP4 0F7E 54 SLOAD 0F7F 04 DIV 0F80 02 MUL 0F81 83 DUP4 0F82 52 MSTORE 0F83 91 SWAP2 0F84 60 PUSH1 0x20 0F86 01 ADD 0F87 91 SWAP2 0F88 61 PUSH2 0x0fb7 0F8B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0F82 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0F87 stack[-1] = stack[-1] // @0F87 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0fb7 label_0F8C: // Incoming jump from 0x0F78, if 0x1f < stack[-1] // Inputs[5] // { // @0F8D stack[-3] // @0F8E stack[-1] // @0F90 stack[-2] // @0F98 memory[0x00:0x20] // @0F9C storage[keccak256(memory[0x00:0x20])] // } 0F8C 5B JUMPDEST 0F8D 82 DUP3 0F8E 01 ADD 0F8F 91 SWAP2 0F90 90 SWAP1 0F91 60 PUSH1 0x00 0F93 52 MSTORE 0F94 60 PUSH1 0x20 0F96 60 PUSH1 0x00 0F98 20 SHA3 0F99 90 SWAP1 0F9A 5B JUMPDEST 0F9B 81 DUP2 0F9C 54 SLOAD 0F9D 81 DUP2 0F9E 52 MSTORE 0F9F 90 SWAP1 0FA0 60 PUSH1 0x01 0FA2 01 ADD 0FA3 90 SWAP1 0FA4 60 PUSH1 0x20 0FA6 01 ADD 0FA7 80 DUP1 0FA8 83 DUP4 0FA9 11 GT 0FAA 61 PUSH2 0x0f9a 0FAD 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0F8F stack[-3] = stack[-3] + stack[-1] // @0F93 memory[0x00:0x20] = stack[-2] // @0F9E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0FA3 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0FA6 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0f9a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0FAE: // Incoming jump from 0x0FAD, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0FAD, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0FAE stack[-3] // @0FAF stack[-1] // } 0FAE 82 DUP3 0FAF 90 SWAP1 0FB0 03 SUB 0FB1 60 PUSH1 0x1f 0FB3 16 AND 0FB4 82 DUP3 0FB5 01 ADD 0FB6 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0FB6 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0FB6 stack[-1] = stack[-3] // } // Block continues label_0FB7: // Incoming jump from 0x0F70, if !stack[-1] // Incoming jump from 0x0FB6 // Incoming jump from 0x0F8B // Inputs[2] // { // @0FBD stack[-7] // @0FBD stack[-6] // } 0FB7 5B JUMPDEST 0FB8 50 POP 0FB9 50 POP 0FBA 50 POP 0FBB 50 POP 0FBC 50 POP 0FBD 90 SWAP1 0FBE 50 POP 0FBF 60 PUSH1 0x00 0FC1 61 PUSH2 0x0fc8 0FC4 61 PUSH2 0x1503 0FC7 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0FBD stack[-7] = stack[-6] // @0FBF stack[-6] = 0x00 // @0FC1 stack[-5] = 0x0fc8 // } // Block ends with unconditional jump to 0x1503 0FC8 5B JUMPDEST 0FC9 90 SWAP1 0FCA 50 POP 0FCB 80 DUP1 0FCC 51 MLOAD 0FCD 60 PUSH1 0x00 0FCF 14 EQ 0FD0 15 ISZERO 0FD1 61 PUSH2 0x0fdc 0FD4 57 *JUMPI 0FD5 50 POP 0FD6 90 SWAP1 0FD7 50 POP 0FD8 61 PUSH2 0x042b 0FDB 56 *JUMP 0FDC 5B JUMPDEST 0FDD 81 DUP2 0FDE 51 MLOAD 0FDF 15 ISZERO 0FE0 61 PUSH2 0x100e 0FE3 57 *JUMPI 0FE4 80 DUP1 0FE5 82 DUP3 0FE6 60 PUSH1 0x40 0FE8 51 MLOAD 0FE9 60 PUSH1 0x20 0FEB 01 ADD 0FEC 61 PUSH2 0x0ff6 0FEF 92 SWAP3 0FF0 91 SWAP2 0FF1 90 SWAP1 0FF2 61 PUSH2 0x1eff 0FF5 56 *JUMP 0FF6 5B JUMPDEST 0FF7 60 PUSH1 0x40 0FF9 51 MLOAD 0FFA 60 PUSH1 0x20 0FFC 81 DUP2 0FFD 83 DUP4 0FFE 03 SUB 0FFF 03 SUB 1000 81 DUP2 1001 52 MSTORE 1002 90 SWAP1 1003 60 PUSH1 0x40 1005 52 MSTORE 1006 92 SWAP3 1007 50 POP 1008 50 POP 1009 50 POP 100A 61 PUSH2 0x042b 100D 56 *JUMP 100E 5B JUMPDEST 100F 61 PUSH2 0x0c01 1012 84 DUP5 1013 61 PUSH2 0x1512 1016 56 *JUMP label_1017: // Incoming jump from 0x0A03 // Inputs[1] { @101D stack[-1] } 1017 5B JUMPDEST 1018 60 PUSH1 0x00 101A 61 PUSH2 0x0428 101D 82 DUP3 101E 61 PUSH2 0x1594 1021 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1018 stack[0] = 0x00 // @101A stack[1] = 0x0428 // @101D stack[2] = stack[-1] // } // Block ends with call to 0x1594, returns to 0x0428 label_1022: // Incoming call from 0x0A31, returns to 0x06B1 // Inputs[1] { @1029 stack[-2] } 1022 5B JUMPDEST 1023 61 PUSH2 0x102e 1026 61 PUSH2 0x0d4f 1029 83 DUP4 102A 61 PUSH2 0x061b 102D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1023 stack[0] = 0x102e // @1026 stack[1] = 0x0d4f // @1029 stack[2] = stack[-2] // } // Block ends with call to 0x061b, returns to 0x0D4F label_102E: // Incoming return from call to 0x0D4F at 0x102D // Inputs[1] { @1032 stack[-1] } 102E 5B JUMPDEST 102F 61 PUSH2 0x0dab 1032 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dab, if stack[-1] label_1033: // Incoming jump from 0x1032, if not stack[-1] // Inputs[1] { @1035 memory[0x40:0x60] } 1033 60 PUSH1 0x40 1035 51 MLOAD 1036 62 PUSH3 0x461bcd 103A 60 PUSH1 0xe5 103C 1B SHL 103D 81 DUP2 103E 52 MSTORE 103F 60 PUSH1 0x04 1041 01 ADD 1042 61 PUSH2 0x04e9 1045 90 SWAP1 1046 61 PUSH2 0x2230 1049 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @103E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1045 stack[0] = 0x04e9 // @1045 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2230, returns to 0x04E9 label_104A: // Incoming call from 0x0A69, returns to 0x05D9 // Inputs[2] // { // @104E stack[-2] // @104F stack[-1] // } 104A 5B JUMPDEST 104B 61 PUSH2 0x1054 104E 82 DUP3 104F 82 DUP3 1050 61 PUSH2 0x0898 1053 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @104B stack[0] = 0x1054 // @104E stack[1] = stack[-2] // @104F stack[2] = stack[-1] // } // Block ends with call to 0x0898, returns to 0x1054 label_1054: // Incoming return from call to 0x0898 at 0x1053 // Inputs[1] { @1058 stack[-1] } 1054 5B JUMPDEST 1055 61 PUSH2 0x05d9 1058 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05d9, if stack[-1] label_1059: // Incoming jump from 0x1058, if not stack[-1] // Inputs[5] // { // @105B stack[-2] // @1067 memory[0x00:0x40] // @1070 stack[-1] // @1078 memory[0x00:0x40] // @107A storage[keccak256(memory[0x00:0x40])] // } 1059 60 PUSH1 0x00 105B 82 DUP3 105C 81 DUP2 105D 52 MSTORE 105E 60 PUSH1 0x20 1060 81 DUP2 1061 81 DUP2 1062 52 MSTORE 1063 60 PUSH1 0x40 1065 80 DUP1 1066 83 DUP4 1067 20 SHA3 1068 60 PUSH1 0x01 106A 60 PUSH1 0x01 106C 60 PUSH1 0xa0 106E 1B SHL 106F 03 SUB 1070 85 DUP6 1071 16 AND 1072 84 DUP5 1073 52 MSTORE 1074 90 SWAP1 1075 91 SWAP2 1076 52 MSTORE 1077 90 SWAP1 1078 20 SHA3 1079 80 DUP1 107A 54 SLOAD 107B 60 PUSH1 0xff 107D 19 NOT 107E 16 AND 107F 60 PUSH1 0x01 1081 17 OR 1082 90 SWAP1 1083 55 SSTORE 1084 61 PUSH2 0x108b 1087 61 PUSH2 0x0ac1 108A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @105D memory[0x00:0x20] = stack[-2] // @1062 memory[0x20:0x40] = 0x00 // @1073 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1076 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1083 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1084 stack[0] = 0x108b // } // Block ends with call to 0x0ac1, returns to 0x108B label_108B: // Incoming return from call to 0x0AC1 at 0x108A // Inputs[7] // { // @1094 stack[-1] // @1095 stack[-2] // @109F stack[-3] // @10C3 memory[0x40:0x60] // @10C6 memory[0x40:0x60] // @10CB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @10CE stack[-4] // } 108B 5B JUMPDEST 108C 60 PUSH1 0x01 108E 60 PUSH1 0x01 1090 60 PUSH1 0xa0 1092 1B SHL 1093 03 SUB 1094 16 AND 1095 81 DUP2 1096 60 PUSH1 0x01 1098 60 PUSH1 0x01 109A 60 PUSH1 0xa0 109C 1B SHL 109D 03 SUB 109E 16 AND 109F 83 DUP4 10A0 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 10C1 60 PUSH1 0x40 10C3 51 MLOAD 10C4 60 PUSH1 0x40 10C6 51 MLOAD 10C7 80 DUP1 10C8 91 SWAP2 10C9 03 SUB 10CA 90 SWAP1 10CB A4 LOG4 10CC 50 POP 10CD 50 POP 10CE 56 *JUMP // Stack delta = -4 // Outputs[1] { @10CB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d, stack[-3], stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-4] 10CF 5B JUMPDEST 10D0 60 PUSH1 0x00 10D2 61 PUSH2 0x10db 10D5 83 DUP4 10D6 83 DUP4 10D7 61 PUSH2 0x1598 10DA 56 *JUMP 10DB 5B JUMPDEST 10DC 61 PUSH2 0x1111 10DF 57 *JUMPI 10E0 50 POP 10E1 81 DUP2 10E2 54 SLOAD 10E3 60 PUSH1 0x01 10E5 81 DUP2 10E6 81 DUP2 10E7 01 ADD 10E8 84 DUP5 10E9 55 SSTORE 10EA 60 PUSH1 0x00 10EC 84 DUP5 10ED 81 DUP2 10EE 52 MSTORE 10EF 60 PUSH1 0x20 10F1 80 DUP1 10F2 82 DUP3 10F3 20 SHA3 10F4 90 SWAP1 10F5 93 SWAP4 10F6 01 ADD 10F7 84 DUP5 10F8 90 SWAP1 10F9 55 SSTORE 10FA 84 DUP5 10FB 54 SLOAD 10FC 84 DUP5 10FD 82 DUP3 10FE 52 MSTORE 10FF 82 DUP3 1100 86 DUP7 1101 01 ADD 1102 90 SWAP1 1103 93 SWAP4 1104 52 MSTORE 1105 60 PUSH1 0x40 1107 90 SWAP1 1108 20 SHA3 1109 91 SWAP2 110A 90 SWAP1 110B 91 SWAP2 110C 55 SSTORE 110D 61 PUSH2 0x06a1 1110 56 *JUMP 1111 5B JUMPDEST 1112 50 POP 1113 60 PUSH1 0x00 1115 61 PUSH2 0x06a1 1118 56 *JUMP label_1119: // Incoming jump from 0x0AA3 // Inputs[1] { @1125 stack[-1] } 1119 5B JUMPDEST 111A 60 PUSH1 0x00 111C 60 PUSH1 0x01 111E 60 PUSH1 0x01 1120 60 PUSH1 0xe0 1122 1B SHL 1123 03 SUB 1124 19 NOT 1125 82 DUP3 1126 16 AND 1127 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 1148 14 EQ 1149 80 DUP1 114A 61 PUSH2 0x117c 114D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @111A stack[0] = 0x00 // @1148 stack[1] = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x117c, if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_114E: // Incoming jump from 0x114D, if not 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1158 stack[-3] } 114E 50 POP 114F 60 PUSH1 0x01 1151 60 PUSH1 0x01 1153 60 PUSH1 0xe0 1155 1B SHL 1156 03 SUB 1157 19 NOT 1158 82 DUP3 1159 16 AND 115A 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 117B 14 EQ 117C 5B JUMPDEST 117D 80 DUP1 117E 61 PUSH2 0x0428 1181 57 *JUMPI // Stack delta = +0 // Outputs[1] { @117B stack[-1] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0428, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_1182: // Incoming jump from 0x1181, if not 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1181, if not stack[-1] // Inputs[1] { @1186 stack[-3] } 1182 50 POP 1183 61 PUSH2 0x0428 1186 82 DUP3 1187 61 PUSH2 0x15b0 118A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1183 stack[-1] = 0x0428 // @1186 stack[0] = stack[-3] // } // Block ends with unconditional jump to 0x15b0 label_118B: // Incoming call from 0x0E21, returns to 0x0E22 // Inputs[3] // { // @118F stack[-3] // @1190 stack[-2] // @1191 stack[-1] // } 118B 5B JUMPDEST 118C 61 PUSH2 0x05a1 118F 83 DUP4 1190 83 DUP4 1191 83 DUP4 1192 61 PUSH2 0x15ee 1195 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @118C stack[0] = 0x05a1 // @118F stack[1] = stack[-3] // @1190 stack[2] = stack[-2] // @1191 stack[3] = stack[-1] // } // Block ends with call to 0x15ee, returns to 0x05A1 label_1196: // Incoming call from 0x0DB4, returns to 0x05D9 // Inputs[2] // { // @119A stack[-2] // @119B stack[-1] // } 1196 5B JUMPDEST 1197 61 PUSH2 0x11a0 119A 82 DUP3 119B 82 DUP3 119C 61 PUSH2 0x0898 119F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1197 stack[0] = 0x11a0 // @119A stack[1] = stack[-2] // @119B stack[2] = stack[-1] // } // Block ends with call to 0x0898, returns to 0x11A0 label_11A0: // Incoming return from call to 0x0898 at 0x119F // Inputs[1] { @11A1 stack[-1] } 11A0 5B JUMPDEST 11A1 15 ISZERO 11A2 61 PUSH2 0x05d9 11A5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05d9, if !stack[-1] label_11A6: // Incoming jump from 0x11A5, if not !stack[-1] // Inputs[5] // { // @11A8 stack[-2] // @11B4 memory[0x00:0x40] // @11BD stack[-1] // @11C5 memory[0x00:0x40] // @11C7 storage[keccak256(memory[0x00:0x40])] // } 11A6 60 PUSH1 0x00 11A8 82 DUP3 11A9 81 DUP2 11AA 52 MSTORE 11AB 60 PUSH1 0x20 11AD 81 DUP2 11AE 81 DUP2 11AF 52 MSTORE 11B0 60 PUSH1 0x40 11B2 80 DUP1 11B3 83 DUP4 11B4 20 SHA3 11B5 60 PUSH1 0x01 11B7 60 PUSH1 0x01 11B9 60 PUSH1 0xa0 11BB 1B SHL 11BC 03 SUB 11BD 85 DUP6 11BE 16 AND 11BF 84 DUP5 11C0 52 MSTORE 11C1 90 SWAP1 11C2 91 SWAP2 11C3 52 MSTORE 11C4 90 SWAP1 11C5 20 SHA3 11C6 80 DUP1 11C7 54 SLOAD 11C8 60 PUSH1 0xff 11CA 19 NOT 11CB 16 AND 11CC 90 SWAP1 11CD 55 SSTORE 11CE 61 PUSH2 0x11d5 11D1 61 PUSH2 0x0ac1 11D4 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @11AA memory[0x00:0x20] = stack[-2] // @11AF memory[0x20:0x40] = 0x00 // @11C0 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @11C3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @11CD storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @11CE stack[0] = 0x11d5 // } // Block ends with call to 0x0ac1, returns to 0x11D5 label_11D5: // Incoming return from call to 0x0AC1 at 0x11D4 // Inputs[7] // { // @11DE stack[-1] // @11DF stack[-2] // @11E9 stack[-3] // @120D memory[0x40:0x60] // @1210 memory[0x40:0x60] // @1215 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1218 stack[-4] // } 11D5 5B JUMPDEST 11D6 60 PUSH1 0x01 11D8 60 PUSH1 0x01 11DA 60 PUSH1 0xa0 11DC 1B SHL 11DD 03 SUB 11DE 16 AND 11DF 81 DUP2 11E0 60 PUSH1 0x01 11E2 60 PUSH1 0x01 11E4 60 PUSH1 0xa0 11E6 1B SHL 11E7 03 SUB 11E8 16 AND 11E9 83 DUP4 11EA 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 120B 60 PUSH1 0x40 120D 51 MLOAD 120E 60 PUSH1 0x40 1210 51 MLOAD 1211 80 DUP1 1212 91 SWAP2 1213 03 SUB 1214 90 SWAP1 1215 A4 LOG4 1216 50 POP 1217 50 POP 1218 56 *JUMP // Stack delta = -4 // Outputs[1] { @1215 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b, stack[-3], stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-4] label_1219: // Incoming call from 0x0DC9, returns to 0x0891 // Inputs[4] // { // @121C stack[-1] // @1221 stack[-2] // @1229 memory[0x00:0x40] // @122A storage[keccak256(memory[0x00:0x40])] // } 1219 5B JUMPDEST 121A 60 PUSH1 0x00 121C 81 DUP2 121D 81 DUP2 121E 52 MSTORE 121F 60 PUSH1 0x01 1221 83 DUP4 1222 01 ADD 1223 60 PUSH1 0x20 1225 52 MSTORE 1226 60 PUSH1 0x40 1228 81 DUP2 1229 20 SHA3 122A 54 SLOAD 122B 80 DUP1 122C 15 ISZERO 122D 61 PUSH2 0x132c 1230 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @121A stack[0] = 0x00 // @121E memory[0x00:0x20] = stack[-1] // @1225 memory[0x20:0x40] = stack[-2] + 0x01 // @122A stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x132c, if !storage[keccak256(memory[0x00:0x40])] label_1231: // Incoming jump from 0x1230, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1238 stack[-1] } 1231 60 PUSH1 0x00 1233 61 PUSH2 0x123d 1236 60 PUSH1 0x01 1238 83 DUP4 1239 61 PUSH2 0x28ad 123C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1231 stack[0] = 0x00 // @1233 stack[1] = 0x123d // @1236 stack[2] = 0x01 // @1238 stack[3] = stack[-1] // } // Block ends with call to 0x28ad, returns to 0x123D label_123D: // Incoming return from call to 0x28AD at 0x123C // Inputs[4] // { // @123E stack[-6] // @123F storage[stack[-6]] // @1240 stack[-1] // @1241 stack[-2] // } 123D 5B JUMPDEST 123E 85 DUP6 123F 54 SLOAD 1240 90 SWAP1 1241 91 SWAP2 1242 50 POP 1243 60 PUSH1 0x00 1245 90 SWAP1 1246 61 PUSH2 0x1251 1249 90 SWAP1 124A 60 PUSH1 0x01 124C 90 SWAP1 124D 61 PUSH2 0x28ad 1250 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1241 stack[-2] = stack[-1] // @1245 stack[-1] = 0x00 // @1249 stack[0] = 0x1251 // @124C stack[1] = 0x01 // @124C stack[2] = storage[stack[-6]] // } // Block ends with call to 0x28ad, returns to 0x1251 label_1251: // Incoming return from call to 0x28AD at 0x1250 // Inputs[4] // { // @1252 stack[-1] // @1252 stack[-2] // @1256 stack[-7] // @125C storage[0x00 + stack[-7]] // } 1251 5B JUMPDEST 1252 90 SWAP1 1253 50 POP 1254 60 PUSH1 0x00 1256 86 DUP7 1257 60 PUSH1 0x00 1259 01 ADD 125A 82 DUP3 125B 81 DUP2 125C 54 SLOAD 125D 81 DUP2 125E 10 LT 125F 61 PUSH2 0x1278 1262 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1252 stack[-2] = stack[-1] // @1254 stack[-1] = 0x00 // @1259 stack[0] = 0x00 + stack[-7] // @125A stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1278, if stack[-1] < storage[0x00 + stack[-7]] label_1263: // Incoming jump from 0x1262, if not stack[-1] < storage[0x00 + stack[-7]] // Inputs[1] { @1277 memory[0x00:0x24] } 1263 63 PUSH4 0x4e487b71 1268 60 PUSH1 0xe0 126A 1B SHL 126B 60 PUSH1 0x00 126D 52 MSTORE 126E 60 PUSH1 0x32 1270 60 PUSH1 0x04 1272 52 MSTORE 1273 60 PUSH1 0x24 1275 60 PUSH1 0x00 1277 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @126D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1272 memory[0x04:0x24] = 0x32 // @1277 revert(memory[0x00:0x24]); // } // Block terminates label_1278: // Incoming jump from 0x1262, if stack[-1] < storage[0x00 + stack[-7]] // Inputs[8] // { // @1279 stack[-1] // @1279 stack[-2] // @1281 memory[0x00:0x20] // @1283 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1284 stack[-3] // @1287 stack[-9] // @128B stack[-5] // @128D storage[0x00 + stack[-9]] // } 1278 5B JUMPDEST 1279 90 SWAP1 127A 60 PUSH1 0x00 127C 52 MSTORE 127D 60 PUSH1 0x20 127F 60 PUSH1 0x00 1281 20 SHA3 1282 01 ADD 1283 54 SLOAD 1284 90 SWAP1 1285 50 POP 1286 80 DUP1 1287 87 DUP8 1288 60 PUSH1 0x00 128A 01 ADD 128B 84 DUP5 128C 81 DUP2 128D 54 SLOAD 128E 81 DUP2 128F 10 LT 1290 61 PUSH2 0x12a9 1293 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @127C memory[0x00:0x20] = stack[-2] // @1284 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1286 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @128A stack[-1] = 0x00 + stack[-9] // @128B stack[0] = stack[-5] // } // Block ends with conditional jump to 0x12a9, if stack[-5] < storage[0x00 + stack[-9]] label_1294: // Incoming jump from 0x1293, if not stack[-5] < storage[0x00 + stack[-9]] // Inputs[1] { @12A8 memory[0x00:0x24] } 1294 63 PUSH4 0x4e487b71 1299 60 PUSH1 0xe0 129B 1B SHL 129C 60 PUSH1 0x00 129E 52 MSTORE 129F 60 PUSH1 0x32 12A1 60 PUSH1 0x04 12A3 52 MSTORE 12A4 60 PUSH1 0x24 12A6 60 PUSH1 0x00 12A8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @129E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @12A3 memory[0x04:0x24] = 0x32 // @12A8 revert(memory[0x00:0x24]); // } // Block terminates label_12A9: // Incoming jump from 0x1293, if stack[-5] < storage[0x00 + stack[-9]] // Inputs[5] // { // @12AC stack[-2] // @12B1 stack[-1] // @12B3 memory[0x00:0x20] // @12B5 stack[-3] // @12B9 stack[-6] // } 12A9 5B JUMPDEST 12AA 60 PUSH1 0x00 12AC 91 SWAP2 12AD 82 DUP3 12AE 52 MSTORE 12AF 60 PUSH1 0x20 12B1 90 SWAP1 12B2 91 SWAP2 12B3 20 SHA3 12B4 01 ADD 12B5 55 SSTORE 12B6 61 PUSH2 0x12c0 12B9 83 DUP4 12BA 60 PUSH1 0x01 12BC 61 PUSH2 0x2881 12BF 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @12AE memory[0x00:0x20] = stack[-2] // @12B5 storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @12B6 stack[-3] = 0x12c0 // @12B9 stack[-2] = stack[-6] // @12BA stack[-1] = 0x01 // } // Block ends with call to 0x2881, returns to 0x12C0 label_12C0: // Incoming return from call to 0x2881 at 0x12BF // Inputs[5] // { // @12C3 stack[-2] // @12C8 stack[-8] // @12D0 memory[0x00:0x40] // @12D1 stack[-1] // @12D3 storage[stack[-8]] // } 12C0 5B JUMPDEST 12C1 60 PUSH1 0x00 12C3 82 DUP3 12C4 81 DUP2 12C5 52 MSTORE 12C6 60 PUSH1 0x01 12C8 89 DUP10 12C9 01 ADD 12CA 60 PUSH1 0x20 12CC 52 MSTORE 12CD 60 PUSH1 0x40 12CF 90 SWAP1 12D0 20 SHA3 12D1 55 SSTORE 12D2 86 DUP7 12D3 54 SLOAD 12D4 87 DUP8 12D5 90 SWAP1 12D6 80 DUP1 12D7 61 PUSH2 0x12f0 12DA 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @12C5 memory[0x00:0x20] = stack[-2] // @12CC memory[0x20:0x40] = stack[-8] + 0x01 // @12D1 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @12D5 stack[0] = storage[stack[-8]] // @12D5 stack[-1] = stack[-8] // } // Block ends with conditional jump to 0x12f0, if storage[stack[-8]] label_12DB: // Incoming jump from 0x12DA, if not storage[stack[-8]] // Inputs[1] { @12EF memory[0x00:0x24] } 12DB 63 PUSH4 0x4e487b71 12E0 60 PUSH1 0xe0 12E2 1B SHL 12E3 60 PUSH1 0x00 12E5 52 MSTORE 12E6 60 PUSH1 0x31 12E8 60 PUSH1 0x04 12EA 52 MSTORE 12EB 60 PUSH1 0x24 12ED 60 PUSH1 0x00 12EF FD *REVERT // Stack delta = +0 // Outputs[3] // { // @12E5 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @12EA memory[0x04:0x24] = 0x31 // @12EF revert(memory[0x00:0x24]); // } // Block terminates label_12F0: // Incoming jump from 0x12DA, if storage[stack[-8]] // Inputs[7] // { // @12F3 stack[-1] // @12F5 stack[-2] // @12FF memory[0x00:0x20] // @1307 stack[-9] // @130D stack[-8] // @131B memory[0x00:0x40] // @1322 stack[-7] // } 12F0 5B JUMPDEST 12F1 60 PUSH1 0x01 12F3 90 SWAP1 12F4 03 SUB 12F5 81 DUP2 12F6 81 DUP2 12F7 90 SWAP1 12F8 60 PUSH1 0x00 12FA 52 MSTORE 12FB 60 PUSH1 0x20 12FD 60 PUSH1 0x00 12FF 20 SHA3 1300 01 ADD 1301 60 PUSH1 0x00 1303 90 SWAP1 1304 55 SSTORE 1305 90 SWAP1 1306 55 SSTORE 1307 86 DUP7 1308 60 PUSH1 0x01 130A 01 ADD 130B 60 PUSH1 0x00 130D 87 DUP8 130E 81 DUP2 130F 52 MSTORE 1310 60 PUSH1 0x20 1312 01 ADD 1313 90 SWAP1 1314 81 DUP2 1315 52 MSTORE 1316 60 PUSH1 0x20 1318 01 ADD 1319 60 PUSH1 0x00 131B 20 SHA3 131C 60 PUSH1 0x00 131E 90 SWAP1 131F 55 SSTORE 1320 60 PUSH1 0x01 1322 94 SWAP5 1323 50 POP 1324 50 POP 1325 50 POP 1326 50 POP 1327 50 POP 1328 61 PUSH2 0x06a1 132B 56 *JUMP // Stack delta = -6 // Outputs[7] // { // @12FA memory[0x00:0x20] = stack[-2] // @1304 storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @1306 storage[stack[-2]] = stack[-1] - 0x01 // @130F memory[0x00:0x20] = stack[-8] // @1315 memory[0x20:0x40] = 0x01 + stack[-9] // @131F storage[keccak256(memory[0x00:0x40])] = 0x00 // @1322 stack[-7] = 0x01 // } // Block ends with unconditional jump to 0x06a1 label_132C: // Incoming jump from 0x1230, if !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @132F stack[-2] } 132C 5B JUMPDEST 132D 60 PUSH1 0x00 132F 91 SWAP2 1330 50 POP 1331 50 POP 1332 61 PUSH2 0x06a1 1335 56 *JUMP // Stack delta = -1 // Outputs[1] { @132F stack[-2] = 0x00 } // Block ends with unconditional jump to 0x06a1 1336 5B JUMPDEST 1337 61 PUSH2 0x133f 133A 81 DUP2 133B 61 PUSH2 0x1677 133E 56 *JUMP 133F 5B JUMPDEST 1340 60 PUSH1 0x00 1342 81 DUP2 1343 81 DUP2 1344 52 MSTORE 1345 60 PUSH1 0x0c 1347 60 PUSH1 0x20 1349 52 MSTORE 134A 60 PUSH1 0x40 134C 90 SWAP1 134D 20 SHA3 134E 80 DUP1 134F 54 SLOAD 1350 61 PUSH2 0x1358 1353 90 SWAP1 1354 61 PUSH2 0x28f0 1357 56 *JUMP 1358 5B JUMPDEST 1359 15 ISZERO 135A 90 SWAP1 135B 50 POP 135C 61 PUSH2 0x0766 135F 57 *JUMPI 1360 60 PUSH1 0x00 1362 81 DUP2 1363 81 DUP2 1364 52 MSTORE 1365 60 PUSH1 0x0c 1367 60 PUSH1 0x20 1369 52 MSTORE 136A 60 PUSH1 0x40 136C 81 DUP2 136D 20 SHA3 136E 61 PUSH2 0x0766 1371 91 SWAP2 1372 61 PUSH2 0x1b72 1375 56 *JUMP label_1376: // Incoming call from 0x0ECA, returns to 0x0891 // Inputs[3] // { // @1377 stack[-2] // @1378 storage[stack[-2]] // @137C stack[-1] // } 1376 5B JUMPDEST 1377 81 DUP2 1378 54 SLOAD 1379 60 PUSH1 0x00 137B 90 SWAP1 137C 82 DUP3 137D 10 LT 137E 61 PUSH2 0x1399 1381 57 *JUMPI // Stack delta = +1 // Outputs[1] { @137B stack[0] = 0x00 } // Block ends with conditional jump to 0x1399, if stack[-1] < storage[stack[-2]] label_1382: // Incoming jump from 0x1381, if not stack[-1] < storage[stack[-2]] // Inputs[1] { @1384 memory[0x40:0x60] } 1382 60 PUSH1 0x40 1384 51 MLOAD 1385 62 PUSH3 0x461bcd 1389 60 PUSH1 0xe5 138B 1B SHL 138C 81 DUP2 138D 52 MSTORE 138E 60 PUSH1 0x04 1390 01 ADD 1391 61 PUSH2 0x04e9 1394 90 SWAP1 1395 61 PUSH2 0x1fa5 1398 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @138D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1394 stack[0] = 0x04e9 // @1394 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1fa5, returns to 0x04E9 label_1399: // Incoming jump from 0x1381, if stack[-1] < storage[stack[-2]] // Inputs[3] // { // @139A stack[-3] // @139E stack[-2] // @13A0 storage[0x00 + stack[-3]] // } 1399 5B JUMPDEST 139A 82 DUP3 139B 60 PUSH1 0x00 139D 01 ADD 139E 82 DUP3 139F 81 DUP2 13A0 54 SLOAD 13A1 81 DUP2 13A2 10 LT 13A3 61 PUSH2 0x13bc 13A6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @139D stack[0] = 0x00 + stack[-3] // @139E stack[1] = stack[-2] // } // Block ends with conditional jump to 0x13bc, if stack[-2] < storage[0x00 + stack[-3]] label_13A7: // Incoming jump from 0x13A6, if not stack[-2] < storage[0x00 + stack[-3]] // Inputs[1] { @13BB memory[0x00:0x24] } 13A7 63 PUSH4 0x4e487b71 13AC 60 PUSH1 0xe0 13AE 1B SHL 13AF 60 PUSH1 0x00 13B1 52 MSTORE 13B2 60 PUSH1 0x32 13B4 60 PUSH1 0x04 13B6 52 MSTORE 13B7 60 PUSH1 0x24 13B9 60 PUSH1 0x00 13BB FD *REVERT // Stack delta = +0 // Outputs[3] // { // @13B1 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @13B6 memory[0x04:0x24] = 0x32 // @13BB revert(memory[0x00:0x24]); // } // Block terminates label_13BC: // Incoming jump from 0x13A6, if stack[-2] < storage[0x00 + stack[-3]] // Inputs[7] // { // @13BD stack[-1] // @13BD stack[-2] // @13C5 memory[0x00:0x20] // @13C7 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @13C8 stack[-3] // @13CA stack[-6] // @13CB stack[-5] // } 13BC 5B JUMPDEST 13BD 90 SWAP1 13BE 60 PUSH1 0x00 13C0 52 MSTORE 13C1 60 PUSH1 0x20 13C3 60 PUSH1 0x00 13C5 20 SHA3 13C6 01 ADD 13C7 54 SLOAD 13C8 90 SWAP1 13C9 50 POP 13CA 92 SWAP3 13CB 91 SWAP2 13CC 50 POP 13CD 50 POP 13CE 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @13C0 memory[0x00:0x20] = stack[-2] // @13CA stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] 13CF 5B JUMPDEST 13D0 60 PUSH1 0x00 13D2 61 PUSH2 0x13e3 13D5 84 DUP5 13D6 60 PUSH1 0x01 13D8 60 PUSH1 0x01 13DA 60 PUSH1 0xa0 13DC 1B SHL 13DD 03 SUB 13DE 16 AND 13DF 61 PUSH2 0x172b 13E2 56 *JUMP 13E3 5B JUMPDEST 13E4 15 ISZERO 13E5 61 PUSH2 0x14f8 13E8 57 *JUMPI 13E9 83 DUP4 13EA 60 PUSH1 0x01 13EC 60 PUSH1 0x01 13EE 60 PUSH1 0xa0 13F0 1B SHL 13F1 03 SUB 13F2 16 AND 13F3 63 PUSH4 0x150b7a02 13F8 61 PUSH2 0x13ff 13FB 61 PUSH2 0x0ac1 13FE 56 *JUMP 13FF 5B JUMPDEST 1400 87 DUP8 1401 86 DUP7 1402 86 DUP7 1403 60 PUSH1 0x40 1405 51 MLOAD 1406 85 DUP6 1407 63 PUSH4 0xffffffff 140C 16 AND 140D 60 PUSH1 0xe0 140F 1B SHL 1410 81 DUP2 1411 52 MSTORE 1412 60 PUSH1 0x04 1414 01 ADD 1415 61 PUSH2 0x1421 1418 94 SWAP5 1419 93 SWAP4 141A 92 SWAP3 141B 91 SWAP2 141C 90 SWAP1 141D 61 PUSH2 0x1f42 1420 56 *JUMP 1421 5B JUMPDEST 1422 60 PUSH1 0x20 1424 60 PUSH1 0x40 1426 51 MLOAD 1427 80 DUP1 1428 83 DUP4 1429 03 SUB 142A 81 DUP2 142B 60 PUSH1 0x00 142D 87 DUP8 142E 80 DUP1 142F 3B EXTCODESIZE 1430 15 ISZERO 1431 80 DUP1 1432 15 ISZERO 1433 61 PUSH2 0x143b 1436 57 *JUMPI 1437 60 PUSH1 0x00 1439 80 DUP1 143A FD *REVERT 143B 5B JUMPDEST 143C 50 POP 143D 5A GAS 143E F1 CALL 143F 92 SWAP3 1440 50 POP 1441 50 POP 1442 50 POP 1443 80 DUP1 1444 15 ISZERO 1445 61 PUSH2 0x146b 1448 57 *JUMPI 1449 50 POP 144A 60 PUSH1 0x40 144C 80 DUP1 144D 51 MLOAD 144E 60 PUSH1 0x1f 1450 3D RETURNDATASIZE 1451 90 SWAP1 1452 81 DUP2 1453 01 ADD 1454 60 PUSH1 0x1f 1456 19 NOT 1457 16 AND 1458 82 DUP3 1459 01 ADD 145A 90 SWAP1 145B 92 SWAP3 145C 52 MSTORE 145D 61 PUSH2 0x1468 1460 91 SWAP2 1461 81 DUP2 1462 01 ADD 1463 90 SWAP1 1464 61 PUSH2 0x1e3f 1467 56 *JUMP 1468 5B JUMPDEST 1469 60 PUSH1 0x01 146B 5B JUMPDEST 146C 61 PUSH2 0x14c5 146F 57 *JUMPI 1470 3D RETURNDATASIZE 1471 80 DUP1 1472 80 DUP1 1473 15 ISZERO 1474 61 PUSH2 0x1499 1477 57 *JUMPI 1478 60 PUSH1 0x40 147A 51 MLOAD 147B 91 SWAP2 147C 50 POP 147D 60 PUSH1 0x1f 147F 19 NOT 1480 60 PUSH1 0x3f 1482 3D RETURNDATASIZE 1483 01 ADD 1484 16 AND 1485 82 DUP3 1486 01 ADD 1487 60 PUSH1 0x40 1489 52 MSTORE 148A 3D RETURNDATASIZE 148B 82 DUP3 148C 52 MSTORE 148D 3D RETURNDATASIZE 148E 60 PUSH1 0x00 1490 60 PUSH1 0x20 1492 84 DUP5 1493 01 ADD 1494 3E RETURNDATACOPY 1495 61 PUSH2 0x149e 1498 56 *JUMP 1499 5B JUMPDEST 149A 60 PUSH1 0x60 149C 91 SWAP2 149D 50 POP 149E 5B JUMPDEST 149F 50 POP 14A0 80 DUP1 14A1 51 MLOAD 14A2 61 PUSH2 0x14bd 14A5 57 *JUMPI 14A6 60 PUSH1 0x40 14A8 51 MLOAD 14A9 62 PUSH3 0x461bcd 14AD 60 PUSH1 0xe5 14AF 1B SHL 14B0 81 DUP2 14B1 52 MSTORE 14B2 60 PUSH1 0x04 14B4 01 ADD 14B5 61 PUSH2 0x04e9 14B8 90 SWAP1 14B9 61 PUSH2 0x20bc 14BC 56 *JUMP 14BD 5B JUMPDEST 14BE 80 DUP1 14BF 51 MLOAD 14C0 81 DUP2 14C1 60 PUSH1 0x20 14C3 01 ADD 14C4 FD *REVERT 14C5 5B JUMPDEST 14C6 60 PUSH1 0x01 14C8 60 PUSH1 0x01 14CA 60 PUSH1 0xe0 14CC 1B SHL 14CD 03 SUB 14CE 19 NOT 14CF 16 AND 14D0 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 14F1 14 EQ 14F2 90 SWAP1 14F3 50 POP 14F4 61 PUSH2 0x0c01 14F7 56 *JUMP 14F8 5B JUMPDEST 14F9 50 POP 14FA 60 PUSH1 0x01 14FC 94 SWAP5 14FD 93 SWAP4 14FE 50 POP 14FF 50 POP 1500 50 POP 1501 50 POP 1502 56 *JUMP label_1503: // Incoming jump from 0x0FC7 // Inputs[1] { @1509 storage[0x0d] } 1503 5B JUMPDEST 1504 60 PUSH1 0x60 1506 60 PUSH1 0x0d 1508 80 DUP1 1509 54 SLOAD 150A 61 PUSH2 0x043f 150D 90 SWAP1 150E 61 PUSH2 0x28f0 1511 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1504 stack[0] = 0x60 // @1506 stack[1] = 0x0d // @150D stack[2] = 0x043f // @150D stack[3] = storage[0x0d] // } // Block ends with call to 0x28f0, returns to 0x043F 1512 5B JUMPDEST 1513 60 PUSH1 0x60 1515 61 PUSH2 0x151d 1518 82 DUP3 1519 61 PUSH2 0x0aa4 151C 56 *JUMP 151D 5B JUMPDEST 151E 61 PUSH2 0x1539 1521 57 *JUMPI 1522 60 PUSH1 0x40 1524 51 MLOAD 1525 62 PUSH3 0x461bcd 1529 60 PUSH1 0xe5 152B 1B SHL 152C 81 DUP2 152D 52 MSTORE 152E 60 PUSH1 0x04 1530 01 ADD 1531 61 PUSH2 0x04e9 1534 90 SWAP1 1535 61 PUSH2 0x253c 1538 56 *JUMP 1539 5B JUMPDEST 153A 60 PUSH1 0x00 153C 61 PUSH2 0x1543 153F 61 PUSH2 0x1503 1542 56 *JUMP 1543 5B JUMPDEST 1544 90 SWAP1 1545 50 POP 1546 60 PUSH1 0x00 1548 81 DUP2 1549 51 MLOAD 154A 11 GT 154B 61 PUSH2 0x1563 154E 57 *JUMPI 154F 60 PUSH1 0x40 1551 51 MLOAD 1552 80 DUP1 1553 60 PUSH1 0x20 1555 01 ADD 1556 60 PUSH1 0x40 1558 52 MSTORE 1559 80 DUP1 155A 60 PUSH1 0x00 155C 81 DUP2 155D 52 MSTORE 155E 50 POP 155F 61 PUSH2 0x0891 1562 56 *JUMP 1563 5B JUMPDEST 1564 80 DUP1 1565 61 PUSH2 0x156d 1568 84 DUP5 1569 61 PUSH2 0x1731 156C 56 *JUMP 156D 5B JUMPDEST 156E 60 PUSH1 0x40 1570 51 MLOAD 1571 60 PUSH1 0x20 1573 01 ADD 1574 61 PUSH2 0x157e 1577 92 SWAP3 1578 91 SWAP2 1579 90 SWAP1 157A 61 PUSH2 0x1eff 157D 56 *JUMP 157E 5B JUMPDEST 157F 60 PUSH1 0x40 1581 51 MLOAD 1582 60 PUSH1 0x20 1584 81 DUP2 1585 83 DUP4 1586 03 SUB 1587 03 SUB 1588 81 DUP2 1589 52 MSTORE 158A 90 SWAP1 158B 60 PUSH1 0x40 158D 52 MSTORE 158E 93 SWAP4 158F 92 SWAP3 1590 50 POP 1591 50 POP 1592 50 POP 1593 56 *JUMP label_1594: // Incoming call from 0x1021, returns to 0x0428 // Inputs[3] // { // @1595 storage[stack[-1]] // @1595 stack[-1] // @1596 stack[-2] // } 1594 5B JUMPDEST 1595 54 SLOAD 1596 90 SWAP1 1597 56 *JUMP // Stack delta = -1 // Outputs[1] { @1596 stack[-2] = storage[stack[-1]] } // Block ends with unconditional jump to stack[-2] 1598 5B JUMPDEST 1599 60 PUSH1 0x00 159B 90 SWAP1 159C 81 DUP2 159D 52 MSTORE 159E 60 PUSH1 0x01 15A0 91 SWAP2 15A1 90 SWAP1 15A2 91 SWAP2 15A3 01 ADD 15A4 60 PUSH1 0x20 15A6 52 MSTORE 15A7 60 PUSH1 0x40 15A9 90 SWAP1 15AA 20 SHA3 15AB 54 SLOAD 15AC 15 ISZERO 15AD 15 ISZERO 15AE 90 SWAP1 15AF 56 *JUMP label_15B0: // Incoming jump from 0x118A // Inputs[1] { @15BC stack[-1] } 15B0 5B JUMPDEST 15B1 60 PUSH1 0x00 15B3 60 PUSH1 0x01 15B5 60 PUSH1 0x01 15B7 60 PUSH1 0xe0 15B9 1B SHL 15BA 03 SUB 15BB 19 NOT 15BC 82 DUP3 15BD 16 AND 15BE 7F PUSH32 0x5a05180f00000000000000000000000000000000000000000000000000000000 15DF 14 EQ 15E0 80 DUP1 15E1 61 PUSH2 0x0428 15E4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @15B1 stack[0] = 0x00 // @15DF stack[1] = 0x5a05180f00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0428, if 0x5a05180f00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_15E5: // Incoming jump from 0x15E4, if not 0x5a05180f00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @15E9 stack[-3] } 15E5 50 POP 15E6 61 PUSH2 0x0428 15E9 82 DUP3 15EA 61 PUSH2 0x1880 15ED 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @15E6 stack[-1] = 0x0428 // @15E9 stack[0] = stack[-3] // } // Block ends with unconditional jump to 0x1880 label_15EE: // Incoming call from 0x1195, returns to 0x05A1 // Inputs[3] // { // @15F2 stack[-3] // @15F3 stack[-2] // @15F4 stack[-1] // } 15EE 5B JUMPDEST 15EF 61 PUSH2 0x15f9 15F2 83 DUP4 15F3 83 DUP4 15F4 83 DUP4 15F5 61 PUSH2 0x05a1 15F8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15EF stack[0] = 0x15f9 // @15F2 stack[1] = stack[-3] // @15F3 stack[2] = stack[-2] // @15F4 stack[3] = stack[-1] // } // Block ends with call to 0x05a1, returns to 0x15F9 label_15F9: // Incoming return from call to 0x05A1 at 0x15F8 // Inputs[1] { @1602 stack[-3] } 15F9 5B JUMPDEST 15FA 60 PUSH1 0x01 15FC 60 PUSH1 0x01 15FE 60 PUSH1 0xa0 1600 1B SHL 1601 03 SUB 1602 83 DUP4 1603 16 AND 1604 61 PUSH2 0x1615 1607 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1615, if stack[-3] & (0x01 << 0xa0) - 0x01 label_1608: // Incoming jump from 0x1607, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @160B stack[-1] } 1608 61 PUSH2 0x1610 160B 81 DUP2 160C 61 PUSH2 0x18be 160F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1608 stack[0] = 0x1610 // @160B stack[1] = stack[-1] // } // Block ends with call to 0x18be, returns to 0x1610 label_1610: // Incoming return from call to 0x18BE at 0x160F 1610 5B JUMPDEST 1611 61 PUSH2 0x1638 1614 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1638 label_1615: // Incoming jump from 0x1607, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1616 stack[-2] // @1620 stack[-3] // } 1615 5B JUMPDEST 1616 81 DUP2 1617 60 PUSH1 0x01 1619 60 PUSH1 0x01 161B 60 PUSH1 0xa0 161D 1B SHL 161E 03 SUB 161F 16 AND 1620 83 DUP4 1621 60 PUSH1 0x01 1623 60 PUSH1 0x01 1625 60 PUSH1 0xa0 1627 1B SHL 1628 03 SUB 1629 16 AND 162A 14 EQ 162B 61 PUSH2 0x1638 162E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1638, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] label_162F: // Incoming jump from 0x162E, if not (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[2] // { // @1632 stack[-3] // @1633 stack[-1] // } 162F 61 PUSH2 0x1638 1632 83 DUP4 1633 82 DUP3 1634 61 PUSH2 0x1902 1637 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @162F stack[0] = 0x1638 // @1632 stack[1] = stack[-3] // @1633 stack[2] = stack[-1] // } // Block ends with call to 0x1902, returns to 0x1638 label_1638: // Incoming jump from 0x162E, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Incoming jump from 0x1614 // Incoming return from call to 0x1902 at 0x1637 // Inputs[1] { @1641 stack[-2] } 1638 5B JUMPDEST 1639 60 PUSH1 0x01 163B 60 PUSH1 0x01 163D 60 PUSH1 0xa0 163F 1B SHL 1640 03 SUB 1641 82 DUP3 1642 16 AND 1643 61 PUSH2 0x1654 1646 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1654, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1647: // Incoming jump from 0x1646, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @164A stack[-1] } 1647 61 PUSH2 0x164f 164A 81 DUP2 164B 61 PUSH2 0x199f 164E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1647 stack[0] = 0x164f // @164A stack[1] = stack[-1] // } // Block ends with call to 0x199f, returns to 0x164F label_164F: // Incoming return from call to 0x199F at 0x164E 164F 5B JUMPDEST 1650 61 PUSH2 0x05a1 1653 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05a1 label_1654: // Incoming jump from 0x1646, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1655 stack[-3] // @165F stack[-2] // } 1654 5B JUMPDEST 1655 82 DUP3 1656 60 PUSH1 0x01 1658 60 PUSH1 0x01 165A 60 PUSH1 0xa0 165C 1B SHL 165D 03 SUB 165E 16 AND 165F 82 DUP3 1660 60 PUSH1 0x01 1662 60 PUSH1 0x01 1664 60 PUSH1 0xa0 1666 1B SHL 1667 03 SUB 1668 16 AND 1669 14 EQ 166A 61 PUSH2 0x05a1 166D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a1, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] label_166E: // Incoming jump from 0x166D, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @1671 stack[-2] // @1672 stack[-1] // } 166E 61 PUSH2 0x05a1 1671 82 DUP3 1672 82 DUP3 1673 61 PUSH2 0x1a78 1676 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @166E stack[0] = 0x05a1 // @1671 stack[1] = stack[-2] // @1672 stack[2] = stack[-1] // } // Block ends with call to 0x1a78, returns to 0x05A1 1677 5B JUMPDEST 1678 60 PUSH1 0x00 167A 61 PUSH2 0x1682 167D 82 DUP3 167E 61 PUSH2 0x0800 1681 56 *JUMP 1682 5B JUMPDEST 1683 90 SWAP1 1684 50 POP 1685 61 PUSH2 0x1690 1688 81 DUP2 1689 60 PUSH1 0x00 168B 84 DUP5 168C 61 PUSH2 0x118b 168F 56 *JUMP 1690 5B JUMPDEST 1691 61 PUSH2 0x169b 1694 60 PUSH1 0x00 1696 83 DUP4 1697 61 PUSH2 0x0ac5 169A 56 *JUMP 169B 5B JUMPDEST 169C 60 PUSH1 0x01 169E 60 PUSH1 0x01 16A0 60 PUSH1 0xa0 16A2 1B SHL 16A3 03 SUB 16A4 81 DUP2 16A5 16 AND 16A6 60 PUSH1 0x00 16A8 90 SWAP1 16A9 81 DUP2 16AA 52 MSTORE 16AB 60 PUSH1 0x05 16AD 60 PUSH1 0x20 16AF 52 MSTORE 16B0 60 PUSH1 0x40 16B2 81 DUP2 16B3 20 SHA3 16B4 80 DUP1 16B5 54 SLOAD 16B6 60 PUSH1 0x01 16B8 92 SWAP3 16B9 90 SWAP1 16BA 61 PUSH2 0x16c4 16BD 90 SWAP1 16BE 84 DUP5 16BF 90 SWAP1 16C0 61 PUSH2 0x28ad 16C3 56 *JUMP 16C4 5B JUMPDEST 16C5 90 SWAP1 16C6 91 SWAP2 16C7 55 SSTORE 16C8 50 POP 16C9 50 POP 16CA 60 PUSH1 0x00 16CC 82 DUP3 16CD 81 DUP2 16CE 52 MSTORE 16CF 60 PUSH1 0x04 16D1 60 PUSH1 0x20 16D3 52 MSTORE 16D4 60 PUSH1 0x40 16D6 80 DUP1 16D7 82 DUP3 16D8 20 SHA3 16D9 80 DUP1 16DA 54 SLOAD 16DB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16F0 19 NOT 16F1 16 AND 16F2 90 SWAP1 16F3 55 SSTORE 16F4 51 MLOAD 16F5 83 DUP4 16F6 91 SWAP2 16F7 90 SWAP1 16F8 60 PUSH1 0x01 16FA 60 PUSH1 0x01 16FC 60 PUSH1 0xa0 16FE 1B SHL 16FF 03 SUB 1700 84 DUP5 1701 16 AND 1702 90 SWAP1 1703 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1724 90 SWAP1 1725 83 DUP4 1726 90 SWAP1 1727 A4 LOG4 1728 50 POP 1729 50 POP 172A 56 *JUMP 172B 5B JUMPDEST 172C 3B EXTCODESIZE 172D 15 ISZERO 172E 15 ISZERO 172F 90 SWAP1 1730 56 *JUMP 1731 5B JUMPDEST 1732 60 PUSH1 0x60 1734 81 DUP2 1735 61 PUSH2 0x1772 1738 57 *JUMPI 1739 50 POP 173A 60 PUSH1 0x40 173C 80 DUP1 173D 51 MLOAD 173E 80 DUP1 173F 82 DUP3 1740 01 ADD 1741 90 SWAP1 1742 91 SWAP2 1743 52 MSTORE 1744 60 PUSH1 0x01 1746 81 DUP2 1747 52 MSTORE 1748 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 1769 60 PUSH1 0x20 176B 82 DUP3 176C 01 ADD 176D 52 MSTORE 176E 61 PUSH2 0x042b 1771 56 *JUMP 1772 5B JUMPDEST 1773 81 DUP2 1774 60 PUSH1 0x00 1776 5B JUMPDEST 1777 81 DUP2 1778 15 ISZERO 1779 61 PUSH2 0x179c 177C 57 *JUMPI 177D 80 DUP1 177E 61 PUSH2 0x1786 1781 81 DUP2 1782 61 PUSH2 0x292b 1785 56 *JUMP 1786 5B JUMPDEST 1787 91 SWAP2 1788 50 POP 1789 61 PUSH2 0x1795 178C 90 SWAP1 178D 50 POP 178E 60 PUSH1 0x0a 1790 83 DUP4 1791 61 PUSH2 0x2899 1794 56 *JUMP 1795 5B JUMPDEST 1796 91 SWAP2 1797 50 POP 1798 61 PUSH2 0x1776 179B 56 *JUMP 179C 5B JUMPDEST 179D 60 PUSH1 0x00 179F 81 DUP2 17A0 67 PUSH8 0xffffffffffffffff 17A9 81 DUP2 17AA 11 GT 17AB 15 ISZERO 17AC 61 PUSH2 0x17c5 17AF 57 *JUMPI 17B0 63 PUSH4 0x4e487b71 17B5 60 PUSH1 0xe0 17B7 1B SHL 17B8 60 PUSH1 0x00 17BA 52 MSTORE 17BB 60 PUSH1 0x41 17BD 60 PUSH1 0x04 17BF 52 MSTORE 17C0 60 PUSH1 0x24 17C2 60 PUSH1 0x00 17C4 FD *REVERT 17C5 5B JUMPDEST 17C6 60 PUSH1 0x40 17C8 51 MLOAD 17C9 90 SWAP1 17CA 80 DUP1 17CB 82 DUP3 17CC 52 MSTORE 17CD 80 DUP1 17CE 60 PUSH1 0x1f 17D0 01 ADD 17D1 60 PUSH1 0x1f 17D3 19 NOT 17D4 16 AND 17D5 60 PUSH1 0x20 17D7 01 ADD 17D8 82 DUP3 17D9 01 ADD 17DA 60 PUSH1 0x40 17DC 52 MSTORE 17DD 80 DUP1 17DE 15 ISZERO 17DF 61 PUSH2 0x17ef 17E2 57 *JUMPI 17E3 60 PUSH1 0x20 17E5 82 DUP3 17E6 01 ADD 17E7 81 DUP2 17E8 80 DUP1 17E9 36 CALLDATASIZE 17EA 83 DUP4 17EB 37 CALLDATACOPY 17EC 01 ADD 17ED 90 SWAP1 17EE 50 POP 17EF 5B JUMPDEST 17F0 50 POP 17F1 90 SWAP1 17F2 50 POP 17F3 5B JUMPDEST 17F4 84 DUP5 17F5 15 ISZERO 17F6 61 PUSH2 0x0c01 17F9 57 *JUMPI 17FA 61 PUSH2 0x1804 17FD 60 PUSH1 0x01 17FF 83 DUP4 1800 61 PUSH2 0x28ad 1803 56 *JUMP 1804 5B JUMPDEST 1805 91 SWAP2 1806 50 POP 1807 61 PUSH2 0x1811 180A 60 PUSH1 0x0a 180C 86 DUP7 180D 61 PUSH2 0x2946 1810 56 *JUMP 1811 5B JUMPDEST 1812 61 PUSH2 0x181c 1815 90 SWAP1 1816 60 PUSH1 0x30 1818 61 PUSH2 0x2881 181B 56 *JUMP 181C 5B JUMPDEST 181D 60 PUSH1 0xf8 181F 1B SHL 1820 81 DUP2 1821 83 DUP4 1822 81 DUP2 1823 51 MLOAD 1824 81 DUP2 1825 10 LT 1826 61 PUSH2 0x183f 1829 57 *JUMPI 182A 63 PUSH4 0x4e487b71 182F 60 PUSH1 0xe0 1831 1B SHL 1832 60 PUSH1 0x00 1834 52 MSTORE 1835 60 PUSH1 0x32 1837 60 PUSH1 0x04 1839 52 MSTORE 183A 60 PUSH1 0x24 183C 60 PUSH1 0x00 183E FD *REVERT 183F 5B JUMPDEST 1840 60 PUSH1 0x20 1842 01 ADD 1843 01 ADD 1844 90 SWAP1 1845 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1865 19 NOT 1866 16 AND 1867 90 SWAP1 1868 81 DUP2 1869 60 PUSH1 0x00 186B 1A BYTE 186C 90 SWAP1 186D 53 MSTORE8 186E 50 POP 186F 61 PUSH2 0x1879 1872 60 PUSH1 0x0a 1874 86 DUP7 1875 61 PUSH2 0x2899 1878 56 *JUMP 1879 5B JUMPDEST 187A 94 SWAP5 187B 50 POP 187C 61 PUSH2 0x17f3 187F 56 *JUMP label_1880: // Incoming jump from 0x15ED // Inputs[1] { @188C stack[-1] } 1880 5B JUMPDEST 1881 60 PUSH1 0x00 1883 60 PUSH1 0x01 1885 60 PUSH1 0x01 1887 60 PUSH1 0xe0 1889 1B SHL 188A 03 SUB 188B 19 NOT 188C 82 DUP3 188D 16 AND 188E 7F PUSH32 0x7965db0b00000000000000000000000000000000000000000000000000000000 18AF 14 EQ 18B0 80 DUP1 18B1 61 PUSH2 0x0428 18B4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1881 stack[0] = 0x00 // @18AF stack[1] = 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0428, if 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_18B5: // Incoming jump from 0x18B4, if not 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @18B9 stack[-3] } 18B5 50 POP 18B6 61 PUSH2 0x0428 18B9 82 DUP3 18BA 61 PUSH2 0x1abc 18BD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @18B6 stack[-1] = 0x0428 // @18B9 stack[0] = stack[-3] // } // Block ends with call to 0x1abc, returns to 0x0428 label_18BE: // Incoming call from 0x160F, returns to 0x1610 // Inputs[4] // { // @18C2 storage[0x0a] // @18C5 stack[-1] // @18D0 memory[0x00:0x40] // @1901 stack[-2] // } 18BE 5B JUMPDEST 18BF 60 PUSH1 0x0a 18C1 80 DUP1 18C2 54 SLOAD 18C3 60 PUSH1 0x00 18C5 83 DUP4 18C6 81 DUP2 18C7 52 MSTORE 18C8 60 PUSH1 0x0b 18CA 60 PUSH1 0x20 18CC 52 MSTORE 18CD 60 PUSH1 0x40 18CF 81 DUP2 18D0 20 SHA3 18D1 82 DUP3 18D2 90 SWAP1 18D3 55 SSTORE 18D4 60 PUSH1 0x01 18D6 82 DUP3 18D7 01 ADD 18D8 83 DUP4 18D9 55 SSTORE 18DA 91 SWAP2 18DB 90 SWAP1 18DC 91 SWAP2 18DD 52 MSTORE 18DE 7F PUSH32 0xc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a8 18FF 01 ADD 1900 55 SSTORE 1901 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @18C7 memory[0x00:0x20] = stack[-1] // @18CC memory[0x20:0x40] = 0x0b // @18D3 storage[keccak256(memory[0x00:0x40])] = storage[0x0a] // @18D9 storage[0x0a] = storage[0x0a] + 0x01 // @18DD memory[0x00:0x20] = 0x0a // @1900 storage[0xc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a8 + storage[0x0a]] = stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1902: // Incoming call from 0x1637, returns to 0x1638 // Inputs[1] { @190A stack[-2] } 1902 5B JUMPDEST 1903 60 PUSH1 0x00 1905 60 PUSH1 0x01 1907 61 PUSH2 0x190f 190A 84 DUP5 190B 61 PUSH2 0x0835 190E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1903 stack[0] = 0x00 // @1905 stack[1] = 0x01 // @1907 stack[2] = 0x190f // @190A stack[3] = stack[-2] // } // Block ends with call to 0x0835, returns to 0x190F label_190F: // Incoming return from call to 0x0835 at 0x190E // Inputs[2] // { // @1913 stack[-2] // @1914 stack[-1] // } 190F 5B JUMPDEST 1910 61 PUSH2 0x1919 1913 91 SWAP2 1914 90 SWAP1 1915 61 PUSH2 0x28ad 1918 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1913 stack[-2] = 0x1919 // @1914 stack[-1] = stack[-2] // @1914 stack[0] = stack[-1] // } // Block ends with call to 0x28ad, returns to 0x1919 label_1919: // Incoming return from call to 0x28AD at 0x1918 // Inputs[5] // { // @191C stack[-3] // @1927 memory[0x00:0x40] // @1928 storage[keccak256(memory[0x00:0x40])] // @1929 stack[-1] // @192A stack[-2] // } 1919 5B JUMPDEST 191A 60 PUSH1 0x00 191C 83 DUP4 191D 81 DUP2 191E 52 MSTORE 191F 60 PUSH1 0x09 1921 60 PUSH1 0x20 1923 52 MSTORE 1924 60 PUSH1 0x40 1926 90 SWAP1 1927 20 SHA3 1928 54 SLOAD 1929 90 SWAP1 192A 91 SWAP2 192B 50 POP 192C 80 DUP1 192D 82 DUP3 192E 14 EQ 192F 61 PUSH2 0x196c 1932 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @191E memory[0x00:0x20] = stack[-3] // @1923 memory[0x20:0x40] = 0x09 // @1929 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @192A stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x196c, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_1933: // Incoming jump from 0x1932, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[13] // { // @193B stack[-4] // @194D memory[0x00:0x40] // @194E stack[-2] // @1955 memory[0x00:0x40] // @1956 storage[keccak256(memory[0x00:0x40])] // @1957 stack[-1] // @195C memory[0x00:0x40] // @1968 memory[0x00:0x40] // @1970 stack[-3] // @197E memory[0x00:0x40] // @1995 memory[0x00:0x40] // @199C memory[0x00:0x40] // @199E stack[-5] // } 1933 60 PUSH1 0x01 1935 60 PUSH1 0x01 1937 60 PUSH1 0xa0 1939 1B SHL 193A 03 SUB 193B 84 DUP5 193C 16 AND 193D 60 PUSH1 0x00 193F 90 SWAP1 1940 81 DUP2 1941 52 MSTORE 1942 60 PUSH1 0x08 1944 60 PUSH1 0x20 1946 90 SWAP1 1947 81 DUP2 1948 52 MSTORE 1949 60 PUSH1 0x40 194B 80 DUP1 194C 83 DUP4 194D 20 SHA3 194E 85 DUP6 194F 84 DUP5 1950 52 MSTORE 1951 82 DUP3 1952 52 MSTORE 1953 80 DUP1 1954 83 DUP4 1955 20 SHA3 1956 54 SLOAD 1957 84 DUP5 1958 84 DUP5 1959 52 MSTORE 195A 81 DUP2 195B 84 DUP5 195C 20 SHA3 195D 81 DUP2 195E 90 SWAP1 195F 55 SSTORE 1960 83 DUP4 1961 52 MSTORE 1962 60 PUSH1 0x09 1964 90 SWAP1 1965 91 SWAP2 1966 52 MSTORE 1967 90 SWAP1 1968 20 SHA3 1969 81 DUP2 196A 90 SWAP1 196B 55 SSTORE 196C 5B JUMPDEST 196D 50 POP 196E 60 PUSH1 0x00 1970 91 SWAP2 1971 82 DUP3 1972 52 MSTORE 1973 60 PUSH1 0x09 1975 60 PUSH1 0x20 1977 90 SWAP1 1978 81 DUP2 1979 52 MSTORE 197A 60 PUSH1 0x40 197C 80 DUP1 197D 84 DUP5 197E 20 SHA3 197F 84 DUP5 1980 90 SWAP1 1981 55 SSTORE 1982 60 PUSH1 0x01 1984 60 PUSH1 0x01 1986 60 PUSH1 0xa0 1988 1B SHL 1989 03 SUB 198A 90 SWAP1 198B 94 SWAP5 198C 16 AND 198D 83 DUP4 198E 52 MSTORE 198F 60 PUSH1 0x08 1991 81 DUP2 1992 52 MSTORE 1993 83 DUP4 1994 83 DUP4 1995 20 SHA3 1996 91 SWAP2 1997 83 DUP4 1998 52 MSTORE 1999 52 MSTORE 199A 90 SWAP1 199B 81 DUP2 199C 20 SHA3 199D 55 SSTORE 199E 56 *JUMP // Stack delta = -5 // Outputs[17] // { // @1941 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1948 memory[0x20:0x40] = 0x08 // @1950 memory[0x00:0x20] = stack[-2] // @1952 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1959 memory[0x00:0x20] = stack[-1] // @195F storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @1961 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @1966 memory[0x20:0x40] = 0x09 // @196B storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1972 memory[0x00:0x20] = stack[-3] // @1979 memory[0x20:0x40] = 0x09 // @1981 storage[keccak256(memory[0x00:0x40])] = 0x00 // @198E memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1992 memory[0x20:0x40] = 0x08 // @1998 memory[0x00:0x20] = stack[-2] // @1999 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @199D storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_199F: // Incoming call from 0x164E, returns to 0x164F // Inputs[1] { @19A2 storage[0x0a] } 199F 5B JUMPDEST 19A0 60 PUSH1 0x0a 19A2 54 SLOAD 19A3 60 PUSH1 0x00 19A5 90 SWAP1 19A6 61 PUSH2 0x19b1 19A9 90 SWAP1 19AA 60 PUSH1 0x01 19AC 90 SWAP1 19AD 61 PUSH2 0x28ad 19B0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19A5 stack[0] = 0x00 // @19A9 stack[1] = 0x19b1 // @19AC stack[2] = 0x01 // @19AC stack[3] = storage[0x0a] // } // Block ends with call to 0x28ad, returns to 0x19B1 label_19B1: // Incoming return from call to 0x28AD at 0x19B0 // Inputs[6] // { // @19B4 stack[-3] // @19BF memory[0x00:0x40] // @19C0 storage[keccak256(memory[0x00:0x40])] // @19C4 storage[0x0a] // @19C5 stack[-1] // @19C6 stack[-2] // } 19B1 5B JUMPDEST 19B2 60 PUSH1 0x00 19B4 83 DUP4 19B5 81 DUP2 19B6 52 MSTORE 19B7 60 PUSH1 0x0b 19B9 60 PUSH1 0x20 19BB 52 MSTORE 19BC 60 PUSH1 0x40 19BE 81 DUP2 19BF 20 SHA3 19C0 54 SLOAD 19C1 60 PUSH1 0x0a 19C3 80 DUP1 19C4 54 SLOAD 19C5 93 SWAP4 19C6 94 SWAP5 19C7 50 POP 19C8 90 SWAP1 19C9 92 SWAP3 19CA 84 DUP5 19CB 90 SWAP1 19CC 81 DUP2 19CD 10 LT 19CE 61 PUSH2 0x19e7 19D1 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @19B2 stack[0] = 0x00 // @19B6 memory[0x00:0x20] = stack[-3] // @19BB memory[0x20:0x40] = 0x0b // @19C6 stack[-2] = stack[-1] // @19C8 stack[1] = 0x0a // @19C9 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @19CB stack[2] = stack[-1] // } // Block ends with conditional jump to 0x19e7, if stack[-1] < storage[0x0a] label_19D2: // Incoming jump from 0x19D1, if not stack[-1] < storage[0x0a] // Inputs[1] { @19E6 memory[0x00:0x24] } 19D2 63 PUSH4 0x4e487b71 19D7 60 PUSH1 0xe0 19D9 1B SHL 19DA 60 PUSH1 0x00 19DC 52 MSTORE 19DD 60 PUSH1 0x32 19DF 60 PUSH1 0x04 19E1 52 MSTORE 19E2 60 PUSH1 0x24 19E4 60 PUSH1 0x00 19E6 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @19DC memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @19E1 memory[0x04:0x24] = 0x32 // @19E6 revert(memory[0x00:0x24]); // } // Block terminates label_19E7: // Incoming jump from 0x19D1, if stack[-1] < storage[0x0a] // Inputs[7] // { // @19E8 stack[-1] // @19E8 stack[-2] // @19F0 memory[0x00:0x20] // @19F2 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @19F3 stack[-3] // @19F8 stack[-4] // @19FA storage[0x0a] // } 19E7 5B JUMPDEST 19E8 90 SWAP1 19E9 60 PUSH1 0x00 19EB 52 MSTORE 19EC 60 PUSH1 0x20 19EE 60 PUSH1 0x00 19F0 20 SHA3 19F1 01 ADD 19F2 54 SLOAD 19F3 90 SWAP1 19F4 50 POP 19F5 80 DUP1 19F6 60 PUSH1 0x0a 19F8 83 DUP4 19F9 81 DUP2 19FA 54 SLOAD 19FB 81 DUP2 19FC 10 LT 19FD 61 PUSH2 0x1a16 1A00 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @19EB memory[0x00:0x20] = stack[-2] // @19F3 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @19F5 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @19F6 stack[-1] = 0x0a // @19F8 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x1a16, if stack[-4] < storage[0x0a] label_1A01: // Incoming jump from 0x1A00, if not stack[-4] < storage[0x0a] // Inputs[1] { @1A15 memory[0x00:0x24] } 1A01 63 PUSH4 0x4e487b71 1A06 60 PUSH1 0xe0 1A08 1B SHL 1A09 60 PUSH1 0x00 1A0B 52 MSTORE 1A0C 60 PUSH1 0x32 1A0E 60 PUSH1 0x04 1A10 52 MSTORE 1A11 60 PUSH1 0x24 1A13 60 PUSH1 0x00 1A15 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A0B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1A10 memory[0x04:0x24] = 0x32 // @1A15 revert(memory[0x00:0x24]); // } // Block terminates label_1A16: // Incoming jump from 0x1A00, if stack[-4] < storage[0x0a] // Inputs[10] // { // @1A19 stack[-2] // @1A20 memory[0x00:0x20] // @1A22 stack[-1] // @1A24 stack[-3] // @1A28 stack[-4] // @1A34 memory[0x00:0x40] // @1A35 stack[-5] // @1A38 stack[-7] // @1A3C memory[0x00:0x40] // @1A41 storage[0x0a] // } 1A16 5B JUMPDEST 1A17 60 PUSH1 0x00 1A19 91 SWAP2 1A1A 82 DUP3 1A1B 52 MSTORE 1A1C 60 PUSH1 0x20 1A1E 80 DUP1 1A1F 83 DUP4 1A20 20 SHA3 1A21 90 SWAP1 1A22 91 SWAP2 1A23 01 ADD 1A24 92 SWAP3 1A25 90 SWAP1 1A26 92 SWAP3 1A27 55 SSTORE 1A28 82 DUP3 1A29 81 DUP2 1A2A 52 MSTORE 1A2B 60 PUSH1 0x0b 1A2D 90 SWAP1 1A2E 91 SWAP2 1A2F 52 MSTORE 1A30 60 PUSH1 0x40 1A32 80 DUP1 1A33 82 DUP3 1A34 20 SHA3 1A35 84 DUP5 1A36 90 SWAP1 1A37 55 SSTORE 1A38 85 DUP6 1A39 82 DUP3 1A3A 52 MSTORE 1A3B 81 DUP2 1A3C 20 SHA3 1A3D 55 SSTORE 1A3E 60 PUSH1 0x0a 1A40 80 DUP1 1A41 54 SLOAD 1A42 80 DUP1 1A43 61 PUSH2 0x1a5c 1A46 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @1A1B memory[0x00:0x20] = stack[-2] // @1A27 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @1A2A memory[0x00:0x20] = stack[-4] // @1A2F memory[0x20:0x40] = 0x0b // @1A37 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @1A3A memory[0x00:0x20] = stack[-7] // @1A3D storage[keccak256(memory[0x00:0x40])] = 0x00 // @1A3E stack[-3] = 0x0a // @1A41 stack[-2] = storage[0x0a] // } // Block ends with conditional jump to 0x1a5c, if storage[0x0a] label_1A47: // Incoming jump from 0x1A46, if not storage[0x0a] // Inputs[1] { @1A5B memory[0x00:0x24] } 1A47 63 PUSH4 0x4e487b71 1A4C 60 PUSH1 0xe0 1A4E 1B SHL 1A4F 60 PUSH1 0x00 1A51 52 MSTORE 1A52 60 PUSH1 0x31 1A54 60 PUSH1 0x04 1A56 52 MSTORE 1A57 60 PUSH1 0x24 1A59 60 PUSH1 0x00 1A5B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A51 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1A56 memory[0x04:0x24] = 0x31 // @1A5B revert(memory[0x00:0x24]); // } // Block terminates label_1A5C: // Incoming jump from 0x1A46, if storage[0x0a] // Inputs[4] // { // @1A5F stack[-1] // @1A61 stack[-2] // @1A6B memory[0x00:0x20] // @1A77 stack[-7] // } 1A5C 5B JUMPDEST 1A5D 60 PUSH1 0x01 1A5F 90 SWAP1 1A60 03 SUB 1A61 81 DUP2 1A62 81 DUP2 1A63 90 SWAP1 1A64 60 PUSH1 0x00 1A66 52 MSTORE 1A67 60 PUSH1 0x20 1A69 60 PUSH1 0x00 1A6B 20 SHA3 1A6C 01 ADD 1A6D 60 PUSH1 0x00 1A6F 90 SWAP1 1A70 55 SSTORE 1A71 90 SWAP1 1A72 55 SSTORE 1A73 50 POP 1A74 50 POP 1A75 50 POP 1A76 50 POP 1A77 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @1A66 memory[0x00:0x20] = stack[-2] // @1A70 storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @1A72 storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_1A78: // Incoming call from 0x1676, returns to 0x05A1 // Inputs[1] { @1A7E stack[-2] } 1A78 5B JUMPDEST 1A79 60 PUSH1 0x00 1A7B 61 PUSH2 0x1a83 1A7E 83 DUP4 1A7F 61 PUSH2 0x0835 1A82 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A79 stack[0] = 0x00 // @1A7B stack[1] = 0x1a83 // @1A7E stack[2] = stack[-2] // } // Block ends with call to 0x0835, returns to 0x1A83 label_1A83: // Incoming return from call to 0x0835 at 0x1A82 // Inputs[8] // { // @1A8C stack[-1] // @1A8D stack[-4] // @1A9F memory[0x00:0x40] // @1AA7 memory[0x00:0x40] // @1AA8 stack[-3] // @1AB3 stack[-2] // @1AB5 memory[0x00:0x40] // @1ABB stack[-5] // } 1A83 5B JUMPDEST 1A84 60 PUSH1 0x01 1A86 60 PUSH1 0x01 1A88 60 PUSH1 0xa0 1A8A 1B SHL 1A8B 03 SUB 1A8C 90 SWAP1 1A8D 93 SWAP4 1A8E 16 AND 1A8F 60 PUSH1 0x00 1A91 90 SWAP1 1A92 81 DUP2 1A93 52 MSTORE 1A94 60 PUSH1 0x08 1A96 60 PUSH1 0x20 1A98 90 SWAP1 1A99 81 DUP2 1A9A 52 MSTORE 1A9B 60 PUSH1 0x40 1A9D 80 DUP1 1A9E 83 DUP4 1A9F 20 SHA3 1AA0 86 DUP7 1AA1 84 DUP5 1AA2 52 MSTORE 1AA3 82 DUP3 1AA4 52 MSTORE 1AA5 80 DUP1 1AA6 83 DUP4 1AA7 20 SHA3 1AA8 85 DUP6 1AA9 90 SWAP1 1AAA 55 SSTORE 1AAB 93 SWAP4 1AAC 82 DUP3 1AAD 52 MSTORE 1AAE 60 PUSH1 0x09 1AB0 90 SWAP1 1AB1 52 MSTORE 1AB2 91 SWAP2 1AB3 90 SWAP1 1AB4 91 SWAP2 1AB5 20 SHA3 1AB6 91 SWAP2 1AB7 90 SWAP1 1AB8 91 SWAP2 1AB9 55 SSTORE 1ABA 50 POP 1ABB 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @1A93 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1A9A memory[0x20:0x40] = 0x08 // @1AA2 memory[0x00:0x20] = stack[-1] // @1AA4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1AAA storage[keccak256(memory[0x00:0x40])] = stack[-3] // @1AAD memory[0x00:0x20] = stack[-3] // @1AB1 memory[0x20:0x40] = 0x09 // @1AB9 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_1ABC: // Incoming call from 0x18BD, returns to 0x0428 // Inputs[2] // { // @1AC6 stack[-1] // @1AEA stack[-2] // } 1ABC 5B JUMPDEST 1ABD 60 PUSH1 0x01 1ABF 60 PUSH1 0x01 1AC1 60 PUSH1 0xe0 1AC3 1B SHL 1AC4 03 SUB 1AC5 19 NOT 1AC6 81 DUP2 1AC7 16 AND 1AC8 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 1AE9 14 EQ 1AEA 91 SWAP2 1AEB 90 SWAP1 1AEC 50 POP 1AED 56 *JUMP // Stack delta = -1 // Outputs[1] { @1AEA stack[-2] = 0x01ffc9a700000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) } // Block ends with unconditional jump to stack[-2] label_1AEE: // Incoming jump from 0x0B83 // Incoming jump from 0x07FF // Inputs[2] // { // @1AEF stack[-3] // @1AF1 storage[stack[-3]] // } 1AEE 5B JUMPDEST 1AEF 82 DUP3 1AF0 80 DUP1 1AF1 54 SLOAD 1AF2 61 PUSH2 0x1afa 1AF5 90 SWAP1 1AF6 61 PUSH2 0x28f0 1AF9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AEF stack[0] = stack[-3] // @1AF5 stack[1] = 0x1afa // @1AF5 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x28f0, returns to 0x1AFA label_1AFA: // Incoming return from call to 0x28F0 at 0x1AF9 // Inputs[5] // { // @1AFB stack[-2] // @1AFB stack[-1] // @1B03 memory[0x00:0x20] // @1B0E stack[-4] // @1B0F stack[-3] // } 1AFA 5B JUMPDEST 1AFB 90 SWAP1 1AFC 60 PUSH1 0x00 1AFE 52 MSTORE 1AFF 60 PUSH1 0x20 1B01 60 PUSH1 0x00 1B03 20 SHA3 1B04 90 SWAP1 1B05 60 PUSH1 0x1f 1B07 01 ADD 1B08 60 PUSH1 0x20 1B0A 90 SWAP1 1B0B 04 DIV 1B0C 81 DUP2 1B0D 01 ADD 1B0E 92 SWAP3 1B0F 82 DUP3 1B10 61 PUSH2 0x1b1c 1B13 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1AFE memory[0x00:0x20] = stack[-2] // @1B04 stack[-2] = keccak256(memory[0x00:0x20]) // @1B0E stack[-1] = stack[-4] // @1B0E stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1b1c, if stack[-3] label_1B14: // Incoming jump from 0x1B13, if not stack[-3] // Inputs[1] { @1B16 stack[-5] } 1B14 60 PUSH1 0x00 1B16 85 DUP6 1B17 55 SSTORE 1B18 61 PUSH2 0x1b62 1B1B 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B17 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1b62 label_1B1C: // Incoming jump from 0x1B13, if stack[-3] // Inputs[1] { @1B1D stack[-3] } 1B1C 5B JUMPDEST 1B1D 82 DUP3 1B1E 60 PUSH1 0x1f 1B20 10 LT 1B21 61 PUSH2 0x1b35 1B24 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b35, if 0x1f < stack[-3] label_1B25: // Incoming jump from 0x1B24, if not 0x1f < stack[-3] // Inputs[4] // { // @1B25 stack[-1] // @1B26 memory[stack[-1]:stack[-1] + 0x20] // @1B2B stack[-3] // @1B2F stack[-5] // } 1B25 80 DUP1 1B26 51 MLOAD 1B27 60 PUSH1 0xff 1B29 19 NOT 1B2A 16 AND 1B2B 83 DUP4 1B2C 80 DUP1 1B2D 01 ADD 1B2E 17 OR 1B2F 85 DUP6 1B30 55 SSTORE 1B31 61 PUSH2 0x1b62 1B34 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B30 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1b62 label_1B35: // Incoming jump from 0x1B24, if 0x1f < stack[-3] // Inputs[2] // { // @1B36 stack[-3] // @1B3C stack[-5] // } 1B35 5B JUMPDEST 1B36 82 DUP3 1B37 80 DUP1 1B38 01 ADD 1B39 60 PUSH1 0x01 1B3B 01 ADD 1B3C 85 DUP6 1B3D 55 SSTORE 1B3E 82 DUP3 1B3F 15 ISZERO 1B40 61 PUSH2 0x1b62 1B43 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B3D storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1b62, if !stack[-3] label_1B44: // Incoming jump from 0x1B43, if not !stack[-3] // Inputs[2] // { // @1B44 stack[-1] // @1B44 stack[-3] // } 1B44 91 SWAP2 1B45 82 DUP3 1B46 01 ADD 1B47 5B JUMPDEST 1B48 82 DUP3 1B49 81 DUP2 1B4A 11 GT 1B4B 15 ISZERO 1B4C 61 PUSH2 0x1b62 1B4F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1B44 stack[-3] = stack[-1] // @1B46 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1b62, if !(stack[-1] + stack[-3] > stack[-1]) label_1B50: // Incoming jump from 0x1B4F, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1B4F, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @1B50 stack[-3] // @1B51 memory[stack[-3]:stack[-3] + 0x20] // @1B52 stack[-2] // @1B54 stack[-1] // } 1B50 82 DUP3 1B51 51 MLOAD 1B52 82 DUP3 1B53 55 SSTORE 1B54 91 SWAP2 1B55 60 PUSH1 0x20 1B57 01 ADD 1B58 91 SWAP2 1B59 90 SWAP1 1B5A 60 PUSH1 0x01 1B5C 01 ADD 1B5D 90 SWAP1 1B5E 61 PUSH2 0x1b47 1B61 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1B53 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1B58 stack[-3] = 0x20 + stack[-3] // @1B5D stack[-2] = 0x01 + stack[-2] // @1B5D stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1b47 label_1B62: // Incoming jump from 0x1B34 // Incoming jump from 0x1B4F, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1B43, if !stack[-3] // Incoming jump from 0x1B1B // Incoming jump from 0x1B4F, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @1B67 stack[-4] // @1B68 stack[-3] // } 1B62 5B JUMPDEST 1B63 50 POP 1B64 61 PUSH2 0x1b6e 1B67 92 SWAP3 1B68 91 SWAP2 1B69 50 POP 1B6A 61 PUSH2 0x1baa 1B6D 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1B67 stack[-4] = 0x1b6e // @1B68 stack[-3] = stack[-4] // } // Block ends with call to 0x1baa, returns to 0x1B6E label_1B6E: // Incoming jump from 0x1BB3, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1BB3, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1BAA at 0x1B6D // Inputs[2] // { // @1B70 stack[-3] // @1B70 stack[-2] // } 1B6E 5B JUMPDEST 1B6F 50 POP 1B70 90 SWAP1 1B71 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B70 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] 1B72 5B JUMPDEST 1B73 50 POP 1B74 80 DUP1 1B75 54 SLOAD 1B76 61 PUSH2 0x1b7e 1B79 90 SWAP1 1B7A 61 PUSH2 0x28f0 1B7D 56 *JUMP 1B7E 5B JUMPDEST 1B7F 60 PUSH1 0x00 1B81 82 DUP3 1B82 55 SSTORE 1B83 80 DUP1 1B84 60 PUSH1 0x1f 1B86 10 LT 1B87 61 PUSH2 0x1b90 1B8A 57 *JUMPI 1B8B 50 POP 1B8C 61 PUSH2 0x0766 1B8F 56 *JUMP 1B90 5B JUMPDEST 1B91 60 PUSH1 0x1f 1B93 01 ADD 1B94 60 PUSH1 0x20 1B96 90 SWAP1 1B97 04 DIV 1B98 90 SWAP1 1B99 60 PUSH1 0x00 1B9B 52 MSTORE 1B9C 60 PUSH1 0x20 1B9E 60 PUSH1 0x00 1BA0 20 SHA3 1BA1 90 SWAP1 1BA2 81 DUP2 1BA3 01 ADD 1BA4 90 SWAP1 1BA5 61 PUSH2 0x0766 1BA8 91 SWAP2 1BA9 90 SWAP1 label_1BAA: // Incoming call from 0x1B6D, returns to 0x1B6E // Inputs[2] // { // @1BAC stack[-1] // @1BAD stack[-2] // } 1BAA 5B JUMPDEST 1BAB 5B JUMPDEST 1BAC 80 DUP1 1BAD 82 DUP3 1BAE 11 GT 1BAF 15 ISZERO 1BB0 61 PUSH2 0x1b6e 1BB3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b6e, if !(stack[-2] > stack[-1]) label_1BB4: // Incoming jump from 0x1BB3, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1BB3, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1BB6 stack[-1] } 1BB4 60 PUSH1 0x00 1BB6 81 DUP2 1BB7 55 SSTORE 1BB8 60 PUSH1 0x01 1BBA 01 ADD 1BBB 61 PUSH2 0x1bab 1BBE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1BB7 storage[stack[-1]] = 0x00 // @1BBA stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1bab label_1BBF: // Incoming call from 0x1C64, returns to 0x0891 // Incoming call from 0x1D58, returns to 0x1D59 // Inputs[1] { @1BCC stack[-2] } 1BBF 5B JUMPDEST 1BC0 60 PUSH1 0x00 1BC2 67 PUSH8 0xffffffffffffffff 1BCB 80 DUP1 1BCC 84 DUP5 1BCD 11 GT 1BCE 15 ISZERO 1BCF 61 PUSH2 0x1bda 1BD2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BC0 stack[0] = 0x00 // @1BC2 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1bda, if !(stack[-2] > 0xffffffffffffffff) label_1BD3: // Incoming jump from 0x1BD2, if not !(stack[-2] > 0xffffffffffffffff) 1BD3 61 PUSH2 0x1bda 1BD6 61 PUSH2 0x2986 1BD9 56 *JUMP // Stack delta = +1 // Outputs[1] { @1BD3 stack[0] = 0x1bda } // Block ends with unconditional jump to 0x2986 label_1BDA: // Incoming jump from 0x1BD2, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @1BDD memory[0x40:0x60] // @1BE0 stack[-4] // @1BEB stack[-1] // } 1BDA 5B JUMPDEST 1BDB 60 PUSH1 0x40 1BDD 51 MLOAD 1BDE 60 PUSH1 0x1f 1BE0 85 DUP6 1BE1 01 ADD 1BE2 60 PUSH1 0x1f 1BE4 19 NOT 1BE5 16 AND 1BE6 81 DUP2 1BE7 01 ADD 1BE8 60 PUSH1 0x20 1BEA 01 ADD 1BEB 82 DUP3 1BEC 81 DUP2 1BED 11 GT 1BEE 82 DUP3 1BEF 82 DUP3 1BF0 10 LT 1BF1 17 OR 1BF2 15 ISZERO 1BF3 61 PUSH2 0x1bfe 1BF6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BDD stack[0] = memory[0x40:0x60] // @1BEA stack[1] = 0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) // } // Block ends with conditional jump to 0x1bfe, if !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) > stack[-1])) label_1BF7: // Incoming jump from 0x1BF6, if not !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) > stack[-1])) 1BF7 61 PUSH2 0x1bfe 1BFA 61 PUSH2 0x2986 1BFD 56 *JUMP // Stack delta = +1 // Outputs[1] { @1BF7 stack[0] = 0x1bfe } // Block ends with unconditional jump to 0x2986 label_1BFE: // Incoming jump from 0x1BF6, if !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) > stack[-1])) // Inputs[6] // { // @1C01 stack[-1] // @1C02 stack[-6] // @1C03 stack[-2] // @1C05 stack[-4] // @1C08 stack[-5] // @1C0B stack[-7] // } 1BFE 5B JUMPDEST 1BFF 60 PUSH1 0x40 1C01 52 MSTORE 1C02 84 DUP5 1C03 81 DUP2 1C04 52 MSTORE 1C05 91 SWAP2 1C06 50 POP 1C07 81 DUP2 1C08 83 DUP4 1C09 85 DUP6 1C0A 01 ADD 1C0B 86 DUP7 1C0C 10 LT 1C0D 15 ISZERO 1C0E 61 PUSH2 0x1c16 1C11 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @1C01 memory[0x40:0x60] = stack[-1] // @1C04 memory[stack[-2]:stack[-2] + 0x20] = stack[-6] // @1C05 stack[-4] = stack[-2] // @1C07 stack[-2] = stack[-2] // } // Block ends with conditional jump to 0x1c16, if !(stack[-7] < stack[-6] + stack[-5]) label_1C12: // Incoming jump from 0x1C11, if not !(stack[-7] < stack[-6] + stack[-5]) // Inputs[1] { @1C15 memory[0x00:0x00] } 1C12 60 PUSH1 0x00 1C14 80 DUP1 1C15 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C15 revert(memory[0x00:0x00]); } // Block terminates label_1C16: // Incoming jump from 0x1C11, if !(stack[-7] < stack[-6] + stack[-5]) // Inputs[7] // { // @1C17 stack[-5] // @1C18 stack[-4] // @1C1B stack[-1] // @1C1D msg.data[stack[-4]:stack[-4] + stack[-5]] // @1C29 stack[-7] // @1C29 stack[-3] // @1C2A stack[-6] // } 1C16 5B JUMPDEST 1C17 84 DUP5 1C18 84 DUP5 1C19 60 PUSH1 0x20 1C1B 83 DUP4 1C1C 01 ADD 1C1D 37 CALLDATACOPY 1C1E 60 PUSH1 0x00 1C20 60 PUSH1 0x20 1C22 86 DUP7 1C23 83 DUP4 1C24 01 ADD 1C25 01 ADD 1C26 52 MSTORE 1C27 50 POP 1C28 50 POP 1C29 93 SWAP4 1C2A 92 SWAP3 1C2B 50 POP 1C2C 50 POP 1C2D 50 POP 1C2E 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @1C1D memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-5]] = msg.data[stack[-4]:stack[-4] + stack[-5]] // @1C26 memory[stack[-1] + stack[-5] + 0x20:stack[-1] + stack[-5] + 0x20 + 0x20] = 0x00 // @1C29 stack[-7] = stack[-3] // } // Block ends with unconditional jump to stack[-7] label_1C2F: // Incoming call from 0x1CCD, returns to 0x1CCE // Incoming call from 0x1C7E, returns to 0x0891 // Incoming call from 0x1E01, returns to 0x1CA8 // Incoming call from 0x1D09, returns to 0x1D0A // Incoming call from 0x1D7F, returns to 0x1D80 // Incoming call from 0x1DB9, returns to 0x1DBA // Incoming call from 0x1D17, returns to 0x1D18 // Incoming call from 0x1CA7, returns to 0x1CA8 // Incoming call from 0x1CDB, returns to 0x1CDC // Incoming call from 0x1C99, returns to 0x1C9A // Inputs[2] // { // @1C30 stack[-1] // @1C31 msg.data[stack[-1]:stack[-1] + 0x20] // } 1C2F 5B JUMPDEST 1C30 80 DUP1 1C31 35 CALLDATALOAD 1C32 60 PUSH1 0x01 1C34 60 PUSH1 0x01 1C36 60 PUSH1 0xa0 1C38 1B SHL 1C39 03 SUB 1C3A 81 DUP2 1C3B 16 AND 1C3C 81 DUP2 1C3D 14 EQ 1C3E 61 PUSH2 0x042b 1C41 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C31 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x042b, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1C42: // Incoming jump from 0x1C41, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1C45 memory[0x00:0x00] } 1C42 60 PUSH1 0x00 1C44 80 DUP1 1C45 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C45 revert(memory[0x00:0x00]); } // Block terminates label_1C46: // Incoming call from 0x1EC8, returns to 0x1EC9 // Incoming call from 0x1E8D, returns to 0x0C01 // Inputs[2] // { // @1C49 stack[-2] // @1C4C stack[-1] // } 1C46 5B JUMPDEST 1C47 60 PUSH1 0x00 1C49 82 DUP3 1C4A 60 PUSH1 0x1f 1C4C 83 DUP4 1C4D 01 ADD 1C4E 12 SLT 1C4F 61 PUSH2 0x1c56 1C52 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C47 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c56, if stack[-1] + 0x1f i< stack[-2] label_1C53: // Incoming jump from 0x1C52, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1C53 stack[-1] // @1C55 memory[stack[-1]:stack[-1] + stack[-1]] // } 1C53 80 DUP1 1C54 81 DUP2 1C55 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C55 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1C56: // Incoming jump from 0x1C52, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1C5A stack[-3] // @1C5B stack[-2] // @1C5C msg.data[stack[-2]:stack[-2] + 0x20] // } 1C56 5B JUMPDEST 1C57 61 PUSH2 0x0891 1C5A 83 DUP4 1C5B 83 DUP4 1C5C 35 CALLDATALOAD 1C5D 60 PUSH1 0x20 1C5F 85 DUP6 1C60 01 ADD 1C61 61 PUSH2 0x1bbf 1C64 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C57 stack[0] = 0x0891 // @1C5A stack[1] = stack[-3] // @1C5C stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @1C60 stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x1bbf, returns to 0x0891 label_1C65: // Incoming call from 0x034D, returns to 0x034E // Inputs[2] // { // @1C6A stack[-1] // @1C6B stack[-2] // } 1C65 5B JUMPDEST 1C66 60 PUSH1 0x00 1C68 60 PUSH1 0x20 1C6A 82 DUP3 1C6B 84 DUP5 1C6C 03 SUB 1C6D 12 SLT 1C6E 15 ISZERO 1C6F 61 PUSH2 0x1c76 1C72 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C66 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c76, if !(stack[-2] - stack[-1] i< 0x20) label_1C73: // Incoming jump from 0x1C72, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1C73 stack[-1] // @1C75 memory[stack[-1]:stack[-1] + stack[-1]] // } 1C73 80 DUP1 1C74 81 DUP2 1C75 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C75 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1C76: // Incoming jump from 0x1C72, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1C7A stack[-2] } 1C76 5B JUMPDEST 1C77 61 PUSH2 0x0891 1C7A 82 DUP3 1C7B 61 PUSH2 0x1c2f 1C7E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C77 stack[0] = 0x0891 // @1C7A stack[1] = stack[-2] // } // Block ends with call to 0x1c2f, returns to 0x0891 label_1C7F: // Incoming jump from 0x03FD // Inputs[2] // { // @1C85 stack[-1] // @1C86 stack[-2] // } 1C7F 5B JUMPDEST 1C80 60 PUSH1 0x00 1C82 80 DUP1 1C83 60 PUSH1 0x40 1C85 83 DUP4 1C86 85 DUP6 1C87 03 SUB 1C88 12 SLT 1C89 15 ISZERO 1C8A 61 PUSH2 0x1c91 1C8D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C80 stack[0] = 0x00 // @1C82 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c91, if !(stack[-2] - stack[-1] i< 0x40) label_1C8E: // Incoming jump from 0x1C8D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1C8E stack[-1] // @1C90 memory[stack[-1]:stack[-1] + stack[-1]] // } 1C8E 80 DUP1 1C8F 81 DUP2 1C90 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C90 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1C91: // Incoming jump from 0x1C8D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1C95 stack[-3] } 1C91 5B JUMPDEST 1C92 61 PUSH2 0x1c9a 1C95 83 DUP4 1C96 61 PUSH2 0x1c2f 1C99 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C92 stack[0] = 0x1c9a // @1C95 stack[1] = stack[-3] // } // Block ends with call to 0x1c2f, returns to 0x1C9A label_1C9A: // Incoming return from call to 0x1C2F at 0x1C99 // Inputs[3] // { // @1C9B stack[-1] // @1C9B stack[-3] // @1CA2 stack[-4] // } 1C9A 5B JUMPDEST 1C9B 91 SWAP2 1C9C 50 POP 1C9D 61 PUSH2 0x1ca8 1CA0 60 PUSH1 0x20 1CA2 84 DUP5 1CA3 01 ADD 1CA4 61 PUSH2 0x1c2f 1CA7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1C9B stack[-3] = stack[-1] // @1C9D stack[-1] = 0x1ca8 // @1CA3 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1c2f, returns to 0x1CA8 label_1CA8: // Incoming return from call to 0x1C2F at 0x1CA7 // Incoming return from call to 0x1C2F at 0x1E01 // Inputs[6] // { // @1CA9 stack[-1] // @1CA9 stack[-2] // @1CAB stack[-5] // @1CAD stack[-6] // @1CAD stack[-3] // @1CAE stack[-4] // } 1CA8 5B JUMPDEST 1CA9 90 SWAP1 1CAA 50 POP 1CAB 92 SWAP3 1CAC 50 POP 1CAD 92 SWAP3 1CAE 90 SWAP1 1CAF 50 POP 1CB0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1CAB stack[-5] = stack[-1] // @1CAD stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1CB1: // Incoming call from 0x02EE, returns to 0x02EF // Incoming call from 0x027C, returns to 0x027D // Inputs[2] // { // @1CB9 stack[-1] // @1CBA stack[-2] // } 1CB1 5B JUMPDEST 1CB2 60 PUSH1 0x00 1CB4 80 DUP1 1CB5 60 PUSH1 0x00 1CB7 60 PUSH1 0x60 1CB9 84 DUP5 1CBA 86 DUP7 1CBB 03 SUB 1CBC 12 SLT 1CBD 15 ISZERO 1CBE 61 PUSH2 0x1cc5 1CC1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1CB2 stack[0] = 0x00 // @1CB4 stack[1] = 0x00 // @1CB5 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1cc5, if !(stack[-2] - stack[-1] i< 0x60) label_1CC2: // Incoming jump from 0x1CC1, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1CC2 stack[-1] // @1CC4 memory[stack[-1]:stack[-1] + stack[-1]] // } 1CC2 80 DUP1 1CC3 81 DUP2 1CC4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CC4 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1CC5: // Incoming jump from 0x1CC1, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1CC9 stack[-4] } 1CC5 5B JUMPDEST 1CC6 61 PUSH2 0x1cce 1CC9 84 DUP5 1CCA 61 PUSH2 0x1c2f 1CCD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1CC6 stack[0] = 0x1cce // @1CC9 stack[1] = stack[-4] // } // Block ends with call to 0x1c2f, returns to 0x1CCE label_1CCE: // Incoming return from call to 0x1C2F at 0x1CCD // Inputs[3] // { // @1CCF stack[-1] // @1CCF stack[-4] // @1CD6 stack[-5] // } 1CCE 5B JUMPDEST 1CCF 92 SWAP3 1CD0 50 POP 1CD1 61 PUSH2 0x1cdc 1CD4 60 PUSH1 0x20 1CD6 85 DUP6 1CD7 01 ADD 1CD8 61 PUSH2 0x1c2f 1CDB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1CCF stack[-4] = stack[-1] // @1CD1 stack[-1] = 0x1cdc // @1CD7 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1c2f, returns to 0x1CDC label_1CDC: // Incoming return from call to 0x1C2F at 0x1CDB // Inputs[8] // { // @1CDD stack[-3] // @1CDD stack[-1] // @1CE1 stack[-5] // @1CE3 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1CE4 stack[-2] // @1CE8 stack[-6] // @1CEA stack[-4] // @1CEA stack[-7] // } 1CDC 5B JUMPDEST 1CDD 91 SWAP2 1CDE 50 POP 1CDF 60 PUSH1 0x40 1CE1 84 DUP5 1CE2 01 ADD 1CE3 35 CALLDATALOAD 1CE4 90 SWAP1 1CE5 50 POP 1CE6 92 SWAP3 1CE7 50 POP 1CE8 92 SWAP3 1CE9 50 POP 1CEA 92 SWAP3 1CEB 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1CE6 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1CE8 stack[-6] = stack[-1] // @1CEA stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1CEC: // Incoming call from 0x03A9, returns to 0x03AA // Inputs[2] // { // @1CF5 stack[-1] // @1CF6 stack[-2] // } 1CEC 5B JUMPDEST 1CED 60 PUSH1 0x00 1CEF 80 DUP1 1CF0 60 PUSH1 0x00 1CF2 80 DUP1 1CF3 60 PUSH1 0x80 1CF5 85 DUP6 1CF6 87 DUP8 1CF7 03 SUB 1CF8 12 SLT 1CF9 15 ISZERO 1CFA 61 PUSH2 0x1d01 1CFD 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1CED stack[0] = 0x00 // @1CEF stack[1] = 0x00 // @1CF0 stack[2] = 0x00 // @1CF2 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1d01, if !(stack[-2] - stack[-1] i< 0x80) label_1CFE: // Incoming jump from 0x1CFD, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1CFE stack[-1] // @1D00 memory[stack[-1]:stack[-1] + stack[-1]] // } 1CFE 80 DUP1 1CFF 81 DUP2 1D00 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D00 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1D01: // Incoming jump from 0x1CFD, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1D05 stack[-5] } 1D01 5B JUMPDEST 1D02 61 PUSH2 0x1d0a 1D05 85 DUP6 1D06 61 PUSH2 0x1c2f 1D09 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D02 stack[0] = 0x1d0a // @1D05 stack[1] = stack[-5] // } // Block ends with call to 0x1c2f, returns to 0x1D0A label_1D0A: // Incoming return from call to 0x1C2F at 0x1D09 // Inputs[3] // { // @1D0B stack[-1] // @1D0B stack[-5] // @1D12 stack[-6] // } 1D0A 5B JUMPDEST 1D0B 93 SWAP4 1D0C 50 POP 1D0D 61 PUSH2 0x1d18 1D10 60 PUSH1 0x20 1D12 86 DUP7 1D13 01 ADD 1D14 61 PUSH2 0x1c2f 1D17 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D0B stack[-5] = stack[-1] // @1D0D stack[-1] = 0x1d18 // @1D13 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1c2f, returns to 0x1D18 label_1D18: // Incoming return from call to 0x1C2F at 0x1D17 // Inputs[6] // { // @1D19 stack[-1] // @1D19 stack[-4] // @1D1D stack[-6] // @1D1F msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1D20 stack[-3] // @1D26 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1D18 5B JUMPDEST 1D19 92 SWAP3 1D1A 50 POP 1D1B 60 PUSH1 0x40 1D1D 85 DUP6 1D1E 01 ADD 1D1F 35 CALLDATALOAD 1D20 91 SWAP2 1D21 50 POP 1D22 60 PUSH1 0x60 1D24 85 DUP6 1D25 01 ADD 1D26 35 CALLDATALOAD 1D27 67 PUSH8 0xffffffffffffffff 1D30 81 DUP2 1D31 11 GT 1D32 15 ISZERO 1D33 61 PUSH2 0x1d3a 1D36 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1D19 stack[-4] = stack[-1] // @1D20 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1D26 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1d3a, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_1D37: // Incoming jump from 0x1D36, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1D37 stack[-2] // @1D39 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D37 81 DUP2 1D38 82 DUP3 1D39 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D39 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1D3A: // Incoming jump from 0x1D36, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1D3B stack[-6] // @1D3C stack[-1] // @1D41 stack[-7] // } 1D3A 5B JUMPDEST 1D3B 85 DUP6 1D3C 01 ADD 1D3D 60 PUSH1 0x1f 1D3F 81 DUP2 1D40 01 ADD 1D41 87 DUP8 1D42 13 SGT 1D43 61 PUSH2 0x1d4a 1D46 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1D3C stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x1d4a, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1D47: // Incoming jump from 0x1D46, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @1D47 stack[-2] // @1D49 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D47 81 DUP2 1D48 82 DUP3 1D49 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D49 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1D4A: // Incoming jump from 0x1D46, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @1D4E stack[-7] // @1D4F stack[-1] // @1D50 msg.data[stack[-1]:stack[-1] + 0x20] // } 1D4A 5B JUMPDEST 1D4B 61 PUSH2 0x1d59 1D4E 87 DUP8 1D4F 82 DUP3 1D50 35 CALLDATALOAD 1D51 60 PUSH1 0x20 1D53 84 DUP5 1D54 01 ADD 1D55 61 PUSH2 0x1bbf 1D58 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D4B stack[0] = 0x1d59 // @1D4E stack[1] = stack[-7] // @1D50 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1D54 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1bbf, returns to 0x1D59 label_1D59: // Incoming return from call to 0x1BBF at 0x1D58 // Inputs[8] // { // @1D5A stack[-1] // @1D5A stack[-3] // @1D5D stack[-6] // @1D5E stack[-9] // @1D5F stack[-5] // @1D60 stack[-8] // @1D62 stack[-4] // @1D62 stack[-7] // } 1D59 5B JUMPDEST 1D5A 91 SWAP2 1D5B 50 POP 1D5C 50 POP 1D5D 92 SWAP3 1D5E 95 SWAP6 1D5F 91 SWAP2 1D60 94 SWAP5 1D61 50 POP 1D62 92 SWAP3 1D63 50 POP 1D64 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1D5D stack[-6] = stack[-1] // @1D5E stack[-9] = stack[-6] // @1D60 stack[-8] = stack[-5] // @1D62 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1D65: // Incoming call from 0x0396, returns to 0x0397 // Inputs[2] // { // @1D6B stack[-1] // @1D6C stack[-2] // } 1D65 5B JUMPDEST 1D66 60 PUSH1 0x00 1D68 80 DUP1 1D69 60 PUSH1 0x40 1D6B 83 DUP4 1D6C 85 DUP6 1D6D 03 SUB 1D6E 12 SLT 1D6F 15 ISZERO 1D70 61 PUSH2 0x1d77 1D73 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D66 stack[0] = 0x00 // @1D68 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d77, if !(stack[-2] - stack[-1] i< 0x40) label_1D74: // Incoming jump from 0x1D73, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D74 stack[-2] // @1D76 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D74 81 DUP2 1D75 82 DUP3 1D76 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D76 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1D77: // Incoming jump from 0x1D73, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D7B stack[-3] } 1D77 5B JUMPDEST 1D78 61 PUSH2 0x1d80 1D7B 83 DUP4 1D7C 61 PUSH2 0x1c2f 1D7F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D78 stack[0] = 0x1d80 // @1D7B stack[1] = stack[-3] // } // Block ends with call to 0x1c2f, returns to 0x1D80 label_1D80: // Incoming return from call to 0x1C2F at 0x1D7F // Inputs[4] // { // @1D81 stack[-3] // @1D81 stack[-1] // @1D85 stack[-4] // @1D87 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1D80 5B JUMPDEST 1D81 91 SWAP2 1D82 50 POP 1D83 60 PUSH1 0x20 1D85 83 DUP4 1D86 01 ADD 1D87 35 CALLDATALOAD 1D88 80 DUP1 1D89 15 ISZERO 1D8A 15 ISZERO 1D8B 81 DUP2 1D8C 14 EQ 1D8D 61 PUSH2 0x1d94 1D90 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1D81 stack[-3] = stack[-1] // @1D87 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1d94, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1D91: // Incoming jump from 0x1D90, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @1D91 stack[-2] // @1D93 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D91 81 DUP2 1D92 82 DUP3 1D93 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D93 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1D94: // Incoming jump from 0x1D90, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1D95 stack[-1] // @1D96 stack[-2] // @1D99 stack[-5] // @1D9B stack[-3] // @1D9B stack[-6] // @1D9C stack[-4] // } 1D94 5B JUMPDEST 1D95 80 DUP1 1D96 91 SWAP2 1D97 50 POP 1D98 50 POP 1D99 92 SWAP3 1D9A 50 POP 1D9B 92 SWAP3 1D9C 90 SWAP1 1D9D 50 POP 1D9E 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1D99 stack[-5] = stack[-1] // @1D9B stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1D9F: // Incoming call from 0x02DB, returns to 0x02DC // Incoming call from 0x023F, returns to 0x0240 // Incoming call from 0x02B5, returns to 0x02B6 // Inputs[2] // { // @1DA5 stack[-1] // @1DA6 stack[-2] // } 1D9F 5B JUMPDEST 1DA0 60 PUSH1 0x00 1DA2 80 DUP1 1DA3 60 PUSH1 0x40 1DA5 83 DUP4 1DA6 85 DUP6 1DA7 03 SUB 1DA8 12 SLT 1DA9 15 ISZERO 1DAA 61 PUSH2 0x1db1 1DAD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DA0 stack[0] = 0x00 // @1DA2 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1db1, if !(stack[-2] - stack[-1] i< 0x40) label_1DAE: // Incoming jump from 0x1DAD, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DAE stack[-2] // @1DB0 memory[stack[-2]:stack[-2] + stack[-2]] // } 1DAE 81 DUP2 1DAF 82 DUP3 1DB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DB0 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1DB1: // Incoming jump from 0x1DAD, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1DB5 stack[-3] } 1DB1 5B JUMPDEST 1DB2 61 PUSH2 0x1dba 1DB5 83 DUP4 1DB6 61 PUSH2 0x1c2f 1DB9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DB2 stack[0] = 0x1dba // @1DB5 stack[1] = stack[-3] // } // Block ends with call to 0x1c2f, returns to 0x1DBA label_1DBA: // Incoming return from call to 0x1C2F at 0x1DB9 // Inputs[5] // { // @1DBB stack[-6] // @1DBB stack[-1] // @1DBE stack[-4] // @1DC2 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1DC3 stack[-5] // } 1DBA 5B JUMPDEST 1DBB 94 SWAP5 1DBC 60 PUSH1 0x20 1DBE 93 SWAP4 1DBF 90 SWAP1 1DC0 93 SWAP4 1DC1 01 ADD 1DC2 35 CALLDATALOAD 1DC3 93 SWAP4 1DC4 50 POP 1DC5 50 POP 1DC6 50 POP 1DC7 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1DBB stack[-6] = stack[-1] // @1DC3 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1DC8: // Incoming call from 0x03BC, returns to 0x03BD // Incoming call from 0x03CF, returns to 0x03D0 // Incoming call from 0x033A, returns to 0x033B // Incoming call from 0x028F, returns to 0x0290 // Incoming call from 0x021F, returns to 0x0220 // Incoming call from 0x0314, returns to 0x0315 // Incoming call from 0x0301, returns to 0x0302 // Inputs[2] // { // @1DCD stack[-1] // @1DCE stack[-2] // } 1DC8 5B JUMPDEST 1DC9 60 PUSH1 0x00 1DCB 60 PUSH1 0x20 1DCD 82 DUP3 1DCE 84 DUP5 1DCF 03 SUB 1DD0 12 SLT 1DD1 15 ISZERO 1DD2 61 PUSH2 0x1dd9 1DD5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DC9 stack[0] = 0x00 } // Block ends with conditional jump to 0x1dd9, if !(stack[-2] - stack[-1] i< 0x20) label_1DD6: // Incoming jump from 0x1DD5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1DD6 stack[-1] // @1DD8 memory[stack[-1]:stack[-1] + stack[-1]] // } 1DD6 80 DUP1 1DD7 81 DUP2 1DD8 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DD8 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1DD9: // Incoming jump from 0x1DD5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1DDB msg.data[stack[-2]:stack[-2] + 0x20] // @1DDB stack[-2] // @1DDC stack[-4] // @1DDD stack[-3] // } 1DD9 5B JUMPDEST 1DDA 50 POP 1DDB 35 CALLDATALOAD 1DDC 91 SWAP2 1DDD 90 SWAP1 1DDE 50 POP 1DDF 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DDC stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1DE0: // Incoming call from 0x03EA, returns to 0x03EB // Incoming call from 0x02A2, returns to 0x02A3 // Incoming call from 0x0373, returns to 0x0374 // Incoming call from 0x02C8, returns to 0x02C9 // Inputs[2] // { // @1DE6 stack[-1] // @1DE7 stack[-2] // } 1DE0 5B JUMPDEST 1DE1 60 PUSH1 0x00 1DE3 80 DUP1 1DE4 60 PUSH1 0x40 1DE6 83 DUP4 1DE7 85 DUP6 1DE8 03 SUB 1DE9 12 SLT 1DEA 15 ISZERO 1DEB 61 PUSH2 0x1df2 1DEE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DE1 stack[0] = 0x00 // @1DE3 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1df2, if !(stack[-2] - stack[-1] i< 0x40) label_1DEF: // Incoming jump from 0x1DEE, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DEF stack[-2] // @1DF1 memory[stack[-2]:stack[-2] + stack[-2]] // } 1DEF 81 DUP2 1DF0 82 DUP3 1DF1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DF1 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1DF2: // Incoming jump from 0x1DEE, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @1DF3 stack[-3] // @1DF4 msg.data[stack[-3]:stack[-3] + 0x20] // @1DF5 stack[-2] // } 1DF2 5B JUMPDEST 1DF3 82 DUP3 1DF4 35 CALLDATALOAD 1DF5 91 SWAP2 1DF6 50 POP 1DF7 61 PUSH2 0x1ca8 1DFA 60 PUSH1 0x20 1DFC 84 DUP5 1DFD 01 ADD 1DFE 61 PUSH2 0x1c2f 1E01 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DF5 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @1DF7 stack[0] = 0x1ca8 // @1DFD stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x1c2f, returns to 0x1CA8 label_1E02: // Incoming call from 0x0360, returns to 0x0361 // Inputs[2] // { // @1E08 stack[-1] // @1E09 stack[-2] // } 1E02 5B JUMPDEST 1E03 60 PUSH1 0x00 1E05 80 DUP1 1E06 60 PUSH1 0x40 1E08 83 DUP4 1E09 85 DUP6 1E0A 03 SUB 1E0B 12 SLT 1E0C 15 ISZERO 1E0D 61 PUSH2 0x1e14 1E10 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E03 stack[0] = 0x00 // @1E05 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e14, if !(stack[-2] - stack[-1] i< 0x40) label_1E11: // Incoming jump from 0x1E10, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1E11 stack[-2] // @1E13 memory[stack[-2]:stack[-2] + stack[-2]] // } 1E11 81 DUP2 1E12 82 DUP3 1E13 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E13 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1E14: // Incoming jump from 0x1E10, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @1E17 stack[-3] // @1E18 msg.data[stack[-3]:stack[-3] + 0x20] // @1E19 stack[-5] // @1E1F msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1E20 stack[-4] // } 1E14 5B JUMPDEST 1E15 50 POP 1E16 50 POP 1E17 80 DUP1 1E18 35 CALLDATALOAD 1E19 92 SWAP3 1E1A 60 PUSH1 0x20 1E1C 90 SWAP1 1E1D 91 SWAP2 1E1E 01 ADD 1E1F 35 CALLDATALOAD 1E20 91 SWAP2 1E21 50 POP 1E22 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1E19 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @1E20 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_1E23: // Incoming call from 0x01E1, returns to 0x01E2 // Inputs[2] // { // @1E28 stack[-1] // @1E29 stack[-2] // } 1E23 5B JUMPDEST 1E24 60 PUSH1 0x00 1E26 60 PUSH1 0x20 1E28 82 DUP3 1E29 84 DUP5 1E2A 03 SUB 1E2B 12 SLT 1E2C 15 ISZERO 1E2D 61 PUSH2 0x1e34 1E30 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E24 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e34, if !(stack[-2] - stack[-1] i< 0x20) label_1E31: // Incoming jump from 0x1E30, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E31 stack[-1] // @1E33 memory[stack[-1]:stack[-1] + stack[-1]] // } 1E31 80 DUP1 1E32 81 DUP2 1E33 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E33 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1E34: // Incoming jump from 0x1E30, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E35 stack[-2] // @1E36 msg.data[stack[-2]:stack[-2] + 0x20] // } 1E34 5B JUMPDEST 1E35 81 DUP2 1E36 35 CALLDATALOAD 1E37 61 PUSH2 0x0891 1E3A 81 DUP2 1E3B 61 PUSH2 0x299c 1E3E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E36 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1E37 stack[1] = 0x0891 // @1E3A stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x299c, returns to 0x0891 1E3F 5B JUMPDEST 1E40 60 PUSH1 0x00 1E42 60 PUSH1 0x20 1E44 82 DUP3 1E45 84 DUP5 1E46 03 SUB 1E47 12 SLT 1E48 15 ISZERO 1E49 61 PUSH2 0x1e50 1E4C 57 *JUMPI 1E4D 80 DUP1 1E4E 81 DUP2 1E4F FD *REVERT 1E50 5B JUMPDEST 1E51 81 DUP2 1E52 51 MLOAD 1E53 61 PUSH2 0x0891 1E56 81 DUP2 1E57 61 PUSH2 0x299c 1E5A 56 *JUMP label_1E5B: // Incoming call from 0x0327, returns to 0x0328 // Inputs[2] // { // @1E60 stack[-1] // @1E61 stack[-2] // } 1E5B 5B JUMPDEST 1E5C 60 PUSH1 0x00 1E5E 60 PUSH1 0x20 1E60 82 DUP3 1E61 84 DUP5 1E62 03 SUB 1E63 12 SLT 1E64 15 ISZERO 1E65 61 PUSH2 0x1e6c 1E68 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E5C stack[0] = 0x00 } // Block ends with conditional jump to 0x1e6c, if !(stack[-2] - stack[-1] i< 0x20) label_1E69: // Incoming jump from 0x1E68, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E69 stack[-1] // @1E6B memory[stack[-1]:stack[-1] + stack[-1]] // } 1E69 80 DUP1 1E6A 81 DUP2 1E6B FD *REVERT // Stack delta = +0 // Outputs[1] { @1E6B revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1E6C: // Incoming jump from 0x1E68, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E6D stack[-2] // @1E6E msg.data[stack[-2]:stack[-2] + 0x20] // } 1E6C 5B JUMPDEST 1E6D 81 DUP2 1E6E 35 CALLDATALOAD 1E6F 67 PUSH8 0xffffffffffffffff 1E78 81 DUP2 1E79 11 GT 1E7A 15 ISZERO 1E7B 61 PUSH2 0x1e82 1E7E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E6E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1e82, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1E7F: // Incoming jump from 0x1E7E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1E7F stack[-2] // @1E81 memory[stack[-2]:stack[-2] + stack[-2]] // } 1E7F 81 DUP2 1E80 82 DUP3 1E81 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E81 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1E82: // Incoming jump from 0x1E7E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1E86 stack[-4] // @1E87 stack[-1] // @1E88 stack[-3] // } 1E82 5B JUMPDEST 1E83 61 PUSH2 0x0c01 1E86 84 DUP5 1E87 82 DUP3 1E88 85 DUP6 1E89 01 ADD 1E8A 61 PUSH2 0x1c46 1E8D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E83 stack[0] = 0x0c01 // @1E86 stack[1] = stack[-4] // @1E89 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x1c46, returns to 0x0C01 label_1E8E: // Incoming call from 0x0254, returns to 0x0255 // Inputs[2] // { // @1E94 stack[-1] // @1E95 stack[-2] // } 1E8E 5B JUMPDEST 1E8F 60 PUSH1 0x00 1E91 80 DUP1 1E92 60 PUSH1 0x40 1E94 83 DUP4 1E95 85 DUP6 1E96 03 SUB 1E97 12 SLT 1E98 15 ISZERO 1E99 61 PUSH2 0x1ea0 1E9C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E8F stack[0] = 0x00 // @1E91 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ea0, if !(stack[-2] - stack[-1] i< 0x40) label_1E9D: // Incoming jump from 0x1E9C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1E9D stack[-2] // @1E9F memory[stack[-2]:stack[-2] + stack[-2]] // } 1E9D 81 DUP2 1E9E 82 DUP3 1E9F FD *REVERT // Stack delta = +0 // Outputs[1] { @1E9F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1EA0: // Incoming jump from 0x1E9C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @1EA1 stack[-3] // @1EA2 msg.data[stack[-3]:stack[-3] + 0x20] // @1EA3 stack[-2] // @1EA9 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 1EA0 5B JUMPDEST 1EA1 82 DUP3 1EA2 35 CALLDATALOAD 1EA3 91 SWAP2 1EA4 50 POP 1EA5 60 PUSH1 0x20 1EA7 83 DUP4 1EA8 01 ADD 1EA9 35 CALLDATALOAD 1EAA 67 PUSH8 0xffffffffffffffff 1EB3 81 DUP2 1EB4 11 GT 1EB5 15 ISZERO 1EB6 61 PUSH2 0x1ebd 1EB9 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1EA3 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @1EA9 stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1ebd, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) label_1EBA: // Incoming jump from 0x1EB9, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1EBA stack[-2] // @1EBC memory[stack[-2]:stack[-2] + stack[-2]] // } 1EBA 81 DUP2 1EBB 82 DUP3 1EBC FD *REVERT // Stack delta = +0 // Outputs[1] { @1EBC revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1EBD: // Incoming jump from 0x1EB9, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1EC1 stack[-5] // @1EC2 stack[-1] // @1EC3 stack[-4] // } 1EBD 5B JUMPDEST 1EBE 61 PUSH2 0x1ec9 1EC1 85 DUP6 1EC2 82 DUP3 1EC3 86 DUP7 1EC4 01 ADD 1EC5 61 PUSH2 0x1c46 1EC8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1EBE stack[0] = 0x1ec9 // @1EC1 stack[1] = stack[-5] // @1EC4 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1c46, returns to 0x1EC9 label_1EC9: // Incoming return from call to 0x1C46 at 0x1EC8 // Inputs[6] // { // @1ECA stack[-1] // @1ECA stack[-3] // @1ECD stack[-6] // @1ECF stack[-4] // @1ECF stack[-7] // @1ED0 stack[-5] // } 1EC9 5B JUMPDEST 1ECA 91 SWAP2 1ECB 50 POP 1ECC 50 POP 1ECD 92 SWAP3 1ECE 50 POP 1ECF 92 SWAP3 1ED0 90 SWAP1 1ED1 50 POP 1ED2 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1ECD stack[-6] = stack[-1] // @1ECF stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1ED3: // Incoming call from 0x1FA4, returns to 0x0891 // Inputs[3] // { // @1ED6 stack[-1] // @1ED7 memory[stack[-1]:stack[-1] + 0x20] // @1ED9 stack[-2] // } 1ED3 5B JUMPDEST 1ED4 60 PUSH1 0x00 1ED6 81 DUP2 1ED7 51 MLOAD 1ED8 80 DUP1 1ED9 84 DUP5 1EDA 52 MSTORE 1EDB 61 PUSH2 0x1eeb 1EDE 81 DUP2 1EDF 60 PUSH1 0x20 1EE1 86 DUP7 1EE2 01 ADD 1EE3 60 PUSH1 0x20 1EE5 86 DUP7 1EE6 01 ADD 1EE7 61 PUSH2 0x28c4 1EEA 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1ED4 stack[0] = 0x00 // @1ED7 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1EDA memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1EDB stack[2] = 0x1eeb // @1EDE stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1EE2 stack[4] = stack[-2] + 0x20 // @1EE6 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x28c4, returns to 0x1EEB label_1EEB: // Incoming return from call to 0x28C4 at 0x1EEA // Inputs[4] // { // @1EEE stack[-1] // @1EF3 stack[-4] // @1EF4 stack[-2] // @1EFA stack[-5] // } 1EEB 5B JUMPDEST 1EEC 60 PUSH1 0x1f 1EEE 01 ADD 1EEF 60 PUSH1 0x1f 1EF1 19 NOT 1EF2 16 AND 1EF3 92 SWAP3 1EF4 90 SWAP1 1EF5 92 SWAP3 1EF6 01 ADD 1EF7 60 PUSH1 0x20 1EF9 01 ADD 1EFA 92 SWAP3 1EFB 91 SWAP2 1EFC 50 POP 1EFD 50 POP 1EFE 56 *JUMP // Stack delta = -4 // Outputs[1] { @1EFA stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 1EFF 5B JUMPDEST 1F00 60 PUSH1 0x00 1F02 83 DUP4 1F03 51 MLOAD 1F04 61 PUSH2 0x1f11 1F07 81 DUP2 1F08 84 DUP5 1F09 60 PUSH1 0x20 1F0B 88 DUP9 1F0C 01 ADD 1F0D 61 PUSH2 0x28c4 1F10 56 *JUMP 1F11 5B JUMPDEST 1F12 83 DUP4 1F13 51 MLOAD 1F14 90 SWAP1 1F15 83 DUP4 1F16 01 ADD 1F17 90 SWAP1 1F18 61 PUSH2 0x1f25 1F1B 81 DUP2 1F1C 83 DUP4 1F1D 60 PUSH1 0x20 1F1F 88 DUP9 1F20 01 ADD 1F21 61 PUSH2 0x28c4 1F24 56 *JUMP 1F25 5B JUMPDEST 1F26 01 ADD 1F27 94 SWAP5 1F28 93 SWAP4 1F29 50 POP 1F2A 50 POP 1F2B 50 POP 1F2C 50 POP 1F2D 56 *JUMP label_1F2E: // Incoming call from 0x0231, returns to 0x01F4 // Inputs[3] // { // @1F37 stack[-2] // @1F38 stack[-1] // @1F40 stack[-3] // } 1F2E 5B JUMPDEST 1F2F 60 PUSH1 0x01 1F31 60 PUSH1 0x01 1F33 60 PUSH1 0xa0 1F35 1B SHL 1F36 03 SUB 1F37 91 SWAP2 1F38 90 SWAP1 1F39 91 SWAP2 1F3A 16 AND 1F3B 81 DUP2 1F3C 52 MSTORE 1F3D 60 PUSH1 0x20 1F3F 01 ADD 1F40 90 SWAP1 1F41 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1F3C memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1F40 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] 1F42 5B JUMPDEST 1F43 60 PUSH1 0x00 1F45 60 PUSH1 0x01 1F47 60 PUSH1 0x01 1F49 60 PUSH1 0xa0 1F4B 1B SHL 1F4C 03 SUB 1F4D 80 DUP1 1F4E 87 DUP8 1F4F 16 AND 1F50 83 DUP4 1F51 52 MSTORE 1F52 80 DUP1 1F53 86 DUP7 1F54 16 AND 1F55 60 PUSH1 0x20 1F57 84 DUP5 1F58 01 ADD 1F59 52 MSTORE 1F5A 50 POP 1F5B 83 DUP4 1F5C 60 PUSH1 0x40 1F5E 83 DUP4 1F5F 01 ADD 1F60 52 MSTORE 1F61 60 PUSH1 0x80 1F63 60 PUSH1 0x60 1F65 83 DUP4 1F66 01 ADD 1F67 52 MSTORE 1F68 61 PUSH2 0x1f74 1F6B 60 PUSH1 0x80 1F6D 83 DUP4 1F6E 01 ADD 1F6F 84 DUP5 1F70 61 PUSH2 0x1ed3 1F73 56 *JUMP 1F74 5B JUMPDEST 1F75 96 SWAP7 1F76 95 SWAP6 1F77 50 POP 1F78 50 POP 1F79 50 POP 1F7A 50 POP 1F7B 50 POP 1F7C 50 POP 1F7D 56 *JUMP label_1F7E: // Incoming call from 0x01F3, returns to 0x01F4 // Incoming call from 0x0996, returns to 0x0997 // Inputs[3] // { // @1F7F stack[-2] // @1F7F stack[-1] // @1F87 stack[-3] // } 1F7E 5B JUMPDEST 1F7F 90 SWAP1 1F80 15 ISZERO 1F81 15 ISZERO 1F82 81 DUP2 1F83 52 MSTORE 1F84 60 PUSH1 0x20 1F86 01 ADD 1F87 90 SWAP1 1F88 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1F83 memory[stack[-1]:stack[-1] + 0x20] = !!stack[-2] // @1F87 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_1F89: // Incoming call from 0x026E, returns to 0x01F4 // Inputs[3] // { // @1F8A stack[-2] // @1F8A stack[-1] // @1F90 stack[-3] // } 1F89 5B JUMPDEST 1F8A 90 SWAP1 1F8B 81 DUP2 1F8C 52 MSTORE 1F8D 60 PUSH1 0x20 1F8F 01 ADD 1F90 90 SWAP1 1F91 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1F8C memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1F90 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_1F92: // Incoming jump from 0x0211 // Inputs[2] // { // @1F97 stack[-1] // @1FA0 stack[-2] // } 1F92 5B JUMPDEST 1F93 60 PUSH1 0x00 1F95 60 PUSH1 0x20 1F97 82 DUP3 1F98 52 MSTORE 1F99 61 PUSH2 0x0891 1F9C 60 PUSH1 0x20 1F9E 83 DUP4 1F9F 01 ADD 1FA0 84 DUP5 1FA1 61 PUSH2 0x1ed3 1FA4 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1F93 stack[0] = 0x00 // @1F98 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1F99 stack[1] = 0x0891 // @1F9F stack[2] = stack[-1] + 0x20 // @1FA0 stack[3] = stack[-2] // } // Block ends with call to 0x1ed3, returns to 0x0891 label_1FA5: // Incoming call from 0x1398, returns to 0x04E9 // Inputs[2] // { // @1FA9 stack[-1] // @2000 stack[-2] // } 1FA5 5B JUMPDEST 1FA6 60 PUSH1 0x20 1FA8 80 DUP1 1FA9 82 DUP3 1FAA 52 MSTORE 1FAB 60 PUSH1 0x22 1FAD 90 SWAP1 1FAE 82 DUP3 1FAF 01 ADD 1FB0 52 MSTORE 1FB1 7F PUSH32 0x456e756d657261626c655365743a20696e646578206f7574206f6620626f756e 1FD2 60 PUSH1 0x40 1FD4 82 DUP3 1FD5 01 ADD 1FD6 52 MSTORE 1FD7 7F PUSH32 0x6473000000000000000000000000000000000000000000000000000000000000 1FF8 60 PUSH1 0x60 1FFA 82 DUP3 1FFB 01 ADD 1FFC 52 MSTORE 1FFD 60 PUSH1 0x80 1FFF 01 ADD 2000 90 SWAP1 2001 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1FAA memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1FB0 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x22 // @1FD6 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x456e756d657261626c655365743a20696e646578206f7574206f6620626f756e // @1FFC memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6473000000000000000000000000000000000000000000000000000000000000 // @2000 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2002: // Incoming call from 0x0D72, returns to 0x04E9 // Inputs[2] // { // @2006 stack[-1] // @205D stack[-2] // } 2002 5B JUMPDEST 2003 60 PUSH1 0x20 2005 80 DUP1 2006 82 DUP3 2007 52 MSTORE 2008 60 PUSH1 0x2f 200A 90 SWAP1 200B 82 DUP3 200C 01 ADD 200D 52 MSTORE 200E 7F PUSH32 0x416363657373436f6e74726f6c3a2073656e646572206d75737420626520616e 202F 60 PUSH1 0x40 2031 82 DUP3 2032 01 ADD 2033 52 MSTORE 2034 7F PUSH32 0x2061646d696e20746f206772616e740000000000000000000000000000000000 2055 60 PUSH1 0x60 2057 82 DUP3 2058 01 ADD 2059 52 MSTORE 205A 60 PUSH1 0x80 205C 01 ADD 205D 90 SWAP1 205E 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2007 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @200D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2f // @2033 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x416363657373436f6e74726f6c3a2073656e646572206d75737420626520616e // @2059 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x2061646d696e20746f206772616e740000000000000000000000000000000000 // @205D stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_205F: // Incoming call from 0x067A, returns to 0x04E9 // Inputs[2] // { // @2063 stack[-1] // @20BA stack[-2] // } 205F 5B JUMPDEST 2060 60 PUSH1 0x20 2062 80 DUP1 2063 82 DUP3 2064 52 MSTORE 2065 60 PUSH1 0x2b 2067 90 SWAP1 2068 82 DUP3 2069 01 ADD 206A 52 MSTORE 206B 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 208C 60 PUSH1 0x40 208E 82 DUP3 208F 01 ADD 2090 52 MSTORE 2091 7F PUSH32 0x74206f6620626f756e6473000000000000000000000000000000000000000000 20B2 60 PUSH1 0x60 20B4 82 DUP3 20B5 01 ADD 20B6 52 MSTORE 20B7 60 PUSH1 0x80 20B9 01 ADD 20BA 90 SWAP1 20BB 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2064 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @206A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2b // @2090 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 // @20B6 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x74206f6620626f756e6473000000000000000000000000000000000000000000 // @20BA stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 20BC 5B JUMPDEST 20BD 60 PUSH1 0x20 20BF 80 DUP1 20C0 82 DUP3 20C1 52 MSTORE 20C2 60 PUSH1 0x32 20C4 90 SWAP1 20C5 82 DUP3 20C6 01 ADD 20C7 52 MSTORE 20C8 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 20E9 60 PUSH1 0x40 20EB 82 DUP3 20EC 01 ADD 20ED 52 MSTORE 20EE 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 210F 60 PUSH1 0x60 2111 82 DUP3 2112 01 ADD 2113 52 MSTORE 2114 60 PUSH1 0x80 2116 01 ADD 2117 90 SWAP1 2118 56 *JUMP label_2119: // Incoming call from 0x0E15, returns to 0x04E9 // Inputs[2] // { // @211D stack[-1] // @214E stack[-2] // } 2119 5B JUMPDEST 211A 60 PUSH1 0x20 211C 80 DUP1 211D 82 DUP3 211E 52 MSTORE 211F 60 PUSH1 0x1c 2121 90 SWAP1 2122 82 DUP3 2123 01 ADD 2124 52 MSTORE 2125 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 2146 60 PUSH1 0x40 2148 82 DUP3 2149 01 ADD 214A 52 MSTORE 214B 60 PUSH1 0x60 214D 01 ADD 214E 90 SWAP1 214F 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @211E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2124 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1c // @214A memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @214E stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 2150 5B JUMPDEST 2151 60 PUSH1 0x20 2153 80 DUP1 2154 82 DUP3 2155 52 MSTORE 2156 60 PUSH1 0x24 2158 90 SWAP1 2159 82 DUP3 215A 01 ADD 215B 52 MSTORE 215C 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 217D 60 PUSH1 0x40 217F 82 DUP3 2180 01 ADD 2181 52 MSTORE 2182 7F PUSH32 0x7265737300000000000000000000000000000000000000000000000000000000 21A3 60 PUSH1 0x60 21A5 82 DUP3 21A6 01 ADD 21A7 52 MSTORE 21A8 60 PUSH1 0x80 21AA 01 ADD 21AB 90 SWAP1 21AC 56 *JUMP label_21AD: // Incoming call from 0x090D, returns to 0x04E9 // Inputs[2] // { // @21B1 stack[-1] // @21E2 stack[-2] // } 21AD 5B JUMPDEST 21AE 60 PUSH1 0x20 21B0 80 DUP1 21B1 82 DUP3 21B2 52 MSTORE 21B3 60 PUSH1 0x19 21B5 90 SWAP1 21B6 82 DUP3 21B7 01 ADD 21B8 52 MSTORE 21B9 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 21DA 60 PUSH1 0x40 21DC 82 DUP3 21DD 01 ADD 21DE 52 MSTORE 21DF 60 PUSH1 0x60 21E1 01 ADD 21E2 90 SWAP1 21E3 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @21B2 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @21B8 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x19 // @21DE memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @21E2 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_21E4: // Incoming call from 0x0BAA, returns to 0x04E9 // Inputs[2] // { // @21E8 stack[-1] // @222E stack[-2] // } 21E4 5B JUMPDEST 21E5 60 PUSH1 0x20 21E7 80 DUP1 21E8 82 DUP3 21E9 52 MSTORE 21EA 60 PUSH1 0x2c 21EC 90 SWAP1 21ED 82 DUP3 21EE 01 ADD 21EF 52 MSTORE 21F0 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 2211 60 PUSH1 0x40 2213 82 DUP3 2214 01 ADD 2215 52 MSTORE 2216 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 2223 60 PUSH1 0xa1 2225 1B SHL 2226 60 PUSH1 0x60 2228 82 DUP3 2229 01 ADD 222A 52 MSTORE 222B 60 PUSH1 0x80 222D 01 ADD 222E 90 SWAP1 222F 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @21E9 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @21EF memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2c // @2215 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @222A memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @222E stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2230: // Incoming call from 0x1049, returns to 0x04E9 // Inputs[2] // { // @2234 stack[-1] // @228B stack[-2] // } 2230 5B JUMPDEST 2231 60 PUSH1 0x20 2233 80 DUP1 2234 82 DUP3 2235 52 MSTORE 2236 60 PUSH1 0x30 2238 90 SWAP1 2239 82 DUP3 223A 01 ADD 223B 52 MSTORE 223C 7F PUSH32 0x416363657373436f6e74726f6c3a2073656e646572206d75737420626520616e 225D 60 PUSH1 0x40 225F 82 DUP3 2260 01 ADD 2261 52 MSTORE 2262 7F PUSH32 0x2061646d696e20746f207265766f6b6500000000000000000000000000000000 2283 60 PUSH1 0x60 2285 82 DUP3 2286 01 ADD 2287 52 MSTORE 2288 60 PUSH1 0x80 228A 01 ADD 228B 90 SWAP1 228C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2235 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @223B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x30 // @2261 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x416363657373436f6e74726f6c3a2073656e646572206d75737420626520616e // @2287 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x2061646d696e20746f207265766f6b6500000000000000000000000000000000 // @228B stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 228D 5B JUMPDEST 228E 60 PUSH1 0x20 2290 80 DUP1 2291 82 DUP3 2292 52 MSTORE 2293 60 PUSH1 0x38 2295 90 SWAP1 2296 82 DUP3 2297 01 ADD 2298 52 MSTORE 2299 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 22BA 60 PUSH1 0x40 22BC 82 DUP3 22BD 01 ADD 22BE 52 MSTORE 22BF 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 22E0 60 PUSH1 0x60 22E2 82 DUP3 22E3 01 ADD 22E4 52 MSTORE 22E5 60 PUSH1 0x80 22E7 01 ADD 22E8 90 SWAP1 22E9 56 *JUMP label_22EA: // Incoming call from 0x085C, returns to 0x04E9 // Inputs[2] // { // @22EE stack[-1] // @2345 stack[-2] // } 22EA 5B JUMPDEST 22EB 60 PUSH1 0x20 22ED 80 DUP1 22EE 82 DUP3 22EF 52 MSTORE 22F0 60 PUSH1 0x2a 22F2 90 SWAP1 22F3 82 DUP3 22F4 01 ADD 22F5 52 MSTORE 22F6 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 2317 60 PUSH1 0x40 2319 82 DUP3 231A 01 ADD 231B 52 MSTORE 231C 7F PUSH32 0x726f206164647265737300000000000000000000000000000000000000000000 233D 60 PUSH1 0x60 233F 82 DUP3 2340 01 ADD 2341 52 MSTORE 2342 60 PUSH1 0x80 2344 01 ADD 2345 90 SWAP1 2346 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @22EF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @22F5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2a // @231B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @2341 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x726f206164647265737300000000000000000000000000000000000000000000 // @2345 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2347: // Incoming call from 0x0834, returns to 0x04E9 // Inputs[2] // { // @234B stack[-1] // @23A2 stack[-2] // } 2347 5B JUMPDEST 2348 60 PUSH1 0x20 234A 80 DUP1 234B 82 DUP3 234C 52 MSTORE 234D 60 PUSH1 0x29 234F 90 SWAP1 2350 82 DUP3 2351 01 ADD 2352 52 MSTORE 2353 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 2374 60 PUSH1 0x40 2376 82 DUP3 2377 01 ADD 2378 52 MSTORE 2379 7F PUSH32 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 239A 60 PUSH1 0x60 239C 82 DUP3 239D 01 ADD 239E 52 MSTORE 239F 60 PUSH1 0x80 23A1 01 ADD 23A2 90 SWAP1 23A3 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @234C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2352 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x29 // @2378 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @239E memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 // @23A2 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_23A4: // Incoming call from 0x0B64, returns to 0x04E9 // Inputs[2] // { // @23A8 stack[-1] // @23FF stack[-2] // } 23A4 5B JUMPDEST 23A5 60 PUSH1 0x20 23A7 80 DUP1 23A8 82 DUP3 23A9 52 MSTORE 23AA 60 PUSH1 0x2e 23AC 90 SWAP1 23AD 82 DUP3 23AE 01 ADD 23AF 52 MSTORE 23B0 7F PUSH32 0x45524337323155524953746f726167653a2055524920736574206f66206e6f6e 23D1 60 PUSH1 0x40 23D3 82 DUP3 23D4 01 ADD 23D5 52 MSTORE 23D6 7F PUSH32 0x6578697374656e7420746f6b656e000000000000000000000000000000000000 23F7 60 PUSH1 0x60 23F9 82 DUP3 23FA 01 ADD 23FB 52 MSTORE 23FC 60 PUSH1 0x80 23FE 01 ADD 23FF 90 SWAP1 2400 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @23A9 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @23AF memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2e // @23D5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45524337323155524953746f726167653a2055524920736574206f66206e6f6e // @23FB memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6578697374656e7420746f6b656e000000000000000000000000000000000000 // @23FF stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2401: // Incoming call from 0x0DEF, returns to 0x04E9 // Inputs[2] // { // @2405 stack[-1] // @2434 stack[-2] // } 2401 5B JUMPDEST 2402 60 PUSH1 0x20 2404 80 DUP1 2405 82 DUP3 2406 52 MSTORE 2407 81 DUP2 2408 81 DUP2 2409 01 ADD 240A 52 MSTORE 240B 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 242C 60 PUSH1 0x40 242E 82 DUP3 242F 01 ADD 2430 52 MSTORE 2431 60 PUSH1 0x60 2433 01 ADD 2434 90 SWAP1 2435 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2406 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @240A memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @2430 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @2434 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2436: // Incoming call from 0x0F24, returns to 0x04E9 // Inputs[2] // { // @243A stack[-1] // @2491 stack[-2] // } 2436 5B JUMPDEST 2437 60 PUSH1 0x20 2439 80 DUP1 243A 82 DUP3 243B 52 MSTORE 243C 60 PUSH1 0x31 243E 90 SWAP1 243F 82 DUP3 2440 01 ADD 2441 52 MSTORE 2442 7F PUSH32 0x45524337323155524953746f726167653a2055524920717565727920666f7220 2463 60 PUSH1 0x40 2465 82 DUP3 2466 01 ADD 2467 52 MSTORE 2468 7F PUSH32 0x6e6f6e6578697374656e7420746f6b656e000000000000000000000000000000 2489 60 PUSH1 0x60 248B 82 DUP3 248C 01 ADD 248D 52 MSTORE 248E 60 PUSH1 0x80 2490 01 ADD 2491 90 SWAP1 2492 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @243B memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2441 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x31 // @2467 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45524337323155524953746f726167653a2055524920717565727920666f7220 // @248D memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6e6f6e6578697374656e7420746f6b656e000000000000000000000000000000 // @2491 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2493: // Incoming call from 0x04E8, returns to 0x04E9 // Inputs[2] // { // @2497 stack[-1] // @24DD stack[-2] // } 2493 5B JUMPDEST 2494 60 PUSH1 0x20 2496 80 DUP1 2497 82 DUP3 2498 52 MSTORE 2499 60 PUSH1 0x2c 249B 90 SWAP1 249C 82 DUP3 249D 01 ADD 249E 52 MSTORE 249F 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 24C0 60 PUSH1 0x40 24C2 82 DUP3 24C3 01 ADD 24C4 52 MSTORE 24C5 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 24D2 60 PUSH1 0xa1 24D4 1B SHL 24D5 60 PUSH1 0x60 24D7 82 DUP3 24D8 01 ADD 24D9 52 MSTORE 24DA 60 PUSH1 0x80 24DC 01 ADD 24DD 90 SWAP1 24DE 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2498 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @249E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2c // @24C4 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @24D9 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @24DD stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 24DF 5B JUMPDEST 24E0 60 PUSH1 0x20 24E2 80 DUP1 24E3 82 DUP3 24E4 52 MSTORE 24E5 60 PUSH1 0x29 24E7 90 SWAP1 24E8 82 DUP3 24E9 01 ADD 24EA 52 MSTORE 24EB 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 250C 60 PUSH1 0x40 250E 82 DUP3 250F 01 ADD 2510 52 MSTORE 2511 7F PUSH32 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 2532 60 PUSH1 0x60 2534 82 DUP3 2535 01 ADD 2536 52 MSTORE 2537 60 PUSH1 0x80 2539 01 ADD 253A 90 SWAP1 253B 56 *JUMP 253C 5B JUMPDEST 253D 60 PUSH1 0x20 253F 80 DUP1 2540 82 DUP3 2541 52 MSTORE 2542 60 PUSH1 0x2f 2544 90 SWAP1 2545 82 DUP3 2546 01 ADD 2547 52 MSTORE 2548 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 2569 60 PUSH1 0x40 256B 82 DUP3 256C 01 ADD 256D 52 MSTORE 256E 7F PUSH32 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 258F 60 PUSH1 0x60 2591 82 DUP3 2592 01 ADD 2593 52 MSTORE 2594 60 PUSH1 0x80 2596 01 ADD 2597 90 SWAP1 2598 56 *JUMP label_2599: // Incoming call from 0x05CE, returns to 0x04E9 // Inputs[2] // { // @259D stack[-1] // @25F4 stack[-2] // } 2599 5B JUMPDEST 259A 60 PUSH1 0x20 259C 80 DUP1 259D 82 DUP3 259E 52 MSTORE 259F 60 PUSH1 0x2e 25A1 90 SWAP1 25A2 82 DUP3 25A3 01 ADD 25A4 52 MSTORE 25A5 7F PUSH32 0x4552433732313a206d75737420686176652061646d696e20726f6c6520746f20 25C6 60 PUSH1 0x40 25C8 82 DUP3 25C9 01 ADD 25CA 52 MSTORE 25CB 7F PUSH32 0x73657420546f6b656e2055524973000000000000000000000000000000000000 25EC 60 PUSH1 0x60 25EE 82 DUP3 25EF 01 ADD 25F0 52 MSTORE 25F1 60 PUSH1 0x80 25F3 01 ADD 25F4 90 SWAP1 25F5 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @259E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25A4 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2e // @25CA memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206d75737420686176652061646d696e20726f6c6520746f20 // @25F0 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x73657420546f6b656e2055524973000000000000000000000000000000000000 // @25F4 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 25F6 5B JUMPDEST 25F7 60 PUSH1 0x20 25F9 80 DUP1 25FA 82 DUP3 25FB 52 MSTORE 25FC 60 PUSH1 0x21 25FE 90 SWAP1 25FF 82 DUP3 2600 01 ADD 2601 52 MSTORE 2602 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 2623 60 PUSH1 0x40 2625 82 DUP3 2626 01 ADD 2627 52 MSTORE 2628 7F PUSH32 0x7200000000000000000000000000000000000000000000000000000000000000 2649 60 PUSH1 0x60 264B 82 DUP3 264C 01 ADD 264D 52 MSTORE 264E 60 PUSH1 0x80 2650 01 ADD 2651 90 SWAP1 2652 56 *JUMP 2653 5B JUMPDEST 2654 60 PUSH1 0x20 2656 80 DUP1 2657 82 DUP3 2658 52 MSTORE 2659 60 PUSH1 0x31 265B 90 SWAP1 265C 82 DUP3 265D 01 ADD 265E 52 MSTORE 265F 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2680 60 PUSH1 0x40 2682 82 DUP3 2683 01 ADD 2684 52 MSTORE 2685 7F PUSH32 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 26A6 60 PUSH1 0x60 26A8 82 DUP3 26A9 01 ADD 26AA 52 MSTORE 26AB 60 PUSH1 0x80 26AD 01 ADD 26AE 90 SWAP1 26AF 56 *JUMP label_26B0: // Incoming call from 0x07EC, returns to 0x04E9 // Inputs[2] // { // @26B4 stack[-1] // @270B stack[-2] // } 26B0 5B JUMPDEST 26B1 60 PUSH1 0x20 26B3 80 DUP1 26B4 82 DUP3 26B5 52 MSTORE 26B6 60 PUSH1 0x2e 26B8 90 SWAP1 26B9 82 DUP3 26BA 01 ADD 26BB 52 MSTORE 26BC 7F PUSH32 0x4552433732313a206d75737420686176652061646d696e20726f6c6520746f20 26DD 60 PUSH1 0x40 26DF 82 DUP3 26E0 01 ADD 26E1 52 MSTORE 26E2 7F PUSH32 0x6368616e67652062617365557269000000000000000000000000000000000000 2703 60 PUSH1 0x60 2705 82 DUP3 2706 01 ADD 2707 52 MSTORE 2708 60 PUSH1 0x80 270A 01 ADD 270B 90 SWAP1 270C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @26B5 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @26BB memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2e // @26E1 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206d75737420686176652061646d696e20726f6c6520746f20 // @2707 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6368616e67652062617365557269000000000000000000000000000000000000 // @270B stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_270D: // Incoming call from 0x0790, returns to 0x04E9 // Inputs[2] // { // @2711 stack[-1] // @2768 stack[-2] // } 270D 5B JUMPDEST 270E 60 PUSH1 0x20 2710 80 DUP1 2711 82 DUP3 2712 52 MSTORE 2713 60 PUSH1 0x2c 2715 90 SWAP1 2716 82 DUP3 2717 01 ADD 2718 52 MSTORE 2719 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 273A 60 PUSH1 0x40 273C 82 DUP3 273D 01 ADD 273E 52 MSTORE 273F 7F PUSH32 0x7574206f6620626f756e64730000000000000000000000000000000000000000 2760 60 PUSH1 0x60 2762 82 DUP3 2763 01 ADD 2764 52 MSTORE 2765 60 PUSH1 0x80 2767 01 ADD 2768 90 SWAP1 2769 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2712 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2718 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2c // @273E memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @2764 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x7574206f6620626f756e64730000000000000000000000000000000000000000 // @2768 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 276A 5B JUMPDEST 276B 60 PUSH1 0x20 276D 80 DUP1 276E 82 DUP3 276F 52 MSTORE 2770 60 PUSH1 0x30 2772 90 SWAP1 2773 82 DUP3 2774 01 ADD 2775 52 MSTORE 2776 7F PUSH32 0x4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f77 2797 60 PUSH1 0x40 2799 82 DUP3 279A 01 ADD 279B 52 MSTORE 279C 7F PUSH32 0x6e6572206e6f7220617070726f76656400000000000000000000000000000000 27BD 60 PUSH1 0x60 27BF 82 DUP3 27C0 01 ADD 27C1 52 MSTORE 27C2 60 PUSH1 0x80 27C4 01 ADD 27C5 90 SWAP1 27C6 56 *JUMP label_27C7: // Incoming call from 0x0710, returns to 0x04E9 // Inputs[2] // { // @27CB stack[-1] // @2822 stack[-2] // } 27C7 5B JUMPDEST 27C8 60 PUSH1 0x20 27CA 80 DUP1 27CB 82 DUP3 27CC 52 MSTORE 27CD 60 PUSH1 0x25 27CF 90 SWAP1 27D0 82 DUP3 27D1 01 ADD 27D2 52 MSTORE 27D3 7F PUSH32 0x4552433732313a206d7573742068617665206d696e74657220726f6c6520746f 27F4 60 PUSH1 0x40 27F6 82 DUP3 27F7 01 ADD 27F8 52 MSTORE 27F9 7F PUSH32 0x206d696e74000000000000000000000000000000000000000000000000000000 281A 60 PUSH1 0x60 281C 82 DUP3 281D 01 ADD 281E 52 MSTORE 281F 60 PUSH1 0x80 2821 01 ADD 2822 90 SWAP1 2823 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @27CC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @27D2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x25 // @27F8 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206d7573742068617665206d696e74657220726f6c6520746f // @281E memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x206d696e74000000000000000000000000000000000000000000000000000000 // @2822 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2824: // Incoming call from 0x0DAA, returns to 0x04E9 // Inputs[2] // { // @2828 stack[-1] // @287F stack[-2] // } 2824 5B JUMPDEST 2825 60 PUSH1 0x20 2827 80 DUP1 2828 82 DUP3 2829 52 MSTORE 282A 60 PUSH1 0x2f 282C 90 SWAP1 282D 82 DUP3 282E 01 ADD 282F 52 MSTORE 2830 7F PUSH32 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 2851 60 PUSH1 0x40 2853 82 DUP3 2854 01 ADD 2855 52 MSTORE 2856 7F PUSH32 0x20726f6c657320666f722073656c660000000000000000000000000000000000 2877 60 PUSH1 0x60 2879 82 DUP3 287A 01 ADD 287B 52 MSTORE 287C 60 PUSH1 0x80 287E 01 ADD 287F 90 SWAP1 2880 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2829 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @282F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2f // @2855 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 // @287B memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x20726f6c657320666f722073656c660000000000000000000000000000000000 // @287F stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2881: // Incoming call from 0x12BF, returns to 0x12C0 // Incoming call from 0x0E4A, returns to 0x0E4B // Inputs[2] // { // @2884 stack[-2] // @2886 stack[-1] // } 2881 5B JUMPDEST 2882 60 PUSH1 0x00 2884 82 DUP3 2885 19 NOT 2886 82 DUP3 2887 11 GT 2888 15 ISZERO 2889 61 PUSH2 0x2894 288C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2882 stack[0] = 0x00 } // Block ends with conditional jump to 0x2894, if !(stack[-1] > ~stack[-2]) label_288D: // Incoming jump from 0x288C, if not !(stack[-1] > ~stack[-2]) 288D 61 PUSH2 0x2894 2890 61 PUSH2 0x295a 2893 56 *JUMP // Stack delta = +1 // Outputs[1] { @288D stack[0] = 0x2894 } // Block ends with unconditional jump to 0x295a label_2894: // Incoming jump from 0x288C, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2896 stack[-3] // @2896 stack[-2] // @2897 stack[-4] // } 2894 5B JUMPDEST 2895 50 POP 2896 01 ADD 2897 90 SWAP1 2898 56 *JUMP // Stack delta = -3 // Outputs[1] { @2897 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] 2899 5B JUMPDEST 289A 60 PUSH1 0x00 289C 82 DUP3 289D 61 PUSH2 0x28a8 28A0 57 *JUMPI 28A1 61 PUSH2 0x28a8 28A4 61 PUSH2 0x2970 28A7 56 *JUMP 28A8 5B JUMPDEST 28A9 50 POP 28AA 04 DIV 28AB 90 SWAP1 28AC 56 *JUMP label_28AD: // Incoming call from 0x123C, returns to 0x123D // Incoming call from 0x19B0, returns to 0x19B1 // Incoming call from 0x1250, returns to 0x1251 // Incoming call from 0x1918, returns to 0x1919 // Inputs[2] // { // @28B0 stack[-2] // @28B1 stack[-1] // } 28AD 5B JUMPDEST 28AE 60 PUSH1 0x00 28B0 82 DUP3 28B1 82 DUP3 28B2 10 LT 28B3 15 ISZERO 28B4 61 PUSH2 0x28bf 28B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28AE stack[0] = 0x00 } // Block ends with conditional jump to 0x28bf, if !(stack[-1] < stack[-2]) label_28B8: // Incoming jump from 0x28B7, if not !(stack[-1] < stack[-2]) 28B8 61 PUSH2 0x28bf 28BB 61 PUSH2 0x295a 28BE 56 *JUMP // Stack delta = +1 // Outputs[1] { @28B8 stack[0] = 0x28bf } // Block ends with unconditional jump to 0x295a label_28BF: // Incoming jump from 0x28B7, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @28C1 stack[-3] // @28C1 stack[-2] // @28C2 stack[-4] // } 28BF 5B JUMPDEST 28C0 50 POP 28C1 03 SUB 28C2 90 SWAP1 28C3 56 *JUMP // Stack delta = -3 // Outputs[1] { @28C2 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_28C4: // Incoming call from 0x1EEA, returns to 0x1EEB // Inputs[1] { @28C8 stack[-3] } 28C4 5B JUMPDEST 28C5 60 PUSH1 0x00 28C7 5B JUMPDEST 28C8 83 DUP4 28C9 81 DUP2 28CA 10 LT 28CB 15 ISZERO 28CC 61 PUSH2 0x28df 28CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28C5 stack[0] = 0x00 } // Block ends with conditional jump to 0x28df, if !(0x00 < stack[-3]) label_28D0: // Incoming jump from 0x28CF, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x28CF, if not !(0x00 < stack[-3]) // Inputs[4] // { // @28D0 stack[-2] // @28D1 stack[-1] // @28D3 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @28D4 stack[-3] // } 28D0 81 DUP2 28D1 81 DUP2 28D2 01 ADD 28D3 51 MLOAD 28D4 83 DUP4 28D5 82 DUP3 28D6 01 ADD 28D7 52 MSTORE 28D8 60 PUSH1 0x20 28DA 01 ADD 28DB 61 PUSH2 0x28c7 28DE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @28D7 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @28DA stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x28c7 label_28DF: // Incoming jump from 0x28CF, if !(stack[-1] < stack[-4]) // Incoming jump from 0x28CF, if !(0x00 < stack[-3]) // Inputs[2] // { // @28E0 stack[-4] // @28E1 stack[-1] // } 28DF 5B JUMPDEST 28E0 83 DUP4 28E1 81 DUP2 28E2 11 GT 28E3 15 ISZERO 28E4 61 PUSH2 0x09dc 28E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09dc, if !(stack[-1] > stack[-4]) label_28E8: // Incoming jump from 0x28E7, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @28EC stack[-4] // @28ED stack[-3] // @28EF stack[-5] // } 28E8 50 POP 28E9 50 POP 28EA 60 PUSH1 0x00 28EC 91 SWAP2 28ED 01 ADD 28EE 52 MSTORE 28EF 56 *JUMP // Stack delta = -5 // Outputs[1] { @28EE memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_28F0: // Incoming call from 0x1AF9, returns to 0x1AFA // Incoming call from 0x08CF, returns to 0x043F // Incoming call from 0x043E, returns to 0x043F // Incoming call from 0x1511, returns to 0x043F // Incoming call from 0x0F69, returns to 0x0F6A // Incoming call from 0x0F3D, returns to 0x0F3E // Incoming call from 0x046A, returns to 0x046B // Inputs[1] { @28F3 stack[-1] } 28F0 5B JUMPDEST 28F1 60 PUSH1 0x02 28F3 81 DUP2 28F4 04 DIV 28F5 60 PUSH1 0x01 28F7 82 DUP3 28F8 16 AND 28F9 80 DUP1 28FA 61 PUSH2 0x2904 28FD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28F4 stack[0] = stack[-1] / 0x02 // @28F8 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2904, if stack[-1] & 0x01 label_28FE: // Incoming jump from 0x28FD, if not stack[-1] & 0x01 // Inputs[2] // { // @2900 stack[-2] // @2909 stack[-1] // } 28FE 60 PUSH1 0x7f 2900 82 DUP3 2901 16 AND 2902 91 SWAP2 2903 50 POP 2904 5B JUMPDEST 2905 60 PUSH1 0x20 2907 82 DUP3 2908 10 LT 2909 81 DUP2 290A 14 EQ 290B 15 ISZERO 290C 61 PUSH2 0x2925 290F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2902 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2925, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2910: // Incoming jump from 0x290F, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x290F, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @2924 memory[0x00:0x24] } 2910 63 PUSH4 0x4e487b71 2915 60 PUSH1 0xe0 2917 1B SHL 2918 60 PUSH1 0x00 291A 52 MSTORE 291B 60 PUSH1 0x22 291D 60 PUSH1 0x04 291F 52 MSTORE 2920 60 PUSH1 0x24 2922 60 PUSH1 0x00 2924 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @291A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @291F memory[0x04:0x24] = 0x22 // @2924 revert(memory[0x00:0x24]); // } // Block terminates label_2925: // Incoming jump from 0x290F, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x290F, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @2927 stack[-2] // @2927 stack[-4] // @2928 stack[-3] // } 2925 5B JUMPDEST 2926 50 POP 2927 91 SWAP2 2928 90 SWAP1 2929 50 POP 292A 56 *JUMP // Stack delta = -3 // Outputs[1] { @2927 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] 292B 5B JUMPDEST 292C 60 PUSH1 0x00 292E 60 PUSH1 0x00 2930 19 NOT 2931 82 DUP3 2932 14 EQ 2933 15 ISZERO 2934 61 PUSH2 0x293f 2937 57 *JUMPI 2938 61 PUSH2 0x293f 293B 61 PUSH2 0x295a 293E 56 *JUMP 293F 5B JUMPDEST 2940 50 POP 2941 60 PUSH1 0x01 2943 01 ADD 2944 90 SWAP1 2945 56 *JUMP 2946 5B JUMPDEST 2947 60 PUSH1 0x00 2949 82 DUP3 294A 61 PUSH2 0x2955 294D 57 *JUMPI 294E 61 PUSH2 0x2955 2951 61 PUSH2 0x2970 2954 56 *JUMP 2955 5B JUMPDEST 2956 50 POP 2957 06 MOD 2958 90 SWAP1 2959 56 *JUMP label_295A: // Incoming jump from 0x2893 // Incoming jump from 0x28BE // Inputs[1] { @296F memory[0x00:0x24] } 295A 5B JUMPDEST 295B 63 PUSH4 0x4e487b71 2960 60 PUSH1 0xe0 2962 1B SHL 2963 60 PUSH1 0x00 2965 52 MSTORE 2966 60 PUSH1 0x11 2968 60 PUSH1 0x04 296A 52 MSTORE 296B 60 PUSH1 0x24 296D 60 PUSH1 0x00 296F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2965 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @296A memory[0x04:0x24] = 0x11 // @296F revert(memory[0x00:0x24]); // } // Block terminates 2970 5B JUMPDEST 2971 63 PUSH4 0x4e487b71 2976 60 PUSH1 0xe0 2978 1B SHL 2979 60 PUSH1 0x00 297B 52 MSTORE 297C 60 PUSH1 0x12 297E 60 PUSH1 0x04 2980 52 MSTORE 2981 60 PUSH1 0x24 2983 60 PUSH1 0x00 2985 FD *REVERT label_2986: // Incoming jump from 0x1BD9 // Incoming jump from 0x1BFD // Inputs[1] { @299B memory[0x00:0x24] } 2986 5B JUMPDEST 2987 63 PUSH4 0x4e487b71 298C 60 PUSH1 0xe0 298E 1B SHL 298F 60 PUSH1 0x00 2991 52 MSTORE 2992 60 PUSH1 0x41 2994 60 PUSH1 0x04 2996 52 MSTORE 2997 60 PUSH1 0x24 2999 60 PUSH1 0x00 299B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2991 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2996 memory[0x04:0x24] = 0x41 // @299B revert(memory[0x00:0x24]); // } // Block terminates label_299C: // Incoming call from 0x1E3E, returns to 0x0891 // Inputs[1] { @29A6 stack[-1] } 299C 5B JUMPDEST 299D 60 PUSH1 0x01 299F 60 PUSH1 0x01 29A1 60 PUSH1 0xe0 29A3 1B SHL 29A4 03 SUB 29A5 19 NOT 29A6 81 DUP2 29A7 16 AND 29A8 81 DUP2 29A9 14 EQ 29AA 61 PUSH2 0x0766 29AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0766, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_29AE: // Incoming jump from 0x29AD, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @29B1 memory[0x00:0x00] } 29AE 60 PUSH1 0x00 29B0 80 DUP1 29B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @29B1 revert(memory[0x00:0x00]); } // Block terminates 29B2 FE *ASSERT 29B3 A2 LOG2 29B4 64 PUSH5 0x6970667358 29BA 22 22 29BB 12 SLT 29BC 20 SHA3 29BD 5E 5E 29BE 51 MLOAD 29BF 37 CALLDATACOPY 29C0 3E RETURNDATACOPY 29C1 AC AC 29C2 F7 F7 29C3 E0 E0 29C4 54 SLOAD 29C5 59 MSIZE 29C6 E1 E1 29C7 5B JUMPDEST 29C8 80 DUP1 29C9 28 28 29CA B2 SWAP 29CB 6C PUSH13 0x097da27981b713a6fbe5637b54 29D9 43 NUMBER 29DA 4E 4E 29DB 5A GAS 29DC 14 EQ 29DD 64 PUSH5 0x736f6c6343 29E3 00 *STOP 29E4 08 ADDMOD 29E5 00 *STOP 29E6 00 *STOP 29E7 33 CALLER