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 0x01e5 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01e5, 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 0x6c0360eb 0026 11 GT 0027 61 PUSH2 0x010f 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x010f, if 0x6c0360eb > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x6c0360eb > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xc2b6b58c 0031 11 GT 0032 61 PUSH2 0x00a2 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a2, if 0xc2b6b58c > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xc2b6b58c > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe1016284 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xe1016284 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe1016284 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe1016284 0047 14 EQ 0048 61 PUSH2 0x0698 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0698, if 0xe1016284 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe1016284 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe9437537 0052 14 EQ 0053 61 PUSH2 0x06b5 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b5, if 0xe9437537 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe9437537 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe985e9c5 005D 14 EQ 005E 61 PUSH2 0x06d2 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d2, if 0xe985e9c5 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xfaeaa153 0068 14 EQ 0069 61 PUSH2 0x0700 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0700, if 0xfaeaa153 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xfaeaa153 == stack[-1] 006D 61 PUSH2 0x01e5 0070 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01e5 label_0071: // Incoming jump from 0x0040, if 0xe1016284 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xc2b6b58c 0078 14 EQ 0079 61 PUSH2 0x0639 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0639, if 0xc2b6b58c == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xc2b6b58c == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xc87b56dd 0083 14 EQ 0084 61 PUSH2 0x0641 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0641, if 0xc87b56dd == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xcc61697b 008E 14 EQ 008F 61 PUSH2 0x065e 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065e, if 0xcc61697b == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xcc61697b == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xd3716630 0099 14 EQ 009A 61 PUSH2 0x067b 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x067b, if 0xd3716630 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xd3716630 == stack[-1] 009E 61 PUSH2 0x01e5 00A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01e5 label_00A2: // Incoming jump from 0x0035, if 0xc2b6b58c > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0x983472c3 00A9 11 GT 00AA 61 PUSH2 0x00de 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00de, if 0x983472c3 > stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x983472c3 > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x983472c3 00B4 14 EQ 00B5 61 PUSH2 0x0537 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0537, if 0x983472c3 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x983472c3 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0xa22cb465 00BF 14 EQ 00C0 61 PUSH2 0x053f 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053f, if 0xa22cb465 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xb88d4fde 00CA 14 EQ 00CB 61 PUSH2 0x056d 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056d, if 0xb88d4fde == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xbe772d4c 00D5 14 EQ 00D6 61 PUSH2 0x0631 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0631, if 0xbe772d4c == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xbe772d4c == stack[-1] 00DA 61 PUSH2 0x01e5 00DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01e5 label_00DE: // Incoming jump from 0x00AD, if 0x983472c3 > stack[-1] // Inputs[1] { @00DF stack[-1] } 00DE 5B JUMPDEST 00DF 80 DUP1 00E0 63 PUSH4 0x6c0360eb 00E5 14 EQ 00E6 61 PUSH2 0x04f9 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f9, if 0x6c0360eb == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x6c0360eb == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x70a08231 00F0 14 EQ 00F1 61 PUSH2 0x0501 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0501, if 0x70a08231 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x70a08231 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x8291286c 00FB 14 EQ 00FC 61 PUSH2 0x0527 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0527, if 0x8291286c == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x8291286c == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0x95d89b41 0106 14 EQ 0107 61 PUSH2 0x052f 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052f, if 0x95d89b41 == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x95d89b41 == stack[-1] 010B 61 PUSH2 0x01e5 010E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01e5 label_010F: // Incoming jump from 0x002A, if 0x6c0360eb > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0110 stack[-1] } 010F 5B JUMPDEST 0110 80 DUP1 0111 63 PUSH4 0x2b6db055 0116 11 GT 0117 61 PUSH2 0x0187 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0187, if 0x2b6db055 > stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x2b6db055 > stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x4f6ccce7 0121 11 GT 0122 61 PUSH2 0x0156 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0156, if 0x4f6ccce7 > stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x4f6ccce7 012C 14 EQ 012D 61 PUSH2 0x04af 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04af, if 0x4f6ccce7 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x610be654 0137 14 EQ 0138 61 PUSH2 0x04cc 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cc, if 0x610be654 == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x610be654 == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x6352211e 0142 14 EQ 0143 61 PUSH2 0x04d4 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d4, if 0x6352211e == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x6352211e == stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x63b7e173 014D 14 EQ 014E 61 PUSH2 0x04f1 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f1, if 0x63b7e173 == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x63b7e173 == stack[-1] 0152 61 PUSH2 0x01e5 0155 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01e5 label_0156: // Incoming jump from 0x0125, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @0157 stack[-1] } 0156 5B JUMPDEST 0157 80 DUP1 0158 63 PUSH4 0x2b6db055 015D 14 EQ 015E 61 PUSH2 0x0376 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0376, if 0x2b6db055 == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x2b6db055 == stack[-1] // Inputs[1] { @0162 stack[-1] } 0162 80 DUP1 0163 63 PUSH4 0x2f745c59 0168 14 EQ 0169 61 PUSH2 0x0421 016C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0421, if 0x2f745c59 == stack[-1] label_016D: // Incoming jump from 0x016C, if not 0x2f745c59 == stack[-1] // Inputs[1] { @016D stack[-1] } 016D 80 DUP1 016E 63 PUSH4 0x42842e0e 0173 14 EQ 0174 61 PUSH2 0x044d 0177 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044d, if 0x42842e0e == stack[-1] label_0178: // Incoming jump from 0x0177, if not 0x42842e0e == stack[-1] // Inputs[1] { @0178 stack[-1] } 0178 80 DUP1 0179 63 PUSH4 0x4f1d4832 017E 14 EQ 017F 61 PUSH2 0x0483 0182 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0483, if 0x4f1d4832 == stack[-1] label_0183: // Incoming jump from 0x0182, if not 0x4f1d4832 == stack[-1] 0183 61 PUSH2 0x01e5 0186 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01e5 label_0187: // Incoming jump from 0x011A, if 0x2b6db055 > stack[-1] // Inputs[1] { @0188 stack[-1] } 0187 5B JUMPDEST 0188 80 DUP1 0189 63 PUSH4 0x095ea7b3 018E 11 GT 018F 61 PUSH2 0x01c3 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c3, if 0x095ea7b3 > stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x095ea7b3 0199 14 EQ 019A 61 PUSH2 0x02db 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02db, if 0x095ea7b3 == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @019E stack[-1] } 019E 80 DUP1 019F 63 PUSH4 0x16e978c5 01A4 14 EQ 01A5 61 PUSH2 0x0309 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0309, if 0x16e978c5 == stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x16e978c5 == stack[-1] // Inputs[1] { @01A9 stack[-1] } 01A9 80 DUP1 01AA 63 PUSH4 0x18160ddd 01AF 14 EQ 01B0 61 PUSH2 0x0338 01B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0338, if 0x18160ddd == stack[-1] label_01B4: // Incoming jump from 0x01B3, if not 0x18160ddd == stack[-1] // Inputs[1] { @01B4 stack[-1] } 01B4 80 DUP1 01B5 63 PUSH4 0x23b872dd 01BA 14 EQ 01BB 61 PUSH2 0x0340 01BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0340, if 0x23b872dd == stack[-1] label_01BF: // Incoming jump from 0x01BE, if not 0x23b872dd == stack[-1] 01BF 61 PUSH2 0x01e5 01C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01e5 label_01C3: // Incoming jump from 0x0192, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01C4 stack[-1] } 01C3 5B JUMPDEST 01C4 80 DUP1 01C5 63 PUSH4 0x01ffc9a7 01CA 14 EQ 01CB 61 PUSH2 0x01ea 01CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ea, if 0x01ffc9a7 == stack[-1] label_01CF: // Incoming jump from 0x01CE, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01CF stack[-1] } 01CF 80 DUP1 01D0 63 PUSH4 0x06fdde03 01D5 14 EQ 01D6 61 PUSH2 0x0225 01D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0225, if 0x06fdde03 == stack[-1] label_01DA: // Incoming jump from 0x01D9, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01DA stack[-1] } 01DA 80 DUP1 01DB 63 PUSH4 0x081812fc 01E0 14 EQ 01E1 61 PUSH2 0x02a2 01E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a2, if 0x081812fc == stack[-1] label_01E5: // Incoming jump from 0x0070 // Incoming jump from 0x0155 // Incoming jump from 0x00DD // Incoming jump from 0x01C2 // Incoming jump from 0x010E // Incoming jump from 0x0186 // Incoming jump from 0x00A1 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x01E4, if not 0x081812fc == stack[-1] // Inputs[1] { @01E9 memory[0x00:0x00] } 01E5 5B JUMPDEST 01E6 60 PUSH1 0x00 01E8 80 DUP1 01E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E9 revert(memory[0x00:0x00]); } // Block terminates label_01EA: // Incoming jump from 0x01CE, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01F1 msg.data.length } 01EA 5B JUMPDEST 01EB 61 PUSH2 0x0211 01EE 60 PUSH1 0x04 01F0 80 DUP1 01F1 36 CALLDATASIZE 01F2 03 SUB 01F3 60 PUSH1 0x20 01F5 81 DUP2 01F6 10 LT 01F7 15 ISZERO 01F8 61 PUSH2 0x0200 01FB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01EB stack[0] = 0x0211 // @01EE stack[1] = 0x04 // @01F2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0200, returns to 0x0211, if !(msg.data.length - 0x04 < 0x20) label_01FC: // Incoming jump from 0x01FB, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @01FF memory[0x00:0x00] } 01FC 60 PUSH1 0x00 01FE 80 DUP1 01FF FD *REVERT // Stack delta = +0 // Outputs[1] { @01FF revert(memory[0x00:0x00]); } // Block terminates label_0200: // Incoming call from 0x01FB, returns to 0x0211, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0202 msg.data[stack[-2]:stack[-2] + 0x20] // @0202 stack[-2] // } 0200 5B JUMPDEST 0201 50 POP 0202 35 CALLDATALOAD 0203 60 PUSH1 0x01 0205 60 PUSH1 0x01 0207 60 PUSH1 0xe0 0209 1B SHL 020A 03 SUB 020B 19 NOT 020C 16 AND 020D 61 PUSH2 0x0708 0210 56 *JUMP // Stack delta = -1 // Outputs[1] { @020C stack[-2] = ~((0x01 << 0xe0) - 0x01) & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0708 label_0211: // Incoming return from call to 0x0200 at 0x01FB // Incoming return from call to 0x0674 at 0x066F // Incoming return from call to 0x161A at 0x0640 // Incoming return from call to 0x06E8 at 0x06E3 // Inputs[4] // { // @0215 memory[0x40:0x60] // @0216 stack[-1] // @021B memory[0x40:0x60] // @0224 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0211 5B JUMPDEST 0212 60 PUSH1 0x40 0214 80 DUP1 0215 51 MLOAD 0216 91 SWAP2 0217 15 ISZERO 0218 15 ISZERO 0219 82 DUP3 021A 52 MSTORE 021B 51 MLOAD 021C 90 SWAP1 021D 81 DUP2 021E 90 SWAP1 021F 03 SUB 0220 60 PUSH1 0x20 0222 01 ADD 0223 90 SWAP1 0224 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @021A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0224 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0225: // Incoming jump from 0x01D9, if 0x06fdde03 == stack[-1] 0225 5B JUMPDEST 0226 61 PUSH2 0x022d 0229 61 PUSH2 0x0727 022C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0226 stack[0] = 0x022d } // Block ends with call to 0x0727, returns to 0x022D label_022D: // Incoming return from call to 0x12F6 at 0x0500 // Incoming return from call to 0x13F2 at 0x0536 // Incoming return from call to 0x0657 at 0x0652 // Incoming return from call to 0x0727 at 0x022C // Incoming return from call to 0x1453 at 0x053E // Incoming return from call to 0x06AE at 0x06A9 // Incoming return from call to 0x0691 at 0x068C // Inputs[4] // { // @0231 memory[0x40:0x60] // @0237 stack[-1] // @0238 memory[stack[-1]:stack[-1] + 0x20] // @023E memory[stack[-1]:stack[-1] + 0x20] // } 022D 5B JUMPDEST 022E 60 PUSH1 0x40 0230 80 DUP1 0231 51 MLOAD 0232 60 PUSH1 0x20 0234 80 DUP1 0235 82 DUP3 0236 52 MSTORE 0237 83 DUP4 0238 51 MLOAD 0239 81 DUP2 023A 83 DUP4 023B 01 ADD 023C 52 MSTORE 023D 83 DUP4 023E 51 MLOAD 023F 91 SWAP2 0240 92 SWAP3 0241 83 DUP4 0242 92 SWAP3 0243 90 SWAP1 0244 83 DUP4 0245 01 ADD 0246 91 SWAP2 0247 85 DUP6 0248 01 ADD 0249 90 SWAP1 024A 80 DUP1 024B 83 DUP4 024C 83 DUP4 024D 60 PUSH1 0x00 024F 5B JUMPDEST 0250 83 DUP4 0251 81 DUP2 0252 10 LT 0253 15 ISZERO 0254 61 PUSH2 0x0267 0257 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0236 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @023C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0240 stack[0] = memory[0x40:0x60] // @0242 stack[1] = memory[0x40:0x60] // @0246 stack[2] = memory[0x40:0x60] + 0x40 // @0249 stack[3] = stack[-1] + 0x20 // @0249 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @024A stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @024B stack[6] = memory[0x40:0x60] + 0x40 // @024C stack[7] = stack[-1] + 0x20 // @024D stack[8] = 0x00 // } // Block ends with conditional jump to 0x0267, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0258: // Incoming jump from 0x0257, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0257, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0258 stack[-2] // @0259 stack[-1] // @025B memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @025C stack[-3] // } 0258 81 DUP2 0259 81 DUP2 025A 01 ADD 025B 51 MLOAD 025C 83 DUP4 025D 82 DUP3 025E 01 ADD 025F 52 MSTORE 0260 60 PUSH1 0x20 0262 01 ADD 0263 61 PUSH2 0x024f 0266 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @025F memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0262 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x024f label_0267: // Incoming jump from 0x0257, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0257, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @026C stack[-5] // @026C stack[-6] // @026E stack[-7] // } 0267 5B JUMPDEST 0268 50 POP 0269 50 POP 026A 50 POP 026B 50 POP 026C 90 SWAP1 026D 50 POP 026E 90 SWAP1 026F 81 DUP2 0270 01 ADD 0271 90 SWAP1 0272 60 PUSH1 0x1f 0274 16 AND 0275 80 DUP1 0276 15 ISZERO 0277 61 PUSH2 0x0294 027A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0271 stack[-7] = stack[-5] + stack[-7] // @0274 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0294, if !(0x1f & stack[-5]) label_027B: // Incoming jump from 0x027A, if not !(0x1f & stack[-5]) // Inputs[6] // { // @027B stack[-1] // @027C stack[-2] // @027F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0296 stack[-5] // @029C memory[0x40:0x60] // @02A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 027B 80 DUP1 027C 82 DUP3 027D 03 SUB 027E 80 DUP1 027F 51 MLOAD 0280 60 PUSH1 0x01 0282 83 DUP4 0283 60 PUSH1 0x20 0285 03 SUB 0286 61 PUSH2 0x0100 0289 0A EXP 028A 03 SUB 028B 19 NOT 028C 16 AND 028D 81 DUP2 028E 52 MSTORE 028F 60 PUSH1 0x20 0291 01 ADD 0292 91 SWAP2 0293 50 POP 0294 5B JUMPDEST 0295 50 POP 0296 92 SWAP3 0297 50 POP 0298 50 POP 0299 50 POP 029A 60 PUSH1 0x40 029C 51 MLOAD 029D 80 DUP1 029E 91 SWAP2 029F 03 SUB 02A0 90 SWAP1 02A1 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @028E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @02A1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_02A2: // Incoming jump from 0x01E4, if 0x081812fc == stack[-1] // Inputs[1] { @02A9 msg.data.length } 02A2 5B JUMPDEST 02A3 61 PUSH2 0x02bf 02A6 60 PUSH1 0x04 02A8 80 DUP1 02A9 36 CALLDATASIZE 02AA 03 SUB 02AB 60 PUSH1 0x20 02AD 81 DUP2 02AE 10 LT 02AF 15 ISZERO 02B0 61 PUSH2 0x02b8 02B3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02A3 stack[0] = 0x02bf // @02A6 stack[1] = 0x04 // @02AA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02b8, returns to 0x02BF, if !(msg.data.length - 0x04 < 0x20) label_02B4: // Incoming jump from 0x02B3, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @02B7 memory[0x00:0x00] } 02B4 60 PUSH1 0x00 02B6 80 DUP1 02B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B7 revert(memory[0x00:0x00]); } // Block terminates label_02B8: // Incoming call from 0x02B3, returns to 0x02BF, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @02BA stack[-2] // @02BA msg.data[stack[-2]:stack[-2] + 0x20] // } 02B8 5B JUMPDEST 02B9 50 POP 02BA 35 CALLDATALOAD 02BB 61 PUSH2 0x07be 02BE 56 *JUMP // Stack delta = -1 // Outputs[1] { @02BA stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x07be label_02BF: // Incoming return from call to 0x02B8 at 0x02B3 // Incoming return from call to 0x160B at 0x0638 // Incoming return from call to 0x12E7 at 0x04F8 // Incoming return from call to 0x04EA at 0x04E5 // Inputs[4] // { // @02C3 memory[0x40:0x60] // @02CD stack[-1] // @02D1 memory[0x40:0x60] // @02DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 02BF 5B JUMPDEST 02C0 60 PUSH1 0x40 02C2 80 DUP1 02C3 51 MLOAD 02C4 60 PUSH1 0x01 02C6 60 PUSH1 0x01 02C8 60 PUSH1 0xa0 02CA 1B SHL 02CB 03 SUB 02CC 90 SWAP1 02CD 92 SWAP3 02CE 16 AND 02CF 82 DUP3 02D0 52 MSTORE 02D1 51 MLOAD 02D2 90 SWAP1 02D3 81 DUP2 02D4 90 SWAP1 02D5 03 SUB 02D6 60 PUSH1 0x20 02D8 01 ADD 02D9 90 SWAP1 02DA F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02DA return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_02DB: // Incoming jump from 0x019D, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02E2 msg.data.length } 02DB 5B JUMPDEST 02DC 61 PUSH2 0x0307 02DF 60 PUSH1 0x04 02E1 80 DUP1 02E2 36 CALLDATASIZE 02E3 03 SUB 02E4 60 PUSH1 0x40 02E6 81 DUP2 02E7 10 LT 02E8 15 ISZERO 02E9 61 PUSH2 0x02f1 02EC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02DC stack[0] = 0x0307 // @02DF stack[1] = 0x04 // @02E3 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02f1, returns to 0x0307, if !(msg.data.length - 0x04 < 0x40) label_02ED: // Incoming jump from 0x02EC, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @02F0 memory[0x00:0x00] } 02ED 60 PUSH1 0x00 02EF 80 DUP1 02F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F0 revert(memory[0x00:0x00]); } // Block terminates label_02F1: // Incoming call from 0x02EC, returns to 0x0307, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @02FB stack[-2] // @02FC msg.data[stack[-2]:stack[-2] + 0x20] // @0302 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 02F1 5B JUMPDEST 02F2 50 POP 02F3 60 PUSH1 0x01 02F5 60 PUSH1 0x01 02F7 60 PUSH1 0xa0 02F9 1B SHL 02FA 03 SUB 02FB 81 DUP2 02FC 35 CALLDATALOAD 02FD 16 AND 02FE 90 SWAP1 02FF 60 PUSH1 0x20 0301 01 ADD 0302 35 CALLDATALOAD 0303 61 PUSH2 0x0820 0306 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02FE stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0302 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0820 label_0307: // Incoming return from call to 0x02F1 at 0x02EC // Incoming return from call to 0x0555 at 0x0550 // Incoming return from call to 0x11EF at 0x04D3 0307 5B JUMPDEST 0308 00 *STOP // Stack delta = +0 // Outputs[1] { @0308 stop(); } // Block terminates label_0309: // Incoming jump from 0x01A8, if 0x16e978c5 == stack[-1] // Inputs[1] { @0310 msg.data.length } 0309 5B JUMPDEST 030A 61 PUSH2 0x0326 030D 60 PUSH1 0x04 030F 80 DUP1 0310 36 CALLDATASIZE 0311 03 SUB 0312 60 PUSH1 0x20 0314 81 DUP2 0315 10 LT 0316 15 ISZERO 0317 61 PUSH2 0x031f 031A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @030A stack[0] = 0x0326 // @030D stack[1] = 0x04 // @0311 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x031f, returns to 0x0326, if !(msg.data.length - 0x04 < 0x20) label_031B: // Incoming jump from 0x031A, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @031E memory[0x00:0x00] } 031B 60 PUSH1 0x00 031D 80 DUP1 031E FD *REVERT // Stack delta = +0 // Outputs[1] { @031E revert(memory[0x00:0x00]); } // Block terminates label_031F: // Incoming call from 0x031A, returns to 0x0326, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0321 msg.data[stack[-2]:stack[-2] + 0x20] // @0321 stack[-2] // } 031F 5B JUMPDEST 0320 50 POP 0321 35 CALLDATALOAD 0322 61 PUSH2 0x0948 0325 56 *JUMP // Stack delta = -1 // Outputs[1] { @0321 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0948 label_0326: // Incoming return from call to 0x031F at 0x031A // Incoming return from call to 0x095A at 0x033F // Incoming return from call to 0x06CB at 0x06C6 // Incoming return from call to 0x13EC at 0x052E // Incoming return from call to 0x04C5 at 0x04C0 // Incoming return from call to 0x1873 at 0x0707 // Inputs[4] // { // @032A memory[0x40:0x60] // @032B stack[-1] // @032E memory[0x40:0x60] // @0337 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0326 5B JUMPDEST 0327 60 PUSH1 0x40 0329 80 DUP1 032A 51 MLOAD 032B 91 SWAP2 032C 82 DUP3 032D 52 MSTORE 032E 51 MLOAD 032F 90 SWAP1 0330 81 DUP2 0331 90 SWAP1 0332 03 SUB 0333 60 PUSH1 0x20 0335 01 ADD 0336 90 SWAP1 0337 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @032D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0337 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0338: // Incoming jump from 0x01B3, if 0x18160ddd == stack[-1] 0338 5B JUMPDEST 0339 61 PUSH2 0x0326 033C 61 PUSH2 0x095a 033F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0339 stack[0] = 0x0326 } // Block ends with call to 0x095a, returns to 0x0326 label_0340: // Incoming jump from 0x01BE, if 0x23b872dd == stack[-1] // Inputs[1] { @0347 msg.data.length } 0340 5B JUMPDEST 0341 61 PUSH2 0x0307 0344 60 PUSH1 0x04 0346 80 DUP1 0347 36 CALLDATASIZE 0348 03 SUB 0349 60 PUSH1 0x60 034B 81 DUP2 034C 10 LT 034D 15 ISZERO 034E 61 PUSH2 0x0356 0351 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0341 stack[0] = 0x0307 // @0344 stack[1] = 0x04 // @0348 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0356, if !(msg.data.length - 0x04 < 0x60) label_0352: // Incoming jump from 0x0351, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0355 memory[0x00:0x00] } 0352 60 PUSH1 0x00 0354 80 DUP1 0355 FD *REVERT // Stack delta = +0 // Outputs[1] { @0355 revert(memory[0x00:0x00]); } // Block terminates label_0356: // Incoming jump from 0x0351, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0360 stack[-2] // @0361 msg.data[stack[-2]:stack[-2] + 0x20] // @0369 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0371 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 0356 5B JUMPDEST 0357 50 POP 0358 60 PUSH1 0x01 035A 60 PUSH1 0x01 035C 60 PUSH1 0xa0 035E 1B SHL 035F 03 SUB 0360 81 DUP2 0361 35 CALLDATALOAD 0362 81 DUP2 0363 16 AND 0364 91 SWAP2 0365 60 PUSH1 0x20 0367 81 DUP2 0368 01 ADD 0369 35 CALLDATALOAD 036A 90 SWAP1 036B 91 SWAP2 036C 16 AND 036D 90 SWAP1 036E 60 PUSH1 0x40 0370 01 ADD 0371 35 CALLDATALOAD 0372 61 PUSH2 0x0960 0375 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0364 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @036D stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0371 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0960 label_0376: // Incoming jump from 0x0161, if 0x2b6db055 == stack[-1] // Inputs[1] { @037D msg.data.length } 0376 5B JUMPDEST 0377 61 PUSH2 0x0307 037A 60 PUSH1 0x04 037C 80 DUP1 037D 36 CALLDATASIZE 037E 03 SUB 037F 60 PUSH1 0x40 0381 81 DUP2 0382 10 LT 0383 15 ISZERO 0384 61 PUSH2 0x038c 0387 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0377 stack[0] = 0x0307 // @037A stack[1] = 0x04 // @037E stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x038c, if !(msg.data.length - 0x04 < 0x40) label_0388: // Incoming jump from 0x0387, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @038B memory[0x00:0x00] } 0388 60 PUSH1 0x00 038A 80 DUP1 038B FD *REVERT // Stack delta = +0 // Outputs[1] { @038B revert(memory[0x00:0x00]); } // Block terminates label_038C: // Incoming jump from 0x0387, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @038D stack[-2] // @038E msg.data[stack[-2]:stack[-2] + 0x20] // @0390 stack[-1] // @039C msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 038C 5B JUMPDEST 038D 81 DUP2 038E 35 CALLDATALOAD 038F 91 SWAP2 0390 90 SWAP1 0391 81 DUP2 0392 01 ADD 0393 90 SWAP1 0394 60 PUSH1 0x40 0396 81 DUP2 0397 01 ADD 0398 60 PUSH1 0x20 039A 82 DUP3 039B 01 ADD 039C 35 CALLDATALOAD 039D 60 PUSH1 0x01 039F 60 PUSH1 0x20 03A1 1B SHL 03A2 81 DUP2 03A3 11 GT 03A4 15 ISZERO 03A5 61 PUSH2 0x03ad 03A8 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @038F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0393 stack[0] = stack[-2] // @0393 stack[-1] = stack[-2] + stack[-1] // @0397 stack[1] = stack[-2] + 0x40 // @039C stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x03ad, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) label_03A9: // Incoming jump from 0x03A8, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[1] { @03AC memory[0x00:0x00] } 03A9 60 PUSH1 0x00 03AB 80 DUP1 03AC FD *REVERT // Stack delta = +0 // Outputs[1] { @03AC revert(memory[0x00:0x00]); } // Block terminates label_03AD: // Incoming jump from 0x03A8, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @03AE stack[-3] // @03AF stack[-1] // @03B0 stack[-4] // } 03AD 5B JUMPDEST 03AE 82 DUP3 03AF 01 ADD 03B0 83 DUP4 03B1 60 PUSH1 0x20 03B3 82 DUP3 03B4 01 ADD 03B5 11 GT 03B6 15 ISZERO 03B7 61 PUSH2 0x03bf 03BA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03AF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x03bf, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_03BB: // Incoming jump from 0x03BA, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @03BE memory[0x00:0x00] } 03BB 60 PUSH1 0x00 03BD 80 DUP1 03BE FD *REVERT // Stack delta = +0 // Outputs[1] { @03BE revert(memory[0x00:0x00]); } // Block terminates label_03BF: // Incoming jump from 0x03BA, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @03C0 stack[-1] // @03C1 msg.data[stack[-1]:stack[-1] + 0x20] // @03C6 stack[-2] // @03C7 stack[-4] // } 03BF 5B JUMPDEST 03C0 80 DUP1 03C1 35 CALLDATALOAD 03C2 90 SWAP1 03C3 60 PUSH1 0x20 03C5 01 ADD 03C6 91 SWAP2 03C7 84 DUP5 03C8 60 PUSH1 0x01 03CA 83 DUP4 03CB 02 MUL 03CC 84 DUP5 03CD 01 ADD 03CE 11 GT 03CF 60 PUSH1 0x01 03D1 60 PUSH1 0x20 03D3 1B SHL 03D4 83 DUP4 03D5 11 GT 03D6 17 OR 03D7 15 ISZERO 03D8 61 PUSH2 0x03e0 03DB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @03C2 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @03C6 stack[0] = stack[-2] // @03C6 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x03e0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_03DC: // Incoming jump from 0x03DB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @03DF memory[0x00:0x00] } 03DC 60 PUSH1 0x00 03DE 80 DUP1 03DF FD *REVERT // Stack delta = +0 // Outputs[1] { @03DF revert(memory[0x00:0x00]); } // Block terminates label_03E0: // Incoming jump from 0x03DB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @03E1 stack[-1] // @03E1 stack[-3] // @03E2 stack[-2] // @03F3 memory[0x40:0x60] // @040A msg.data[stack[-3]:stack[-3] + stack[-2]] // @0415 stack[-5] // @041A stack[-4] // } 03E0 5B JUMPDEST 03E1 91 SWAP2 03E2 90 SWAP1 03E3 80 DUP1 03E4 80 DUP1 03E5 60 PUSH1 0x1f 03E7 01 ADD 03E8 60 PUSH1 0x20 03EA 80 DUP1 03EB 91 SWAP2 03EC 04 DIV 03ED 02 MUL 03EE 60 PUSH1 0x20 03F0 01 ADD 03F1 60 PUSH1 0x40 03F3 51 MLOAD 03F4 90 SWAP1 03F5 81 DUP2 03F6 01 ADD 03F7 60 PUSH1 0x40 03F9 52 MSTORE 03FA 80 DUP1 03FB 93 SWAP4 03FC 92 SWAP3 03FD 91 SWAP2 03FE 90 SWAP1 03FF 81 DUP2 0400 81 DUP2 0401 52 MSTORE 0402 60 PUSH1 0x20 0404 01 ADD 0405 83 DUP4 0406 83 DUP4 0407 80 DUP1 0408 82 DUP3 0409 84 DUP5 040A 37 CALLDATACOPY 040B 60 PUSH1 0x00 040D 92 SWAP3 040E 01 ADD 040F 91 SWAP2 0410 90 SWAP1 0411 91 SWAP2 0412 52 MSTORE 0413 50 POP 0414 92 SWAP3 0415 95 SWAP6 0416 50 POP 0417 61 PUSH2 0x09bc 041A 94 SWAP5 041B 50 POP 041C 50 POP 041D 50 POP 041E 50 POP 041F 50 POP 0420 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @03F9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0401 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @040A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0412 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0415 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09bc label_0421: // Incoming jump from 0x016C, if 0x2f745c59 == stack[-1] // Inputs[1] { @0428 msg.data.length } 0421 5B JUMPDEST 0422 61 PUSH2 0x0326 0425 60 PUSH1 0x04 0427 80 DUP1 0428 36 CALLDATASIZE 0429 03 SUB 042A 60 PUSH1 0x40 042C 81 DUP2 042D 10 LT 042E 15 ISZERO 042F 61 PUSH2 0x0437 0432 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0422 stack[0] = 0x0326 // @0425 stack[1] = 0x04 // @0429 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0437, if !(msg.data.length - 0x04 < 0x40) label_0433: // Incoming jump from 0x0432, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0436 memory[0x00:0x00] } 0433 60 PUSH1 0x00 0435 80 DUP1 0436 FD *REVERT // Stack delta = +0 // Outputs[1] { @0436 revert(memory[0x00:0x00]); } // Block terminates label_0437: // Incoming jump from 0x0432, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0441 stack[-2] // @0442 msg.data[stack[-2]:stack[-2] + 0x20] // @0448 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0437 5B JUMPDEST 0438 50 POP 0439 60 PUSH1 0x01 043B 60 PUSH1 0x01 043D 60 PUSH1 0xa0 043F 1B SHL 0440 03 SUB 0441 81 DUP2 0442 35 CALLDATALOAD 0443 16 AND 0444 90 SWAP1 0445 60 PUSH1 0x20 0447 01 ADD 0448 35 CALLDATALOAD 0449 61 PUSH2 0x0ae9 044C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0444 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0448 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0ae9 label_044D: // Incoming jump from 0x0177, if 0x42842e0e == stack[-1] // Inputs[1] { @0454 msg.data.length } 044D 5B JUMPDEST 044E 61 PUSH2 0x0307 0451 60 PUSH1 0x04 0453 80 DUP1 0454 36 CALLDATASIZE 0455 03 SUB 0456 60 PUSH1 0x60 0458 81 DUP2 0459 10 LT 045A 15 ISZERO 045B 61 PUSH2 0x0463 045E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @044E stack[0] = 0x0307 // @0451 stack[1] = 0x04 // @0455 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0463, if !(msg.data.length - 0x04 < 0x60) label_045F: // Incoming jump from 0x045E, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0462 memory[0x00:0x00] } 045F 60 PUSH1 0x00 0461 80 DUP1 0462 FD *REVERT // Stack delta = +0 // Outputs[1] { @0462 revert(memory[0x00:0x00]); } // Block terminates label_0463: // Incoming jump from 0x045E, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @046D stack[-2] // @046E msg.data[stack[-2]:stack[-2] + 0x20] // @0476 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @047E msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 0463 5B JUMPDEST 0464 50 POP 0465 60 PUSH1 0x01 0467 60 PUSH1 0x01 0469 60 PUSH1 0xa0 046B 1B SHL 046C 03 SUB 046D 81 DUP2 046E 35 CALLDATALOAD 046F 81 DUP2 0470 16 AND 0471 91 SWAP2 0472 60 PUSH1 0x20 0474 81 DUP2 0475 01 ADD 0476 35 CALLDATALOAD 0477 90 SWAP1 0478 91 SWAP2 0479 16 AND 047A 90 SWAP1 047B 60 PUSH1 0x40 047D 01 ADD 047E 35 CALLDATALOAD 047F 61 PUSH2 0x0b68 0482 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0471 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @047A stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @047E stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b68 label_0483: // Incoming jump from 0x0182, if 0x4f1d4832 == stack[-1] // Inputs[1] { @048A msg.data.length } 0483 5B JUMPDEST 0484 61 PUSH2 0x0307 0487 60 PUSH1 0x04 0489 80 DUP1 048A 36 CALLDATASIZE 048B 03 SUB 048C 60 PUSH1 0x40 048E 81 DUP2 048F 10 LT 0490 15 ISZERO 0491 61 PUSH2 0x0499 0494 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0484 stack[0] = 0x0307 // @0487 stack[1] = 0x04 // @048B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0499, if !(msg.data.length - 0x04 < 0x40) label_0495: // Incoming jump from 0x0494, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0498 memory[0x00:0x00] } 0495 60 PUSH1 0x00 0497 80 DUP1 0498 FD *REVERT // Stack delta = +0 // Outputs[1] { @0498 revert(memory[0x00:0x00]); } // Block terminates label_0499: // Incoming jump from 0x0494, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @04A3 stack[-2] // @04A4 msg.data[stack[-2]:stack[-2] + 0x20] // @04AA msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0499 5B JUMPDEST 049A 50 POP 049B 60 PUSH1 0x01 049D 60 PUSH1 0x01 049F 60 PUSH1 0xa0 04A1 1B SHL 04A2 03 SUB 04A3 81 DUP2 04A4 35 CALLDATALOAD 04A5 16 AND 04A6 90 SWAP1 04A7 60 PUSH1 0x20 04A9 01 ADD 04AA 35 CALLDATALOAD 04AB 61 PUSH2 0x0b83 04AE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @04A6 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @04AA stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b83 label_04AF: // Incoming jump from 0x0130, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @04B6 msg.data.length } 04AF 5B JUMPDEST 04B0 61 PUSH2 0x0326 04B3 60 PUSH1 0x04 04B5 80 DUP1 04B6 36 CALLDATASIZE 04B7 03 SUB 04B8 60 PUSH1 0x20 04BA 81 DUP2 04BB 10 LT 04BC 15 ISZERO 04BD 61 PUSH2 0x04c5 04C0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04B0 stack[0] = 0x0326 // @04B3 stack[1] = 0x04 // @04B7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04c5, returns to 0x0326, if !(msg.data.length - 0x04 < 0x20) label_04C1: // Incoming jump from 0x04C0, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04C4 memory[0x00:0x00] } 04C1 60 PUSH1 0x00 04C3 80 DUP1 04C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C4 revert(memory[0x00:0x00]); } // Block terminates label_04C5: // Incoming call from 0x04C0, returns to 0x0326, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04C7 msg.data[stack[-2]:stack[-2] + 0x20] // @04C7 stack[-2] // } 04C5 5B JUMPDEST 04C6 50 POP 04C7 35 CALLDATALOAD 04C8 61 PUSH2 0x1189 04CB 56 *JUMP // Stack delta = -1 // Outputs[1] { @04C7 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1189 label_04CC: // Incoming jump from 0x013B, if 0x610be654 == stack[-1] 04CC 5B JUMPDEST 04CD 61 PUSH2 0x0307 04D0 61 PUSH2 0x11ef 04D3 56 *JUMP // Stack delta = +1 // Outputs[1] { @04CD stack[0] = 0x0307 } // Block ends with call to 0x11ef, returns to 0x0307 label_04D4: // Incoming jump from 0x0146, if 0x6352211e == stack[-1] // Inputs[1] { @04DB msg.data.length } 04D4 5B JUMPDEST 04D5 61 PUSH2 0x02bf 04D8 60 PUSH1 0x04 04DA 80 DUP1 04DB 36 CALLDATASIZE 04DC 03 SUB 04DD 60 PUSH1 0x20 04DF 81 DUP2 04E0 10 LT 04E1 15 ISZERO 04E2 61 PUSH2 0x04ea 04E5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04D5 stack[0] = 0x02bf // @04D8 stack[1] = 0x04 // @04DC stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04ea, returns to 0x02BF, if !(msg.data.length - 0x04 < 0x20) label_04E6: // Incoming jump from 0x04E5, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04E9 memory[0x00:0x00] } 04E6 60 PUSH1 0x00 04E8 80 DUP1 04E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E9 revert(memory[0x00:0x00]); } // Block terminates label_04EA: // Incoming call from 0x04E5, returns to 0x02BF, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04EC stack[-2] // @04EC msg.data[stack[-2]:stack[-2] + 0x20] // } 04EA 5B JUMPDEST 04EB 50 POP 04EC 35 CALLDATALOAD 04ED 61 PUSH2 0x128d 04F0 56 *JUMP // Stack delta = -1 // Outputs[1] { @04EC stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x128d label_04F1: // Incoming jump from 0x0151, if 0x63b7e173 == stack[-1] 04F1 5B JUMPDEST 04F2 61 PUSH2 0x02bf 04F5 61 PUSH2 0x12e7 04F8 56 *JUMP // Stack delta = +1 // Outputs[1] { @04F2 stack[0] = 0x02bf } // Block ends with call to 0x12e7, returns to 0x02BF label_04F9: // Incoming jump from 0x00E9, if 0x6c0360eb == stack[-1] 04F9 5B JUMPDEST 04FA 61 PUSH2 0x022d 04FD 61 PUSH2 0x12f6 0500 56 *JUMP // Stack delta = +1 // Outputs[1] { @04FA stack[0] = 0x022d } // Block ends with call to 0x12f6, returns to 0x022D label_0501: // Incoming jump from 0x00F4, if 0x70a08231 == stack[-1] // Inputs[1] { @0508 msg.data.length } 0501 5B JUMPDEST 0502 61 PUSH2 0x0326 0505 60 PUSH1 0x04 0507 80 DUP1 0508 36 CALLDATASIZE 0509 03 SUB 050A 60 PUSH1 0x20 050C 81 DUP2 050D 10 LT 050E 15 ISZERO 050F 61 PUSH2 0x0517 0512 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0502 stack[0] = 0x0326 // @0505 stack[1] = 0x04 // @0509 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0517, if !(msg.data.length - 0x04 < 0x20) label_0513: // Incoming jump from 0x0512, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0516 memory[0x00:0x00] } 0513 60 PUSH1 0x00 0515 80 DUP1 0516 FD *REVERT // Stack delta = +0 // Outputs[1] { @0516 revert(memory[0x00:0x00]); } // Block terminates label_0517: // Incoming jump from 0x0512, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0519 stack[-2] // @0519 msg.data[stack[-2]:stack[-2] + 0x20] // } 0517 5B JUMPDEST 0518 50 POP 0519 35 CALLDATALOAD 051A 60 PUSH1 0x01 051C 60 PUSH1 0x01 051E 60 PUSH1 0xa0 0520 1B SHL 0521 03 SUB 0522 16 AND 0523 61 PUSH2 0x1384 0526 56 *JUMP // Stack delta = -1 // Outputs[1] { @0522 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1384 label_0527: // Incoming jump from 0x00FF, if 0x8291286c == stack[-1] 0527 5B JUMPDEST 0528 61 PUSH2 0x0326 052B 61 PUSH2 0x13ec 052E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0528 stack[0] = 0x0326 } // Block ends with call to 0x13ec, returns to 0x0326 label_052F: // Incoming jump from 0x010A, if 0x95d89b41 == stack[-1] 052F 5B JUMPDEST 0530 61 PUSH2 0x022d 0533 61 PUSH2 0x13f2 0536 56 *JUMP // Stack delta = +1 // Outputs[1] { @0530 stack[0] = 0x022d } // Block ends with call to 0x13f2, returns to 0x022D label_0537: // Incoming jump from 0x00B8, if 0x983472c3 == stack[-1] 0537 5B JUMPDEST 0538 61 PUSH2 0x022d 053B 61 PUSH2 0x1453 053E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0538 stack[0] = 0x022d } // Block ends with call to 0x1453, returns to 0x022D label_053F: // Incoming jump from 0x00C3, if 0xa22cb465 == stack[-1] // Inputs[1] { @0546 msg.data.length } 053F 5B JUMPDEST 0540 61 PUSH2 0x0307 0543 60 PUSH1 0x04 0545 80 DUP1 0546 36 CALLDATASIZE 0547 03 SUB 0548 60 PUSH1 0x40 054A 81 DUP2 054B 10 LT 054C 15 ISZERO 054D 61 PUSH2 0x0555 0550 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0540 stack[0] = 0x0307 // @0543 stack[1] = 0x04 // @0547 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0555, returns to 0x0307, if !(msg.data.length - 0x04 < 0x40) label_0551: // Incoming jump from 0x0550, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0554 memory[0x00:0x00] } 0551 60 PUSH1 0x00 0553 80 DUP1 0554 FD *REVERT // Stack delta = +0 // Outputs[1] { @0554 revert(memory[0x00:0x00]); } // Block terminates label_0555: // Incoming call from 0x0550, returns to 0x0307, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @055F stack[-2] // @0560 msg.data[stack[-2]:stack[-2] + 0x20] // @0566 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0555 5B JUMPDEST 0556 50 POP 0557 60 PUSH1 0x01 0559 60 PUSH1 0x01 055B 60 PUSH1 0xa0 055D 1B SHL 055E 03 SUB 055F 81 DUP2 0560 35 CALLDATALOAD 0561 16 AND 0562 90 SWAP1 0563 60 PUSH1 0x20 0565 01 ADD 0566 35 CALLDATALOAD 0567 15 ISZERO 0568 15 ISZERO 0569 61 PUSH2 0x14ae 056C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0562 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0568 stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x14ae label_056D: // Incoming jump from 0x00CE, if 0xb88d4fde == stack[-1] // Inputs[1] { @0574 msg.data.length } 056D 5B JUMPDEST 056E 61 PUSH2 0x0307 0571 60 PUSH1 0x04 0573 80 DUP1 0574 36 CALLDATASIZE 0575 03 SUB 0576 60 PUSH1 0x80 0578 81 DUP2 0579 10 LT 057A 15 ISZERO 057B 61 PUSH2 0x0583 057E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @056E stack[0] = 0x0307 // @0571 stack[1] = 0x04 // @0575 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0583, if !(msg.data.length - 0x04 < 0x80) label_057F: // Incoming jump from 0x057E, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0582 memory[0x00:0x00] } 057F 60 PUSH1 0x00 0581 80 DUP1 0582 FD *REVERT // Stack delta = +0 // Outputs[1] { @0582 revert(memory[0x00:0x00]); } // Block terminates label_0583: // Incoming jump from 0x057E, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @058C stack[-2] // @058D msg.data[stack[-2]:stack[-2] + 0x20] // @0595 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0599 stack[-1] // @059E msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @05AC msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0583 5B JUMPDEST 0584 60 PUSH1 0x01 0586 60 PUSH1 0x01 0588 60 PUSH1 0xa0 058A 1B SHL 058B 03 SUB 058C 82 DUP3 058D 35 CALLDATALOAD 058E 81 DUP2 058F 16 AND 0590 92 SWAP3 0591 60 PUSH1 0x20 0593 81 DUP2 0594 01 ADD 0595 35 CALLDATALOAD 0596 90 SWAP1 0597 91 SWAP2 0598 16 AND 0599 91 SWAP2 059A 60 PUSH1 0x40 059C 82 DUP3 059D 01 ADD 059E 35 CALLDATALOAD 059F 91 SWAP2 05A0 90 SWAP1 05A1 81 DUP2 05A2 01 ADD 05A3 90 SWAP1 05A4 60 PUSH1 0x80 05A6 81 DUP2 05A7 01 ADD 05A8 60 PUSH1 0x60 05AA 82 DUP3 05AB 01 ADD 05AC 35 CALLDATALOAD 05AD 60 PUSH1 0x01 05AF 60 PUSH1 0x20 05B1 1B SHL 05B2 81 DUP2 05B3 11 GT 05B4 15 ISZERO 05B5 61 PUSH2 0x05bd 05B8 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0590 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0599 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @059F stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @05A3 stack[1] = stack[-2] + stack[-1] // @05A3 stack[2] = stack[-2] // @05A7 stack[3] = stack[-2] + 0x80 // @05AC stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x05bd, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) label_05B9: // Incoming jump from 0x05B8, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[1] { @05BC memory[0x00:0x00] } 05B9 60 PUSH1 0x00 05BB 80 DUP1 05BC FD *REVERT // Stack delta = +0 // Outputs[1] { @05BC revert(memory[0x00:0x00]); } // Block terminates label_05BD: // Incoming jump from 0x05B8, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @05BE stack[-3] // @05BF stack[-1] // @05C0 stack[-4] // } 05BD 5B JUMPDEST 05BE 82 DUP3 05BF 01 ADD 05C0 83 DUP4 05C1 60 PUSH1 0x20 05C3 82 DUP3 05C4 01 ADD 05C5 11 GT 05C6 15 ISZERO 05C7 61 PUSH2 0x05cf 05CA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @05BF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x05cf, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_05CB: // Incoming jump from 0x05CA, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @05CE memory[0x00:0x00] } 05CB 60 PUSH1 0x00 05CD 80 DUP1 05CE FD *REVERT // Stack delta = +0 // Outputs[1] { @05CE revert(memory[0x00:0x00]); } // Block terminates label_05CF: // Incoming jump from 0x05CA, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @05D0 stack[-1] // @05D1 msg.data[stack[-1]:stack[-1] + 0x20] // @05D6 stack[-2] // @05D7 stack[-4] // } 05CF 5B JUMPDEST 05D0 80 DUP1 05D1 35 CALLDATALOAD 05D2 90 SWAP1 05D3 60 PUSH1 0x20 05D5 01 ADD 05D6 91 SWAP2 05D7 84 DUP5 05D8 60 PUSH1 0x01 05DA 83 DUP4 05DB 02 MUL 05DC 84 DUP5 05DD 01 ADD 05DE 11 GT 05DF 60 PUSH1 0x01 05E1 60 PUSH1 0x20 05E3 1B SHL 05E4 83 DUP4 05E5 11 GT 05E6 17 OR 05E7 15 ISZERO 05E8 61 PUSH2 0x05f0 05EB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @05D2 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @05D6 stack[0] = stack[-2] // @05D6 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x05f0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_05EC: // Incoming jump from 0x05EB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @05EF memory[0x00:0x00] } 05EC 60 PUSH1 0x00 05EE 80 DUP1 05EF FD *REVERT // Stack delta = +0 // Outputs[1] { @05EF revert(memory[0x00:0x00]); } // Block terminates label_05F0: // Incoming jump from 0x05EB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @05F1 stack[-1] // @05F1 stack[-3] // @05F2 stack[-2] // @0603 memory[0x40:0x60] // @061A msg.data[stack[-3]:stack[-3] + stack[-2]] // @0625 stack[-5] // @062A stack[-4] // } 05F0 5B JUMPDEST 05F1 91 SWAP2 05F2 90 SWAP1 05F3 80 DUP1 05F4 80 DUP1 05F5 60 PUSH1 0x1f 05F7 01 ADD 05F8 60 PUSH1 0x20 05FA 80 DUP1 05FB 91 SWAP2 05FC 04 DIV 05FD 02 MUL 05FE 60 PUSH1 0x20 0600 01 ADD 0601 60 PUSH1 0x40 0603 51 MLOAD 0604 90 SWAP1 0605 81 DUP2 0606 01 ADD 0607 60 PUSH1 0x40 0609 52 MSTORE 060A 80 DUP1 060B 93 SWAP4 060C 92 SWAP3 060D 91 SWAP2 060E 90 SWAP1 060F 81 DUP2 0610 81 DUP2 0611 52 MSTORE 0612 60 PUSH1 0x20 0614 01 ADD 0615 83 DUP4 0616 83 DUP4 0617 80 DUP1 0618 82 DUP3 0619 84 DUP5 061A 37 CALLDATACOPY 061B 60 PUSH1 0x00 061D 92 SWAP3 061E 01 ADD 061F 91 SWAP2 0620 90 SWAP1 0621 91 SWAP2 0622 52 MSTORE 0623 50 POP 0624 92 SWAP3 0625 95 SWAP6 0626 50 POP 0627 61 PUSH2 0x15b3 062A 94 SWAP5 062B 50 POP 062C 50 POP 062D 50 POP 062E 50 POP 062F 50 POP 0630 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0609 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0611 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @061A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0622 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0625 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x15b3 label_0631: // Incoming jump from 0x00D9, if 0xbe772d4c == stack[-1] 0631 5B JUMPDEST 0632 61 PUSH2 0x02bf 0635 61 PUSH2 0x160b 0638 56 *JUMP // Stack delta = +1 // Outputs[1] { @0632 stack[0] = 0x02bf } // Block ends with call to 0x160b, returns to 0x02BF label_0639: // Incoming jump from 0x007C, if 0xc2b6b58c == stack[-1] 0639 5B JUMPDEST 063A 61 PUSH2 0x0211 063D 61 PUSH2 0x161a 0640 56 *JUMP // Stack delta = +1 // Outputs[1] { @063A stack[0] = 0x0211 } // Block ends with call to 0x161a, returns to 0x0211 label_0641: // Incoming jump from 0x0087, if 0xc87b56dd == stack[-1] // Inputs[1] { @0648 msg.data.length } 0641 5B JUMPDEST 0642 61 PUSH2 0x022d 0645 60 PUSH1 0x04 0647 80 DUP1 0648 36 CALLDATASIZE 0649 03 SUB 064A 60 PUSH1 0x20 064C 81 DUP2 064D 10 LT 064E 15 ISZERO 064F 61 PUSH2 0x0657 0652 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0642 stack[0] = 0x022d // @0645 stack[1] = 0x04 // @0649 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0657, returns to 0x022D, if !(msg.data.length - 0x04 < 0x20) label_0653: // Incoming jump from 0x0652, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0656 memory[0x00:0x00] } 0653 60 PUSH1 0x00 0655 80 DUP1 0656 FD *REVERT // Stack delta = +0 // Outputs[1] { @0656 revert(memory[0x00:0x00]); } // Block terminates label_0657: // Incoming call from 0x0652, returns to 0x022D, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0659 stack[-2] // @0659 msg.data[stack[-2]:stack[-2] + 0x20] // } 0657 5B JUMPDEST 0658 50 POP 0659 35 CALLDATALOAD 065A 61 PUSH2 0x1623 065D 56 *JUMP // Stack delta = -1 // Outputs[1] { @0659 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1623 label_065E: // Incoming jump from 0x0092, if 0xcc61697b == stack[-1] // Inputs[1] { @0665 msg.data.length } 065E 5B JUMPDEST 065F 61 PUSH2 0x0211 0662 60 PUSH1 0x04 0664 80 DUP1 0665 36 CALLDATASIZE 0666 03 SUB 0667 60 PUSH1 0x20 0669 81 DUP2 066A 10 LT 066B 15 ISZERO 066C 61 PUSH2 0x0674 066F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @065F stack[0] = 0x0211 // @0662 stack[1] = 0x04 // @0666 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0674, returns to 0x0211, if !(msg.data.length - 0x04 < 0x20) label_0670: // Incoming jump from 0x066F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0673 memory[0x00:0x00] } 0670 60 PUSH1 0x00 0672 80 DUP1 0673 FD *REVERT // Stack delta = +0 // Outputs[1] { @0673 revert(memory[0x00:0x00]); } // Block terminates label_0674: // Incoming call from 0x066F, returns to 0x0211, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0676 stack[-2] // @0676 msg.data[stack[-2]:stack[-2] + 0x20] // } 0674 5B JUMPDEST 0675 50 POP 0676 35 CALLDATALOAD 0677 61 PUSH2 0x1708 067A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0676 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1708 label_067B: // Incoming jump from 0x009D, if 0xd3716630 == stack[-1] // Inputs[1] { @0682 msg.data.length } 067B 5B JUMPDEST 067C 61 PUSH2 0x022d 067F 60 PUSH1 0x04 0681 80 DUP1 0682 36 CALLDATASIZE 0683 03 SUB 0684 60 PUSH1 0x20 0686 81 DUP2 0687 10 LT 0688 15 ISZERO 0689 61 PUSH2 0x0691 068C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @067C stack[0] = 0x022d // @067F stack[1] = 0x04 // @0683 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0691, returns to 0x022D, if !(msg.data.length - 0x04 < 0x20) label_068D: // Incoming jump from 0x068C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0690 memory[0x00:0x00] } 068D 60 PUSH1 0x00 068F 80 DUP1 0690 FD *REVERT // Stack delta = +0 // Outputs[1] { @0690 revert(memory[0x00:0x00]); } // Block terminates label_0691: // Incoming call from 0x068C, returns to 0x022D, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0693 msg.data[stack[-2]:stack[-2] + 0x20] // @0693 stack[-2] // } 0691 5B JUMPDEST 0692 50 POP 0693 35 CALLDATALOAD 0694 61 PUSH2 0x171d 0697 56 *JUMP // Stack delta = -1 // Outputs[1] { @0693 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x171d label_0698: // Incoming jump from 0x004B, if 0xe1016284 == stack[-1] // Inputs[1] { @069F msg.data.length } 0698 5B JUMPDEST 0699 61 PUSH2 0x022d 069C 60 PUSH1 0x04 069E 80 DUP1 069F 36 CALLDATASIZE 06A0 03 SUB 06A1 60 PUSH1 0x20 06A3 81 DUP2 06A4 10 LT 06A5 15 ISZERO 06A6 61 PUSH2 0x06ae 06A9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0699 stack[0] = 0x022d // @069C stack[1] = 0x04 // @06A0 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06ae, returns to 0x022D, if !(msg.data.length - 0x04 < 0x20) label_06AA: // Incoming jump from 0x06A9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06AD memory[0x00:0x00] } 06AA 60 PUSH1 0x00 06AC 80 DUP1 06AD FD *REVERT // Stack delta = +0 // Outputs[1] { @06AD revert(memory[0x00:0x00]); } // Block terminates label_06AE: // Incoming call from 0x06A9, returns to 0x022D, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @06B0 msg.data[stack[-2]:stack[-2] + 0x20] // @06B0 stack[-2] // } 06AE 5B JUMPDEST 06AF 50 POP 06B0 35 CALLDATALOAD 06B1 61 PUSH2 0x17cb 06B4 56 *JUMP // Stack delta = -1 // Outputs[1] { @06B0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x17cb label_06B5: // Incoming jump from 0x0056, if 0xe9437537 == stack[-1] // Inputs[1] { @06BC msg.data.length } 06B5 5B JUMPDEST 06B6 61 PUSH2 0x0326 06B9 60 PUSH1 0x04 06BB 80 DUP1 06BC 36 CALLDATASIZE 06BD 03 SUB 06BE 60 PUSH1 0x20 06C0 81 DUP2 06C1 10 LT 06C2 15 ISZERO 06C3 61 PUSH2 0x06cb 06C6 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06B6 stack[0] = 0x0326 // @06B9 stack[1] = 0x04 // @06BD stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06cb, returns to 0x0326, if !(msg.data.length - 0x04 < 0x20) label_06C7: // Incoming jump from 0x06C6, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06CA memory[0x00:0x00] } 06C7 60 PUSH1 0x00 06C9 80 DUP1 06CA FD *REVERT // Stack delta = +0 // Outputs[1] { @06CA revert(memory[0x00:0x00]); } // Block terminates label_06CB: // Incoming call from 0x06C6, returns to 0x0326, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @06CD msg.data[stack[-2]:stack[-2] + 0x20] // @06CD stack[-2] // } 06CB 5B JUMPDEST 06CC 50 POP 06CD 35 CALLDATALOAD 06CE 61 PUSH2 0x1833 06D1 56 *JUMP // Stack delta = -1 // Outputs[1] { @06CD stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1833 label_06D2: // Incoming jump from 0x0061, if 0xe985e9c5 == stack[-1] // Inputs[1] { @06D9 msg.data.length } 06D2 5B JUMPDEST 06D3 61 PUSH2 0x0211 06D6 60 PUSH1 0x04 06D8 80 DUP1 06D9 36 CALLDATASIZE 06DA 03 SUB 06DB 60 PUSH1 0x40 06DD 81 DUP2 06DE 10 LT 06DF 15 ISZERO 06E0 61 PUSH2 0x06e8 06E3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06D3 stack[0] = 0x0211 // @06D6 stack[1] = 0x04 // @06DA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06e8, returns to 0x0211, if !(msg.data.length - 0x04 < 0x40) label_06E4: // Incoming jump from 0x06E3, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @06E7 memory[0x00:0x00] } 06E4 60 PUSH1 0x00 06E6 80 DUP1 06E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E7 revert(memory[0x00:0x00]); } // Block terminates label_06E8: // Incoming call from 0x06E3, returns to 0x0211, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @06F2 stack[-2] // @06F3 msg.data[stack[-2]:stack[-2] + 0x20] // @06FA msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 06E8 5B JUMPDEST 06E9 50 POP 06EA 60 PUSH1 0x01 06EC 60 PUSH1 0x01 06EE 60 PUSH1 0xa0 06F0 1B SHL 06F1 03 SUB 06F2 81 DUP2 06F3 35 CALLDATALOAD 06F4 81 DUP2 06F5 16 AND 06F6 91 SWAP2 06F7 60 PUSH1 0x20 06F9 01 ADD 06FA 35 CALLDATALOAD 06FB 16 AND 06FC 61 PUSH2 0x1845 06FF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06F6 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @06FB stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x1845 label_0700: // Incoming jump from 0x006C, if 0xfaeaa153 == stack[-1] 0700 5B JUMPDEST 0701 61 PUSH2 0x0326 0704 61 PUSH2 0x1873 0707 56 *JUMP // Stack delta = +1 // Outputs[1] { @0701 stack[0] = 0x0326 } // Block ends with call to 0x1873, returns to 0x0326 label_0708: // Incoming jump from 0x0210 // Inputs[4] // { // @0712 stack[-1] // @0720 memory[0x00:0x40] // @0721 storage[keccak256(memory[0x00:0x40])] // @0725 stack[-2] // } 0708 5B JUMPDEST 0709 60 PUSH1 0x01 070B 60 PUSH1 0x01 070D 60 PUSH1 0xe0 070F 1B SHL 0710 03 SUB 0711 19 NOT 0712 16 AND 0713 60 PUSH1 0x00 0715 90 SWAP1 0716 81 DUP2 0717 52 MSTORE 0718 60 PUSH1 0x20 071A 81 DUP2 071B 90 SWAP1 071C 52 MSTORE 071D 60 PUSH1 0x40 071F 90 SWAP1 0720 20 SHA3 0721 54 SLOAD 0722 60 PUSH1 0xff 0724 16 AND 0725 90 SWAP1 0726 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0717 memory[0x00:0x20] = ~((0x01 << 0xe0) - 0x01) & stack[-1] // @071C memory[0x20:0x40] = 0x00 // @0725 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0727: // Incoming call from 0x022C, returns to 0x022D // Inputs[2] // { // @072B storage[0x09] // @072F memory[0x40:0x60] // } 0727 5B JUMPDEST 0728 60 PUSH1 0x09 072A 80 DUP1 072B 54 SLOAD 072C 60 PUSH1 0x40 072E 80 DUP1 072F 51 MLOAD 0730 60 PUSH1 0x20 0732 60 PUSH1 0x1f 0734 60 PUSH1 0x02 0736 60 PUSH1 0x00 0738 19 NOT 0739 61 PUSH2 0x0100 073C 60 PUSH1 0x01 073E 88 DUP9 073F 16 AND 0740 15 ISZERO 0741 02 MUL 0742 01 ADD 0743 90 SWAP1 0744 95 SWAP6 0745 16 AND 0746 94 SWAP5 0747 90 SWAP1 0748 94 SWAP5 0749 04 DIV 074A 93 SWAP4 074B 84 DUP5 074C 01 ADD 074D 81 DUP2 074E 90 SWAP1 074F 04 DIV 0750 81 DUP2 0751 02 MUL 0752 82 DUP3 0753 01 ADD 0754 81 DUP2 0755 01 ADD 0756 90 SWAP1 0757 92 SWAP3 0758 52 MSTORE 0759 82 DUP3 075A 81 DUP2 075B 52 MSTORE 075C 60 PUSH1 0x60 075E 93 SWAP4 075F 90 SWAP1 0760 92 SWAP3 0761 90 SWAP1 0762 91 SWAP2 0763 83 DUP4 0764 01 ADD 0765 82 DUP3 0766 82 DUP3 0767 80 DUP1 0768 15 ISZERO 0769 61 PUSH2 0x07b3 076C 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0758 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @075B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // @075E stack[0] = 0x60 // @0760 stack[1] = memory[0x40:0x60] // @0761 stack[3] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0762 stack[2] = 0x09 // @0764 stack[4] = memory[0x40:0x60] + 0x20 // @0765 stack[5] = 0x09 // @0766 stack[6] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x07b3, if !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) label_076D: // Incoming jump from 0x076C, if not !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @076D stack[-1] } 076D 80 DUP1 076E 60 PUSH1 0x1f 0770 10 LT 0771 61 PUSH2 0x0788 0774 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0788, if 0x1f < stack[-1] label_0775: // Incoming jump from 0x0774, if not 0x1f < stack[-1] // Inputs[4] // { // @0779 stack[-2] // @077A storage[stack[-2]] // @077D stack[-3] // @077F stack[-1] // } 0775 61 PUSH2 0x0100 0778 80 DUP1 0779 83 DUP4 077A 54 SLOAD 077B 04 DIV 077C 02 MUL 077D 83 DUP4 077E 52 MSTORE 077F 91 SWAP2 0780 60 PUSH1 0x20 0782 01 ADD 0783 91 SWAP2 0784 61 PUSH2 0x07b3 0787 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @077E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0783 stack[-1] = stack[-1] // @0783 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07b3 label_0788: // Incoming jump from 0x0774, if 0x1f < stack[-1] // Incoming jump from 0x143F, if 0x1f < stack[-1] // Inputs[5] // { // @0789 stack[-3] // @078A stack[-1] // @078C stack[-2] // @0794 memory[0x00:0x20] // @0798 storage[keccak256(memory[0x00:0x20])] // } 0788 5B JUMPDEST 0789 82 DUP3 078A 01 ADD 078B 91 SWAP2 078C 90 SWAP1 078D 60 PUSH1 0x00 078F 52 MSTORE 0790 60 PUSH1 0x20 0792 60 PUSH1 0x00 0794 20 SHA3 0795 90 SWAP1 0796 5B JUMPDEST 0797 81 DUP2 0798 54 SLOAD 0799 81 DUP2 079A 52 MSTORE 079B 90 SWAP1 079C 60 PUSH1 0x01 079E 01 ADD 079F 90 SWAP1 07A0 60 PUSH1 0x20 07A2 01 ADD 07A3 80 DUP1 07A4 83 DUP4 07A5 11 GT 07A6 61 PUSH2 0x0796 07A9 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @078B stack[-3] = stack[-3] + stack[-1] // @078F memory[0x00:0x20] = stack[-2] // @079A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @079F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07A2 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0796, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07AA: // Incoming jump from 0x07A9, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x07A9, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @07AA stack[-3] // @07AB stack[-1] // } 07AA 82 DUP3 07AB 90 SWAP1 07AC 03 SUB 07AD 60 PUSH1 0x1f 07AF 16 AND 07B0 82 DUP3 07B1 01 ADD 07B2 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @07B2 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @07B2 stack[-1] = stack[-3] // } // Block continues label_07B3: // Incoming jump from 0x076C, if !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x1437, if !((storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0787 // Incoming jump from 0x1452 // Incoming jump from 0x07B2 // Inputs[3] // { // @07B9 stack[-6] // @07B9 stack[-7] // @07BC stack[-8] // } 07B3 5B JUMPDEST 07B4 50 POP 07B5 50 POP 07B6 50 POP 07B7 50 POP 07B8 50 POP 07B9 90 SWAP1 07BA 50 POP 07BB 5B JUMPDEST 07BC 90 SWAP1 07BD 56 *JUMP // Stack delta = -7 // Outputs[1] { @07BC stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_07BE: // Incoming jump from 0x02BE // Incoming call from 0x191A, returns to 0x191B // Inputs[1] { @07C4 stack[-1] } 07BE 5B JUMPDEST 07BF 60 PUSH1 0x00 07C1 61 PUSH2 0x07c9 07C4 82 DUP3 07C5 61 PUSH2 0x1879 07C8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07BF stack[0] = 0x00 // @07C1 stack[1] = 0x07c9 // @07C4 stack[2] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x07C9 label_07C9: // Incoming return from call to 0x1879 at 0x07C8 // Inputs[1] { @07CD stack[-1] } 07C9 5B JUMPDEST 07CA 61 PUSH2 0x0804 07CD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0804, if stack[-1] label_07CE: // Incoming jump from 0x07CD, if not stack[-1] // Inputs[3] // { // @07D0 memory[0x40:0x60] // @07FE memory[0x40:0x60] // @0803 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07CE 60 PUSH1 0x40 07D0 51 MLOAD 07D1 62 PUSH3 0x461bcd 07D5 60 PUSH1 0xe5 07D7 1B SHL 07D8 81 DUP2 07D9 52 MSTORE 07DA 60 PUSH1 0x04 07DC 01 ADD 07DD 80 DUP1 07DE 80 DUP1 07DF 60 PUSH1 0x20 07E1 01 ADD 07E2 82 DUP3 07E3 81 DUP2 07E4 03 SUB 07E5 82 DUP3 07E6 52 MSTORE 07E7 60 PUSH1 0x2c 07E9 81 DUP2 07EA 52 MSTORE 07EB 60 PUSH1 0x20 07ED 01 ADD 07EE 80 DUP1 07EF 61 PUSH2 0x2342 07F2 60 PUSH1 0x2c 07F4 91 SWAP2 07F5 39 CODECOPY 07F6 60 PUSH1 0x40 07F8 01 ADD 07F9 91 SWAP2 07FA 50 POP 07FB 50 POP 07FC 60 PUSH1 0x40 07FE 51 MLOAD 07FF 80 DUP1 0800 91 SWAP2 0801 03 SUB 0802 90 SWAP1 0803 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @07D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07E6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @07EA memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @07F5 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x2342:0x236e] // @0803 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0804: // Incoming jump from 0x07CD, if stack[-1] // Inputs[4] // { // @0808 stack[-2] // @0813 memory[0x00:0x40] // @0814 storage[keccak256(memory[0x00:0x40])] // @081E stack[-3] // } 0804 5B JUMPDEST 0805 50 POP 0806 60 PUSH1 0x00 0808 90 SWAP1 0809 81 DUP2 080A 52 MSTORE 080B 60 PUSH1 0x02 080D 60 PUSH1 0x20 080F 52 MSTORE 0810 60 PUSH1 0x40 0812 90 SWAP1 0813 20 SHA3 0814 54 SLOAD 0815 60 PUSH1 0x01 0817 60 PUSH1 0x01 0819 60 PUSH1 0xa0 081B 1B SHL 081C 03 SUB 081D 16 AND 081E 90 SWAP1 081F 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @080A memory[0x00:0x20] = stack[-2] // @080F memory[0x20:0x40] = 0x02 // @081E stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0820: // Incoming jump from 0x0306 // Inputs[1] { @0826 stack[-1] } 0820 5B JUMPDEST 0821 60 PUSH1 0x00 0823 61 PUSH2 0x082b 0826 82 DUP3 0827 61 PUSH2 0x128d 082A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0821 stack[0] = 0x00 // @0823 stack[1] = 0x082b // @0826 stack[2] = stack[-1] // } // Block ends with call to 0x128d, returns to 0x082B label_082B: // Incoming return from call to 0x128D at 0x082A // Inputs[3] // { // @082C stack[-1] // @082C stack[-2] // @0838 stack[-4] // } 082B 5B JUMPDEST 082C 90 SWAP1 082D 50 POP 082E 80 DUP1 082F 60 PUSH1 0x01 0831 60 PUSH1 0x01 0833 60 PUSH1 0xa0 0835 1B SHL 0836 03 SUB 0837 16 AND 0838 83 DUP4 0839 60 PUSH1 0x01 083B 60 PUSH1 0x01 083D 60 PUSH1 0xa0 083F 1B SHL 0840 03 SUB 0841 16 AND 0842 14 EQ 0843 15 ISZERO 0844 61 PUSH2 0x087e 0847 57 *JUMPI // Stack delta = -1 // Outputs[1] { @082C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x087e, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0848: // Incoming jump from 0x0847, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @084A memory[0x40:0x60] // @0878 memory[0x40:0x60] // @087D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0848 60 PUSH1 0x40 084A 51 MLOAD 084B 62 PUSH3 0x461bcd 084F 60 PUSH1 0xe5 0851 1B SHL 0852 81 DUP2 0853 52 MSTORE 0854 60 PUSH1 0x04 0856 01 ADD 0857 80 DUP1 0858 80 DUP1 0859 60 PUSH1 0x20 085B 01 ADD 085C 82 DUP3 085D 81 DUP2 085E 03 SUB 085F 82 DUP3 0860 52 MSTORE 0861 60 PUSH1 0x21 0863 81 DUP2 0864 52 MSTORE 0865 60 PUSH1 0x20 0867 01 ADD 0868 80 DUP1 0869 61 PUSH2 0x23f2 086C 60 PUSH1 0x21 086E 91 SWAP2 086F 39 CODECOPY 0870 60 PUSH1 0x40 0872 01 ADD 0873 91 SWAP2 0874 50 POP 0875 50 POP 0876 60 PUSH1 0x40 0878 51 MLOAD 0879 80 DUP1 087A 91 SWAP2 087B 03 SUB 087C 90 SWAP1 087D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0853 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0860 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0864 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @086F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x23f2:0x2413] // @087D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_087E: // Incoming jump from 0x0847, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @087F stack[-1] } 087E 5B JUMPDEST 087F 80 DUP1 0880 60 PUSH1 0x01 0882 60 PUSH1 0x01 0884 60 PUSH1 0xa0 0886 1B SHL 0887 03 SUB 0888 16 AND 0889 61 PUSH2 0x0890 088C 61 PUSH2 0x1896 088F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0888 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0889 stack[1] = 0x0890 // } // Block ends with call to 0x1896, returns to 0x0890 label_0890: // Incoming return from call to 0x1896 at 0x088F // Inputs[2] // { // @0899 stack[-1] // @089A stack[-2] // } 0890 5B JUMPDEST 0891 60 PUSH1 0x01 0893 60 PUSH1 0x01 0895 60 PUSH1 0xa0 0897 1B SHL 0898 03 SUB 0899 16 AND 089A 14 EQ 089B 80 DUP1 089C 61 PUSH2 0x08b1 089F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @089A stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x08b1, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_08A0: // Incoming jump from 0x089F, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @08A4 stack[-2] } 08A0 50 POP 08A1 61 PUSH2 0x08b1 08A4 81 DUP2 08A5 61 PUSH2 0x08ac 08A8 61 PUSH2 0x1896 08AB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08A1 stack[-1] = 0x08b1 // @08A4 stack[0] = stack[-2] // @08A5 stack[1] = 0x08ac // } // Block ends with call to 0x1896, returns to 0x08AC label_08AC: // Incoming return from call to 0x1896 at 0x08AB 08AC 5B JUMPDEST 08AD 61 PUSH2 0x1845 08B0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1845 label_08B1: // Incoming jump from 0x089F, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Incoming return from call to 0x08AC at 0x08AB // Inputs[1] { @08B5 stack[-1] } 08B1 5B JUMPDEST 08B2 61 PUSH2 0x08ec 08B5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08ec, if stack[-1] label_08B6: // Incoming jump from 0x08B5, if not stack[-1] // Inputs[3] // { // @08B8 memory[0x40:0x60] // @08E6 memory[0x40:0x60] // @08EB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08B6 60 PUSH1 0x40 08B8 51 MLOAD 08B9 62 PUSH3 0x461bcd 08BD 60 PUSH1 0xe5 08BF 1B SHL 08C0 81 DUP2 08C1 52 MSTORE 08C2 60 PUSH1 0x04 08C4 01 ADD 08C5 80 DUP1 08C6 80 DUP1 08C7 60 PUSH1 0x20 08C9 01 ADD 08CA 82 DUP3 08CB 81 DUP2 08CC 03 SUB 08CD 82 DUP3 08CE 52 MSTORE 08CF 60 PUSH1 0x38 08D1 81 DUP2 08D2 52 MSTORE 08D3 60 PUSH1 0x20 08D5 01 ADD 08D6 80 DUP1 08D7 61 PUSH2 0x22b7 08DA 60 PUSH1 0x38 08DC 91 SWAP2 08DD 39 CODECOPY 08DE 60 PUSH1 0x40 08E0 01 ADD 08E1 91 SWAP2 08E2 50 POP 08E3 50 POP 08E4 60 PUSH1 0x40 08E6 51 MLOAD 08E7 80 DUP1 08E8 91 SWAP2 08E9 03 SUB 08EA 90 SWAP1 08EB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @08C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08CE memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @08D2 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x38 // @08DD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x38] = code[0x22b7:0x22ef] // @08EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08EC: // Incoming jump from 0x08B5, if stack[-1] // Inputs[8] // { // @08EF stack[-2] // @08FB memory[0x00:0x40] // @08FD storage[keccak256(memory[0x00:0x40])] // @0910 stack[-3] // @091A memory[0x40:0x60] // @091E stack[-1] // @0943 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0947 stack[-4] // } 08EC 5B JUMPDEST 08ED 60 PUSH1 0x00 08EF 82 DUP3 08F0 81 DUP2 08F1 52 MSTORE 08F2 60 PUSH1 0x02 08F4 60 PUSH1 0x20 08F6 52 MSTORE 08F7 60 PUSH1 0x40 08F9 80 DUP1 08FA 82 DUP3 08FB 20 SHA3 08FC 80 DUP1 08FD 54 SLOAD 08FE 60 PUSH1 0x01 0900 60 PUSH1 0x01 0902 60 PUSH1 0xa0 0904 1B SHL 0905 03 SUB 0906 19 NOT 0907 16 AND 0908 60 PUSH1 0x01 090A 60 PUSH1 0x01 090C 60 PUSH1 0xa0 090E 1B SHL 090F 03 SUB 0910 87 DUP8 0911 81 DUP2 0912 16 AND 0913 91 SWAP2 0914 82 DUP3 0915 17 OR 0916 90 SWAP1 0917 92 SWAP3 0918 55 SSTORE 0919 91 SWAP2 091A 51 MLOAD 091B 85 DUP6 091C 93 SWAP4 091D 91 SWAP2 091E 85 DUP6 091F 16 AND 0920 91 SWAP2 0921 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0942 91 SWAP2 0943 A4 LOG4 0944 50 POP 0945 50 POP 0946 50 POP 0947 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @08F1 memory[0x00:0x20] = stack[-2] // @08F6 memory[0x20:0x40] = 0x02 // @0918 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0943 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_0948: // Incoming jump from 0x0325 // Inputs[4] // { // @0950 stack[-1] // @0956 memory[0x00:0x40] // @0957 storage[keccak256(memory[0x00:0x40])] // @0958 stack[-2] // } 0948 5B JUMPDEST 0949 60 PUSH1 0x15 094B 60 PUSH1 0x20 094D 52 MSTORE 094E 60 PUSH1 0x00 0950 90 SWAP1 0951 81 DUP2 0952 52 MSTORE 0953 60 PUSH1 0x40 0955 90 SWAP1 0956 20 SHA3 0957 54 SLOAD 0958 81 DUP2 0959 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @094D memory[0x20:0x40] = 0x15 // @0952 memory[0x00:0x20] = stack[-1] // @0957 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_095A: // Incoming call from 0x1192, returns to 0x1193 // Incoming call from 0x033F, returns to 0x0326 // Inputs[2] // { // @095D storage[0x07] // @095E stack[-1] // } 095A 5B JUMPDEST 095B 60 PUSH1 0x07 095D 54 SLOAD 095E 90 SWAP1 095F 56 *JUMP // Stack delta = +0 // Outputs[1] { @095E stack[-1] = storage[0x07] } // Block ends with unconditional jump to stack[-1] label_0960: // Incoming jump from 0x0375 0960 5B JUMPDEST 0961 61 PUSH2 0x0971 0964 61 PUSH2 0x096b 0967 61 PUSH2 0x1896 096A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0961 stack[0] = 0x0971 // @0964 stack[1] = 0x096b // } // Block ends with call to 0x1896, returns to 0x096B label_096B: // Incoming return from call to 0x1896 at 0x096A // Inputs[1] { @096C stack[-3] } 096B 5B JUMPDEST 096C 82 DUP3 096D 61 PUSH2 0x189a 0970 56 *JUMP // Stack delta = +1 // Outputs[1] { @096C stack[0] = stack[-3] } // Block ends with unconditional jump to 0x189a label_0971: // Incoming return from call to 0x096B at 0x096A // Inputs[1] { @0975 stack[-1] } 0971 5B JUMPDEST 0972 61 PUSH2 0x09ac 0975 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09ac, if stack[-1] label_0976: // Incoming jump from 0x0975, if not stack[-1] // Inputs[3] // { // @0978 memory[0x40:0x60] // @09A6 memory[0x40:0x60] // @09AB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0976 60 PUSH1 0x40 0978 51 MLOAD 0979 62 PUSH3 0x461bcd 097D 60 PUSH1 0xe5 097F 1B SHL 0980 81 DUP2 0981 52 MSTORE 0982 60 PUSH1 0x04 0984 01 ADD 0985 80 DUP1 0986 80 DUP1 0987 60 PUSH1 0x20 0989 01 ADD 098A 82 DUP3 098B 81 DUP2 098C 03 SUB 098D 82 DUP3 098E 52 MSTORE 098F 60 PUSH1 0x31 0991 81 DUP2 0992 52 MSTORE 0993 60 PUSH1 0x20 0995 01 ADD 0996 80 DUP1 0997 61 PUSH2 0x2413 099A 60 PUSH1 0x31 099C 91 SWAP2 099D 39 CODECOPY 099E 60 PUSH1 0x40 09A0 01 ADD 09A1 91 SWAP2 09A2 50 POP 09A3 50 POP 09A4 60 PUSH1 0x40 09A6 51 MLOAD 09A7 80 DUP1 09A8 91 SWAP2 09A9 03 SUB 09AA 90 SWAP1 09AB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0981 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @098E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0992 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @099D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x2413:0x2444] // @09AB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09AC: // Incoming jump from 0x0975, if stack[-1] // Inputs[3] // { // @09B0 stack[-3] // @09B1 stack[-2] // @09B2 stack[-1] // } 09AC 5B JUMPDEST 09AD 61 PUSH2 0x09b7 09B0 83 DUP4 09B1 83 DUP4 09B2 83 DUP4 09B3 61 PUSH2 0x193e 09B6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09AD stack[0] = 0x09b7 // @09B0 stack[1] = stack[-3] // @09B1 stack[2] = stack[-2] // @09B2 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x193e label_09B7: // Incoming return from call to 0x1CDC at 0x195C // Incoming jump from 0x21DC, if !(storage[stack[-2]] > stack[-1]) // Inputs[1] { @09BB stack[-4] } 09B7 5B JUMPDEST 09B8 50 POP 09B9 50 POP 09BA 50 POP 09BB 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_09BC: // Incoming jump from 0x0420 // Inputs[5] // { // @09BF storage[0x12] // @09C3 memory[0x40:0x60] // @09CE msg.sender // @09D5 memory[0x40:0x60] // @0A00 address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // } 09BC 5B JUMPDEST 09BD 60 PUSH1 0x12 09BF 54 SLOAD 09C0 60 PUSH1 0x40 09C2 80 DUP1 09C3 51 MLOAD 09C4 63 PUSH4 0x71be737d 09C9 60 PUSH1 0xe1 09CB 1B SHL 09CC 81 DUP2 09CD 52 MSTORE 09CE 33 CALLER 09CF 60 PUSH1 0x04 09D1 82 DUP3 09D2 01 ADD 09D3 52 MSTORE 09D4 90 SWAP1 09D5 51 MLOAD 09D6 60 PUSH1 0x01 09D8 60 PUSH1 0x01 09DA 60 PUSH1 0xa0 09DC 1B SHL 09DD 03 SUB 09DE 90 SWAP1 09DF 92 SWAP3 09E0 16 AND 09E1 91 SWAP2 09E2 60 PUSH1 0x00 09E4 91 SWAP2 09E5 83 DUP4 09E6 91 SWAP2 09E7 63 PUSH4 0xe37ce6fa 09EC 91 SWAP2 09ED 60 PUSH1 0x24 09EF 80 DUP1 09F0 82 DUP3 09F1 01 ADD 09F2 92 SWAP3 09F3 60 PUSH1 0x20 09F5 92 SWAP3 09F6 90 SWAP1 09F7 91 SWAP2 09F8 90 SWAP1 09F9 82 DUP3 09FA 90 SWAP1 09FB 03 SUB 09FC 01 ADD 09FD 81 DUP2 09FE 86 DUP7 09FF 80 DUP1 0A00 3B EXTCODESIZE 0A01 15 ISZERO 0A02 80 DUP1 0A03 15 ISZERO 0A04 61 PUSH2 0x0a0c 0A07 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @09CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x71be737d << 0xe1 // @09D3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @09E1 stack[0] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @09E4 stack[1] = 0x00 // @09E6 stack[2] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @09EC stack[3] = 0xe37ce6fa // @09F2 stack[4] = memory[0x40:0x60] + 0x24 // @09F5 stack[5] = 0x20 // @09F7 stack[6] = memory[0x40:0x60] // @09FC stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @09FD stack[8] = memory[0x40:0x60] // @09FE stack[9] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @0A01 stack[10] = !address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0a0c, if !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length label_0A08: // Incoming jump from 0x0A07, if not !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0A0B memory[0x00:0x00] } 0A08 60 PUSH1 0x00 0A0A 80 DUP1 0A0B FD *REVERT // Stack delta = +0 // Outputs[1] { @0A0B revert(memory[0x00:0x00]); } // Block terminates label_0A0C: // Incoming jump from 0x0A07, if !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @0A0E msg.gas // @0A0F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0A0F stack[-5] // @0A0F stack[-6] // @0A0F stack[-2] // @0A0F stack[-3] // @0A0F stack[-4] // @0A0F memory[stack[-3]:stack[-3] + stack[-4]] // } 0A0C 5B JUMPDEST 0A0D 50 POP 0A0E 5A GAS 0A0F FA STATICCALL 0A10 15 ISZERO 0A11 80 DUP1 0A12 15 ISZERO 0A13 61 PUSH2 0x0a20 0A16 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0A0F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0A10 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0a20, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0A17: // Incoming jump from 0x0A16, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0A17 returndata.length // @0A1B returndata[0x00:0x00 + returndata.length] // @0A1C returndata.length // @0A1F memory[0x00:0x00 + returndata.length] // } 0A17 3D RETURNDATASIZE 0A18 60 PUSH1 0x00 0A1A 80 DUP1 0A1B 3E RETURNDATACOPY 0A1C 3D RETURNDATASIZE 0A1D 60 PUSH1 0x00 0A1F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A1B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A1F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A20: // Incoming jump from 0x0A16, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0A27 memory[0x40:0x60] // @0A28 returndata.length // } 0A20 5B JUMPDEST 0A21 50 POP 0A22 50 POP 0A23 50 POP 0A24 50 POP 0A25 60 PUSH1 0x40 0A27 51 MLOAD 0A28 3D RETURNDATASIZE 0A29 60 PUSH1 0x20 0A2B 81 DUP2 0A2C 10 LT 0A2D 15 ISZERO 0A2E 61 PUSH2 0x0a36 0A31 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0A27 stack[-4] = memory[0x40:0x60] // @0A28 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0a36, if !(returndata.length < 0x20) label_0A32: // Incoming jump from 0x0A31, if not !(returndata.length < 0x20) // Inputs[1] { @0A35 memory[0x00:0x00] } 0A32 60 PUSH1 0x00 0A34 80 DUP1 0A35 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A35 revert(memory[0x00:0x00]); } // Block terminates label_0A36: // Incoming jump from 0x0A31, if !(returndata.length < 0x20) // Inputs[3] // { // @0A38 stack[-2] // @0A38 memory[stack[-2]:stack[-2] + 0x20] // @0A39 stack[-3] // } 0A36 5B JUMPDEST 0A37 50 POP 0A38 51 MLOAD 0A39 90 SWAP1 0A3A 50 POP 0A3B 60 PUSH1 0x01 0A3D 81 DUP2 0A3E 15 ISZERO 0A3F 15 ISZERO 0A40 14 EQ 0A41 61 PUSH2 0x0a49 0A44 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0A39 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0a49, if !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 label_0A45: // Incoming jump from 0x0A44, if not !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 // Inputs[1] { @0A48 memory[0x00:0x00] } 0A45 60 PUSH1 0x00 0A47 80 DUP1 0A48 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A48 revert(memory[0x00:0x00]); } // Block terminates label_0A49: // Incoming jump from 0x0A44, if !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 // Inputs[3] // { // @0A4C stack[-4] // @0A57 memory[0x00:0x40] // @0A58 storage[keccak256(memory[0x00:0x40])] // } 0A49 5B JUMPDEST 0A4A 60 PUSH1 0x00 0A4C 84 DUP5 0A4D 81 DUP2 0A4E 52 MSTORE 0A4F 60 PUSH1 0x17 0A51 60 PUSH1 0x20 0A53 52 MSTORE 0A54 60 PUSH1 0x40 0A56 90 SWAP1 0A57 20 SHA3 0A58 54 SLOAD 0A59 60 PUSH1 0xff 0A5B 16 AND 0A5C 15 ISZERO 0A5D 15 ISZERO 0A5E 60 PUSH1 0x01 0A60 14 EQ 0A61 15 ISZERO 0A62 61 PUSH2 0x0aa9 0A65 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0A4E memory[0x00:0x20] = stack[-4] // @0A53 memory[0x20:0x40] = 0x17 // } // Block ends with conditional jump to 0x0aa9, if !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) label_0A66: // Incoming jump from 0x0A65, if not !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) // Inputs[3] // { // @0A69 memory[0x40:0x60] // @0A9F memory[0x40:0x60] // @0AA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0A66 60 PUSH1 0x40 0A68 80 DUP1 0A69 51 MLOAD 0A6A 62 PUSH3 0x461bcd 0A6E 60 PUSH1 0xe5 0A70 1B SHL 0A71 81 DUP2 0A72 52 MSTORE 0A73 60 PUSH1 0x20 0A75 60 PUSH1 0x04 0A77 82 DUP3 0A78 01 ADD 0A79 52 MSTORE 0A7A 60 PUSH1 0x14 0A7C 60 PUSH1 0x24 0A7E 82 DUP3 0A7F 01 ADD 0A80 52 MSTORE 0A81 73 PUSH20 0x43616e206f6e6c7920626520736574206f6e6365 0A96 60 PUSH1 0x60 0A98 1B SHL 0A99 60 PUSH1 0x44 0A9B 82 DUP3 0A9C 01 ADD 0A9D 52 MSTORE 0A9E 90 SWAP1 0A9F 51 MLOAD 0AA0 90 SWAP1 0AA1 81 DUP2 0AA2 90 SWAP1 0AA3 03 SUB 0AA4 60 PUSH1 0x64 0AA6 01 ADD 0AA7 90 SWAP1 0AA8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0A72 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A79 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A80 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @0A9D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e206f6e6c7920626520736574206f6e6365 << 0x60 // @0AA8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0AA9: // Incoming jump from 0x0A65, if !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) // Inputs[4] // { // @0AAC stack[-4] // @0ABA memory[0x00:0x40] // @0ABB stack[-3] // @0ABC memory[stack[-3]:stack[-3] + 0x20] // } 0AA9 5B JUMPDEST 0AAA 60 PUSH1 0x00 0AAC 84 DUP5 0AAD 81 DUP2 0AAE 52 MSTORE 0AAF 60 PUSH1 0x16 0AB1 60 PUSH1 0x20 0AB3 90 SWAP1 0AB4 81 DUP2 0AB5 52 MSTORE 0AB6 60 PUSH1 0x40 0AB8 90 SWAP1 0AB9 91 SWAP2 0ABA 20 SHA3 0ABB 84 DUP5 0ABC 51 MLOAD 0ABD 61 PUSH2 0x0ac8 0AC0 92 SWAP3 0AC1 86 DUP7 0AC2 01 ADD 0AC3 90 SWAP1 0AC4 61 PUSH2 0x2151 0AC7 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0AAE memory[0x00:0x20] = stack[-4] // @0AB5 memory[0x20:0x40] = 0x16 // @0ABA stack[1] = keccak256(memory[0x00:0x40]) // @0AC0 stack[0] = 0x0ac8 // @0AC3 stack[2] = stack[-3] + 0x20 // @0AC3 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with unconditional jump to 0x2151 0AC8 5B JUMPDEST 0AC9 50 POP 0ACA 60 PUSH1 0x00 0ACC 84 DUP5 0ACD 81 DUP2 0ACE 52 MSTORE 0ACF 60 PUSH1 0x17 0AD1 60 PUSH1 0x20 0AD3 52 MSTORE 0AD4 60 PUSH1 0x40 0AD6 90 SWAP1 0AD7 20 SHA3 0AD8 80 DUP1 0AD9 54 SLOAD 0ADA 60 PUSH1 0xff 0ADC 19 NOT 0ADD 16 AND 0ADE 60 PUSH1 0x01 0AE0 17 OR 0AE1 90 SWAP1 0AE2 55 SSTORE 0AE3 5B JUMPDEST 0AE4 50 POP 0AE5 50 POP 0AE6 50 POP 0AE7 50 POP 0AE8 56 *JUMP label_0AE9: // Incoming jump from 0x044C // Inputs[1] { @0AEF stack[-2] } 0AE9 5B JUMPDEST 0AEA 60 PUSH1 0x00 0AEC 61 PUSH2 0x0af4 0AEF 83 DUP4 0AF0 61 PUSH2 0x1384 0AF3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AEA stack[0] = 0x00 // @0AEC stack[1] = 0x0af4 // @0AEF stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x1384 0AF4 5B JUMPDEST 0AF5 82 DUP3 0AF6 10 LT 0AF7 61 PUSH2 0x0b31 0AFA 57 *JUMPI 0AFB 60 PUSH1 0x40 0AFD 51 MLOAD 0AFE 62 PUSH3 0x461bcd 0B02 60 PUSH1 0xe5 0B04 1B SHL 0B05 81 DUP2 0B06 52 MSTORE 0B07 60 PUSH1 0x04 0B09 01 ADD 0B0A 80 DUP1 0B0B 80 DUP1 0B0C 60 PUSH1 0x20 0B0E 01 ADD 0B0F 82 DUP3 0B10 81 DUP2 0B11 03 SUB 0B12 82 DUP3 0B13 52 MSTORE 0B14 60 PUSH1 0x2b 0B16 81 DUP2 0B17 52 MSTORE 0B18 60 PUSH1 0x20 0B1A 01 ADD 0B1B 80 DUP1 0B1C 61 PUSH2 0x220a 0B1F 60 PUSH1 0x2b 0B21 91 SWAP2 0B22 39 CODECOPY 0B23 60 PUSH1 0x40 0B25 01 ADD 0B26 91 SWAP2 0B27 50 POP 0B28 50 POP 0B29 60 PUSH1 0x40 0B2B 51 MLOAD 0B2C 80 DUP1 0B2D 91 SWAP2 0B2E 03 SUB 0B2F 90 SWAP1 0B30 FD *REVERT 0B31 5B JUMPDEST 0B32 60 PUSH1 0x01 0B34 60 PUSH1 0x01 0B36 60 PUSH1 0xa0 0B38 1B SHL 0B39 03 SUB 0B3A 83 DUP4 0B3B 16 AND 0B3C 60 PUSH1 0x00 0B3E 90 SWAP1 0B3F 81 DUP2 0B40 52 MSTORE 0B41 60 PUSH1 0x05 0B43 60 PUSH1 0x20 0B45 52 MSTORE 0B46 60 PUSH1 0x40 0B48 90 SWAP1 0B49 20 SHA3 0B4A 80 DUP1 0B4B 54 SLOAD 0B4C 83 DUP4 0B4D 90 SWAP1 0B4E 81 DUP2 0B4F 10 LT 0B50 61 PUSH2 0x0b55 0B53 57 *JUMPI 0B54 FE *ASSERT 0B55 5B JUMPDEST 0B56 90 SWAP1 0B57 60 PUSH1 0x00 0B59 52 MSTORE 0B5A 60 PUSH1 0x20 0B5C 60 PUSH1 0x00 0B5E 20 SHA3 0B5F 01 ADD 0B60 54 SLOAD 0B61 90 SWAP1 0B62 50 POP 0B63 92 SWAP3 0B64 91 SWAP2 0B65 50 POP 0B66 50 POP 0B67 56 *JUMP label_0B68: // Incoming jump from 0x0482 // Inputs[4] // { // @0B6C stack[-3] // @0B6D stack[-2] // @0B6E stack[-1] // @0B71 memory[0x40:0x60] // } 0B68 5B JUMPDEST 0B69 61 PUSH2 0x09b7 0B6C 83 DUP4 0B6D 83 DUP4 0B6E 83 DUP4 0B6F 60 PUSH1 0x40 0B71 51 MLOAD 0B72 80 DUP1 0B73 60 PUSH1 0x20 0B75 01 ADD 0B76 60 PUSH1 0x40 0B78 52 MSTORE 0B79 80 DUP1 0B7A 60 PUSH1 0x00 0B7C 81 DUP2 0B7D 52 MSTORE 0B7E 50 POP 0B7F 61 PUSH2 0x15b3 0B82 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0B69 stack[0] = 0x09b7 // @0B6C stack[1] = stack[-3] // @0B6D stack[2] = stack[-2] // @0B6E stack[3] = stack[-1] // @0B71 stack[4] = memory[0x40:0x60] // @0B78 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0B7D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x15b3 label_0B83: // Incoming jump from 0x04AE // Inputs[5] // { // @0B86 storage[0x12] // @0B8A memory[0x40:0x60] // @0B95 msg.sender // @0B9C memory[0x40:0x60] // @0BC7 address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // } 0B83 5B JUMPDEST 0B84 60 PUSH1 0x12 0B86 54 SLOAD 0B87 60 PUSH1 0x40 0B89 80 DUP1 0B8A 51 MLOAD 0B8B 63 PUSH4 0x71be737d 0B90 60 PUSH1 0xe1 0B92 1B SHL 0B93 81 DUP2 0B94 52 MSTORE 0B95 33 CALLER 0B96 60 PUSH1 0x04 0B98 82 DUP3 0B99 01 ADD 0B9A 52 MSTORE 0B9B 90 SWAP1 0B9C 51 MLOAD 0B9D 60 PUSH1 0x01 0B9F 60 PUSH1 0x01 0BA1 60 PUSH1 0xa0 0BA3 1B SHL 0BA4 03 SUB 0BA5 90 SWAP1 0BA6 92 SWAP3 0BA7 16 AND 0BA8 91 SWAP2 0BA9 60 PUSH1 0x00 0BAB 91 SWAP2 0BAC 83 DUP4 0BAD 91 SWAP2 0BAE 63 PUSH4 0xe37ce6fa 0BB3 91 SWAP2 0BB4 60 PUSH1 0x24 0BB6 80 DUP1 0BB7 82 DUP3 0BB8 01 ADD 0BB9 92 SWAP3 0BBA 60 PUSH1 0x20 0BBC 92 SWAP3 0BBD 90 SWAP1 0BBE 91 SWAP2 0BBF 90 SWAP1 0BC0 82 DUP3 0BC1 90 SWAP1 0BC2 03 SUB 0BC3 01 ADD 0BC4 81 DUP2 0BC5 86 DUP7 0BC6 80 DUP1 0BC7 3B EXTCODESIZE 0BC8 15 ISZERO 0BC9 80 DUP1 0BCA 15 ISZERO 0BCB 61 PUSH2 0x0bd3 0BCE 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @0B94 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x71be737d << 0xe1 // @0B9A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0BA8 stack[0] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @0BAB stack[1] = 0x00 // @0BAD stack[2] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @0BB3 stack[3] = 0xe37ce6fa // @0BB9 stack[4] = memory[0x40:0x60] + 0x24 // @0BBC stack[5] = 0x20 // @0BBE stack[6] = memory[0x40:0x60] // @0BC3 stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0BC4 stack[8] = memory[0x40:0x60] // @0BC5 stack[9] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @0BC8 stack[10] = !address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0bd3, if !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length label_0BCF: // Incoming jump from 0x0BCE, if not !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0BD2 memory[0x00:0x00] } 0BCF 60 PUSH1 0x00 0BD1 80 DUP1 0BD2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BD2 revert(memory[0x00:0x00]); } // Block terminates label_0BD3: // Incoming jump from 0x0BCE, if !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @0BD5 msg.gas // @0BD6 stack[-6] // @0BD6 memory[stack[-3]:stack[-3] + stack[-4]] // @0BD6 stack[-5] // @0BD6 stack[-4] // @0BD6 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0BD6 stack[-2] // @0BD6 stack[-3] // } 0BD3 5B JUMPDEST 0BD4 50 POP 0BD5 5A GAS 0BD6 FA STATICCALL 0BD7 15 ISZERO 0BD8 80 DUP1 0BD9 15 ISZERO 0BDA 61 PUSH2 0x0be7 0BDD 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0BD6 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0BD7 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0be7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0BDE: // Incoming jump from 0x0BDD, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0BDE returndata.length // @0BE2 returndata[0x00:0x00 + returndata.length] // @0BE3 returndata.length // @0BE6 memory[0x00:0x00 + returndata.length] // } 0BDE 3D RETURNDATASIZE 0BDF 60 PUSH1 0x00 0BE1 80 DUP1 0BE2 3E RETURNDATACOPY 0BE3 3D RETURNDATASIZE 0BE4 60 PUSH1 0x00 0BE6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BE2 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0BE6 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0BE7: // Incoming jump from 0x0BDD, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0BEE memory[0x40:0x60] // @0BEF returndata.length // } 0BE7 5B JUMPDEST 0BE8 50 POP 0BE9 50 POP 0BEA 50 POP 0BEB 50 POP 0BEC 60 PUSH1 0x40 0BEE 51 MLOAD 0BEF 3D RETURNDATASIZE 0BF0 60 PUSH1 0x20 0BF2 81 DUP2 0BF3 10 LT 0BF4 15 ISZERO 0BF5 61 PUSH2 0x0bfd 0BF8 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0BEE stack[-4] = memory[0x40:0x60] // @0BEF stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0bfd, if !(returndata.length < 0x20) label_0BF9: // Incoming jump from 0x0BF8, if not !(returndata.length < 0x20) // Inputs[1] { @0BFC memory[0x00:0x00] } 0BF9 60 PUSH1 0x00 0BFB 80 DUP1 0BFC FD *REVERT // Stack delta = +0 // Outputs[1] { @0BFC revert(memory[0x00:0x00]); } // Block terminates label_0BFD: // Incoming jump from 0x0BF8, if !(returndata.length < 0x20) // Inputs[3] // { // @0BFF stack[-2] // @0BFF memory[stack[-2]:stack[-2] + 0x20] // @0C00 stack[-3] // } 0BFD 5B JUMPDEST 0BFE 50 POP 0BFF 51 MLOAD 0C00 90 SWAP1 0C01 50 POP 0C02 60 PUSH1 0x01 0C04 81 DUP2 0C05 15 ISZERO 0C06 15 ISZERO 0C07 14 EQ 0C08 61 PUSH2 0x0c10 0C0B 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0C00 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0c10, if !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 label_0C0C: // Incoming jump from 0x0C0B, if not !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 // Inputs[1] { @0C0F memory[0x00:0x00] } 0C0C 60 PUSH1 0x00 0C0E 80 DUP1 0C0F FD *REVERT // Stack delta = +0 // Outputs[1] { @0C0F revert(memory[0x00:0x00]); } // Block terminates label_0C10: // Incoming jump from 0x0C0B, if !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 // Inputs[3] // { // @0C13 storage[0x13] // @0C16 stack[-3] // @0C21 memory[0x00:0x40] // } 0C10 5B JUMPDEST 0C11 60 PUSH1 0x13 0C13 54 SLOAD 0C14 60 PUSH1 0x00 0C16 84 DUP5 0C17 81 DUP2 0C18 52 MSTORE 0C19 60 PUSH1 0x14 0C1B 60 PUSH1 0x20 0C1D 52 MSTORE 0C1E 60 PUSH1 0x40 0C20 90 SWAP1 0C21 20 SHA3 0C22 60 PUSH1 0x01 0C24 60 PUSH1 0x01 0C26 60 PUSH1 0xa0 0C28 1B SHL 0C29 03 SUB 0C2A 90 SWAP1 0C2B 91 SWAP2 0C2C 16 AND 0C2D 90 SWAP1 0C2E 61 PUSH2 0x0c36 0C31 90 SWAP1 0C32 61 PUSH2 0x195d 0C35 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0C18 memory[0x00:0x20] = stack[-3] // @0C1D memory[0x20:0x40] = 0x14 // @0C2D stack[0] = storage[0x13] & (0x01 << 0xa0) - 0x01 // @0C31 stack[1] = 0x0c36 // @0C31 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x195d, returns to 0x0C36 label_0C36: // Incoming return from call to 0x195D at 0x0C35 // Inputs[1] { @0C39 storage[0x0f] } 0C36 5B JUMPDEST 0C37 60 PUSH1 0x0f 0C39 54 SLOAD 0C3A 60 PUSH1 0xff 0C3C 16 AND 0C3D 15 ISZERO 0C3E 15 ISZERO 0C3F 60 PUSH1 0x01 0C41 14 EQ 0C42 15 ISZERO 0C43 61 PUSH2 0x0c93 0C46 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c93, if !(0x01 == !!(0xff & storage[0x0f])) label_0C47: // Incoming jump from 0x0C46, if not !(0x01 == !!(0xff & storage[0x0f])) // Inputs[3] // { // @0C4A memory[0x40:0x60] // @0C89 memory[0x40:0x60] // @0C92 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0C47 60 PUSH1 0x40 0C49 80 DUP1 0C4A 51 MLOAD 0C4B 62 PUSH3 0x461bcd 0C4F 60 PUSH1 0xe5 0C51 1B SHL 0C52 81 DUP2 0C53 52 MSTORE 0C54 60 PUSH1 0x20 0C56 60 PUSH1 0x04 0C58 82 DUP3 0C59 01 ADD 0C5A 52 MSTORE 0C5B 60 PUSH1 0x18 0C5D 60 PUSH1 0x24 0C5F 82 DUP3 0C60 01 ADD 0C61 52 MSTORE 0C62 7F PUSH32 0x5468697320636f6e747261637420697320636c6f736564210000000000000000 0C83 60 PUSH1 0x44 0C85 82 DUP3 0C86 01 ADD 0C87 52 MSTORE 0C88 90 SWAP1 0C89 51 MLOAD 0C8A 90 SWAP1 0C8B 81 DUP2 0C8C 90 SWAP1 0C8D 03 SUB 0C8E 60 PUSH1 0x64 0C90 01 ADD 0C91 90 SWAP1 0C92 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C5A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C61 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @0C87 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468697320636f6e747261637420697320636c6f736564210000000000000000 // @0C92 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0C93: // Incoming jump from 0x0C46, if !(0x01 == !!(0xff & storage[0x0f])) // Inputs[2] // { // @0C96 stack[-4] // @0CA1 memory[0x00:0x40] // } 0C93 5B JUMPDEST 0C94 60 PUSH1 0x00 0C96 84 DUP5 0C97 81 DUP2 0C98 52 MSTORE 0C99 60 PUSH1 0x14 0C9B 60 PUSH1 0x20 0C9D 52 MSTORE 0C9E 60 PUSH1 0x40 0CA0 81 DUP2 0CA1 20 SHA3 0CA2 61 PUSH2 0x0caa 0CA5 90 SWAP1 0CA6 61 PUSH2 0x1966 0CA9 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0C94 stack[0] = 0x00 // @0C98 memory[0x00:0x20] = stack[-4] // @0C9D memory[0x20:0x40] = 0x14 // @0CA5 stack[1] = 0x0caa // @0CA5 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x1966, returns to 0x0CAA label_0CAA: // Incoming return from call to 0x1966 at 0x0CA9 // Inputs[8] // { // @0CAB stack[-1] // @0CAB stack[-2] // @0CAF stack[-3] // @0CC0 storage[0x0e] // @0CC1 stack[-6] // @0CC5 memory[0x40:0x60] // @0CF1 memory[0x40:0x60] // @0CF8 address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // } 0CAA 5B JUMPDEST 0CAB 90 SWAP1 0CAC 50 POP 0CAD 60 PUSH1 0x00 0CAF 82 DUP3 0CB0 60 PUSH1 0x01 0CB2 60 PUSH1 0x01 0CB4 60 PUSH1 0xa0 0CB6 1B SHL 0CB7 03 SUB 0CB8 16 AND 0CB9 63 PUSH4 0x959c45b7 0CBE 60 PUSH1 0x0e 0CC0 54 SLOAD 0CC1 88 DUP9 0CC2 85 DUP6 0CC3 60 PUSH1 0x40 0CC5 51 MLOAD 0CC6 84 DUP5 0CC7 63 PUSH4 0xffffffff 0CCC 16 AND 0CCD 60 PUSH1 0xe0 0CCF 1B SHL 0CD0 81 DUP2 0CD1 52 MSTORE 0CD2 60 PUSH1 0x04 0CD4 01 ADD 0CD5 80 DUP1 0CD6 84 DUP5 0CD7 81 DUP2 0CD8 52 MSTORE 0CD9 60 PUSH1 0x20 0CDB 01 ADD 0CDC 83 DUP4 0CDD 81 DUP2 0CDE 52 MSTORE 0CDF 60 PUSH1 0x20 0CE1 01 ADD 0CE2 82 DUP3 0CE3 81 DUP2 0CE4 52 MSTORE 0CE5 60 PUSH1 0x20 0CE7 01 ADD 0CE8 93 SWAP4 0CE9 50 POP 0CEA 50 POP 0CEB 50 POP 0CEC 50 POP 0CED 60 PUSH1 0x20 0CEF 60 PUSH1 0x40 0CF1 51 MLOAD 0CF2 80 DUP1 0CF3 83 DUP4 0CF4 03 SUB 0CF5 81 DUP2 0CF6 86 DUP7 0CF7 80 DUP1 0CF8 3B EXTCODESIZE 0CF9 15 ISZERO 0CFA 80 DUP1 0CFB 15 ISZERO 0CFC 61 PUSH2 0x0d04 0CFF 57 *JUMPI // Stack delta = +9 // Outputs[15] // { // @0CAB stack[-2] = stack[-1] // @0CAD stack[-1] = 0x00 // @0CB8 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0CB9 stack[1] = 0x959c45b7 // @0CD1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x959c45b7) << 0xe0 // @0CD8 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = storage[0x0e] // @0CDE memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-6] // @0CE4 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @0CE8 stack[2] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0CED stack[3] = 0x20 // @0CF1 stack[4] = memory[0x40:0x60] // @0CF4 stack[5] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0CF5 stack[6] = memory[0x40:0x60] // @0CF6 stack[7] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0CF9 stack[8] = !address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // } // Block ends with conditional jump to 0x0d04, if !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length label_0D00: // Incoming jump from 0x0CFF, if not !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // Inputs[1] { @0D03 memory[0x00:0x00] } 0D00 60 PUSH1 0x00 0D02 80 DUP1 0D03 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D03 revert(memory[0x00:0x00]); } // Block terminates label_0D04: // Incoming jump from 0x0CFF, if !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // Inputs[8] // { // @0D06 msg.gas // @0D07 stack[-6] // @0D07 stack[-5] // @0D07 memory[stack[-3]:stack[-3] + stack[-4]] // @0D07 stack[-3] // @0D07 stack[-4] // @0D07 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D07 stack[-2] // } 0D04 5B JUMPDEST 0D05 50 POP 0D06 5A GAS 0D07 FA STATICCALL 0D08 15 ISZERO 0D09 80 DUP1 0D0A 15 ISZERO 0D0B 61 PUSH2 0x0d18 0D0E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0D07 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D08 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0d18, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0D0F: // Incoming jump from 0x0D0E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0D0F returndata.length // @0D13 returndata[0x00:0x00 + returndata.length] // @0D14 returndata.length // @0D17 memory[0x00:0x00 + returndata.length] // } 0D0F 3D RETURNDATASIZE 0D10 60 PUSH1 0x00 0D12 80 DUP1 0D13 3E RETURNDATACOPY 0D14 3D RETURNDATASIZE 0D15 60 PUSH1 0x00 0D17 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D13 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0D17 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0D18: // Incoming jump from 0x0D0E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0D1F memory[0x40:0x60] // @0D20 returndata.length // } 0D18 5B JUMPDEST 0D19 50 POP 0D1A 50 POP 0D1B 50 POP 0D1C 50 POP 0D1D 60 PUSH1 0x40 0D1F 51 MLOAD 0D20 3D RETURNDATASIZE 0D21 60 PUSH1 0x20 0D23 81 DUP2 0D24 10 LT 0D25 15 ISZERO 0D26 61 PUSH2 0x0d2e 0D29 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0D1F stack[-4] = memory[0x40:0x60] // @0D20 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0d2e, if !(returndata.length < 0x20) label_0D2A: // Incoming jump from 0x0D29, if not !(returndata.length < 0x20) // Inputs[1] { @0D2D memory[0x00:0x00] } 0D2A 60 PUSH1 0x00 0D2C 80 DUP1 0D2D FD *REVERT // Stack delta = +0 // Outputs[1] { @0D2D revert(memory[0x00:0x00]); } // Block terminates label_0D2E: // Incoming jump from 0x0D29, if !(returndata.length < 0x20) // Inputs[7] // { // @0D30 stack[-2] // @0D30 memory[stack[-2]:stack[-2] + 0x20] // @0D34 memory[0x40:0x60] // @0D47 memory[0x40:0x60] // @0D49 stack[-3] // @0D56 stack[-5] // @0D71 address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // } 0D2E 5B JUMPDEST 0D2F 50 POP 0D30 51 MLOAD 0D31 60 PUSH1 0x40 0D33 80 DUP1 0D34 51 MLOAD 0D35 63 PUSH4 0x7bb7ca87 0D3A 60 PUSH1 0xe1 0D3C 1B SHL 0D3D 81 DUP2 0D3E 52 MSTORE 0D3F 60 PUSH1 0x04 0D41 81 DUP2 0D42 01 ADD 0D43 83 DUP4 0D44 90 SWAP1 0D45 52 MSTORE 0D46 90 SWAP1 0D47 51 MLOAD 0D48 91 SWAP2 0D49 92 SWAP3 0D4A 50 POP 0D4B 60 PUSH1 0x60 0D4D 91 SWAP2 0D4E 60 PUSH1 0x01 0D50 60 PUSH1 0x01 0D52 60 PUSH1 0xa0 0D54 1B SHL 0D55 03 SUB 0D56 86 DUP7 0D57 16 AND 0D58 91 SWAP2 0D59 63 PUSH4 0xf76f950e 0D5E 91 SWAP2 0D5F 60 PUSH1 0x24 0D61 80 DUP1 0D62 83 DUP4 0D63 01 ADD 0D64 92 SWAP3 0D65 60 PUSH1 0x00 0D67 92 SWAP3 0D68 91 SWAP2 0D69 90 SWAP1 0D6A 82 DUP3 0D6B 90 SWAP1 0D6C 03 SUB 0D6D 01 ADD 0D6E 81 DUP2 0D6F 86 DUP7 0D70 80 DUP1 0D71 3B EXTCODESIZE 0D72 15 ISZERO 0D73 80 DUP1 0D74 15 ISZERO 0D75 61 PUSH2 0x0d7d 0D78 57 *JUMPI // Stack delta = +8 // Outputs[13] // { // @0D3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7bb7ca87 << 0xe1 // @0D45 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0D49 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @0D4D stack[-2] = 0x60 // @0D58 stack[-1] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0D5E stack[0] = 0xf76f950e // @0D64 stack[1] = memory[0x40:0x60] + 0x24 // @0D67 stack[2] = 0x00 // @0D68 stack[3] = memory[0x40:0x60] // @0D6D stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0D6E stack[5] = memory[0x40:0x60] // @0D6F stack[6] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0D72 stack[7] = !address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0d7d, if !!address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length label_0D79: // Incoming jump from 0x0D78, if not !!address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0D7C memory[0x00:0x00] } 0D79 60 PUSH1 0x00 0D7B 80 DUP1 0D7C FD *REVERT // Stack delta = +0 // Outputs[1] { @0D7C revert(memory[0x00:0x00]); } // Block terminates label_0D7D: // Incoming jump from 0x0D78, if !!address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @0D7F msg.gas // @0D80 memory[stack[-3]:stack[-3] + stack[-4]] // @0D80 stack[-3] // @0D80 stack[-4] // @0D80 stack[-2] // @0D80 stack[-5] // @0D80 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D80 stack[-6] // } 0D7D 5B JUMPDEST 0D7E 50 POP 0D7F 5A GAS 0D80 FA STATICCALL 0D81 15 ISZERO 0D82 80 DUP1 0D83 15 ISZERO 0D84 61 PUSH2 0x0d91 0D87 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0D80 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D81 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0d91, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0D88: // Incoming jump from 0x0D87, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0D88 returndata.length // @0D8C returndata[0x00:0x00 + returndata.length] // @0D8D returndata.length // @0D90 memory[0x00:0x00 + returndata.length] // } 0D88 3D RETURNDATASIZE 0D89 60 PUSH1 0x00 0D8B 80 DUP1 0D8C 3E RETURNDATACOPY 0D8D 3D RETURNDATASIZE 0D8E 60 PUSH1 0x00 0D90 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D8C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0D90 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0D91: // Incoming jump from 0x0D87, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0D98 memory[0x40:0x60] // @0D99 returndata.length // @0D9D returndata[0x00:0x00 + returndata.length] // @0DA0 returndata.length // } 0D91 5B JUMPDEST 0D92 50 POP 0D93 50 POP 0D94 50 POP 0D95 50 POP 0D96 60 PUSH1 0x40 0D98 51 MLOAD 0D99 3D RETURNDATASIZE 0D9A 60 PUSH1 0x00 0D9C 82 DUP3 0D9D 3E RETURNDATACOPY 0D9E 60 PUSH1 0x1f 0DA0 3D RETURNDATASIZE 0DA1 90 SWAP1 0DA2 81 DUP2 0DA3 01 ADD 0DA4 60 PUSH1 0x1f 0DA6 19 NOT 0DA7 16 AND 0DA8 82 DUP3 0DA9 01 ADD 0DAA 60 PUSH1 0x40 0DAC 52 MSTORE 0DAD 60 PUSH1 0x20 0DAF 81 DUP2 0DB0 10 LT 0DB1 15 ISZERO 0DB2 61 PUSH2 0x0dba 0DB5 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @0D98 stack[-4] = memory[0x40:0x60] // @0D9D memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0DA1 stack[-3] = returndata.length // @0DAC memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // } // Block ends with conditional jump to 0x0dba, if !(returndata.length < 0x20) label_0DB6: // Incoming jump from 0x0DB5, if not !(returndata.length < 0x20) // Inputs[1] { @0DB9 memory[0x00:0x00] } 0DB6 60 PUSH1 0x00 0DB8 80 DUP1 0DB9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DB9 revert(memory[0x00:0x00]); } // Block terminates label_0DBA: // Incoming jump from 0x0DB5, if !(returndata.length < 0x20) // Inputs[4] // { // @0DBB stack[-2] // @0DBC stack[-1] // @0DC0 memory[stack[-2]:stack[-2] + 0x20] // @0DC3 memory[0x40:0x60] // } 0DBA 5B JUMPDEST 0DBB 81 DUP2 0DBC 01 ADD 0DBD 90 SWAP1 0DBE 80 DUP1 0DBF 80 DUP1 0DC0 51 MLOAD 0DC1 60 PUSH1 0x40 0DC3 51 MLOAD 0DC4 93 SWAP4 0DC5 92 SWAP3 0DC6 91 SWAP2 0DC7 90 SWAP1 0DC8 84 DUP5 0DC9 60 PUSH1 0x01 0DCB 60 PUSH1 0x20 0DCD 1B SHL 0DCE 82 DUP3 0DCF 11 GT 0DD0 15 ISZERO 0DD1 61 PUSH2 0x0dd9 0DD4 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0DC4 stack[-2] = memory[0x40:0x60] // @0DC5 stack[-1] = stack[-2] + stack[-1] // @0DC6 stack[0] = stack[-2] // @0DC7 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @0DC7 stack[1] = stack[-2] // @0DC8 stack[3] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0dd9, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_0DD5: // Incoming jump from 0x0DD4, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0DD8 memory[0x00:0x00] } 0DD5 60 PUSH1 0x00 0DD7 80 DUP1 0DD8 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DD8 revert(memory[0x00:0x00]); } // Block terminates label_0DD9: // Incoming jump from 0x0DD4, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[4] // { // @0DDA stack[-2] // @0DDA stack[-1] // @0DDB stack[-4] // @0DE2 stack[-5] // } 0DD9 5B JUMPDEST 0DDA 90 SWAP1 0DDB 83 DUP4 0DDC 01 ADD 0DDD 90 SWAP1 0DDE 60 PUSH1 0x20 0DE0 82 DUP3 0DE1 01 ADD 0DE2 85 DUP6 0DE3 81 DUP2 0DE4 11 GT 0DE5 15 ISZERO 0DE6 61 PUSH2 0x0dee 0DE9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0DDD stack[-2] = stack[-4] + stack[-2] // @0DDD stack[-1] = stack[-1] // @0DE1 stack[0] = stack[-4] + stack[-2] + 0x20 // } // Block ends with conditional jump to 0x0dee, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_0DEA: // Incoming jump from 0x0DE9, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @0DED memory[0x00:0x00] } 0DEA 60 PUSH1 0x00 0DEC 80 DUP1 0DED FD *REVERT // Stack delta = +0 // Outputs[1] { @0DED revert(memory[0x00:0x00]); } // Block terminates label_0DEE: // Incoming jump from 0x0DE9, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[4] // { // @0DEF stack[-3] // @0DF0 memory[stack[-3]:stack[-3] + 0x20] // @0DF8 stack[-1] // @0DFB stack[-6] // } 0DEE 5B JUMPDEST 0DEF 82 DUP3 0DF0 51 MLOAD 0DF1 60 PUSH1 0x01 0DF3 60 PUSH1 0x20 0DF5 1B SHL 0DF6 81 DUP2 0DF7 11 GT 0DF8 82 DUP3 0DF9 82 DUP3 0DFA 01 ADD 0DFB 88 DUP9 0DFC 10 LT 0DFD 17 OR 0DFE 15 ISZERO 0DFF 61 PUSH2 0x0e07 0E02 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DF0 stack[0] = memory[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x0e07, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) label_0E03: // Incoming jump from 0x0E02, if not !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[1] { @0E06 memory[0x00:0x00] } 0E03 60 PUSH1 0x00 0E05 80 DUP1 0E06 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E06 revert(memory[0x00:0x00]); } // Block terminates label_0E07: // Incoming jump from 0x0E02, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[4] // { // @0E08 stack[-3] // @0E09 stack[-1] // @0E0B stack[-4] // @0E0C memory[stack[-4]:stack[-4] + 0x20] // } 0E07 5B JUMPDEST 0E08 82 DUP3 0E09 52 MSTORE 0E0A 50 POP 0E0B 81 DUP2 0E0C 51 MLOAD 0E0D 60 PUSH1 0x20 0E0F 91 SWAP2 0E10 82 DUP3 0E11 01 ADD 0E12 92 SWAP3 0E13 90 SWAP1 0E14 91 SWAP2 0E15 01 ADD 0E16 90 SWAP1 0E17 80 DUP1 0E18 83 DUP4 0E19 83 DUP4 0E1A 60 PUSH1 0x00 0E1C 5B JUMPDEST 0E1D 83 DUP4 0E1E 81 DUP2 0E1F 10 LT 0E20 15 ISZERO 0E21 61 PUSH2 0x0e34 0E24 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @0E09 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @0E12 stack[-4] = 0x20 + stack[-3] // @0E16 stack[-2] = memory[stack[-4]:stack[-4] + 0x20] // @0E16 stack[-3] = 0x20 + stack[-4] // @0E17 stack[-1] = memory[stack[-4]:stack[-4] + 0x20] // @0E18 stack[0] = 0x20 + stack[-3] // @0E19 stack[1] = 0x20 + stack[-4] // @0E1A stack[2] = 0x00 // } // Block ends with conditional jump to 0x0e34, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_0E25: // Incoming jump from 0x0E24, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0E24, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @0E25 stack[-2] // @0E26 stack[-1] // @0E28 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0E29 stack[-3] // } 0E25 81 DUP2 0E26 81 DUP2 0E27 01 ADD 0E28 51 MLOAD 0E29 83 DUP4 0E2A 82 DUP3 0E2B 01 ADD 0E2C 52 MSTORE 0E2D 60 PUSH1 0x20 0E2F 01 ADD 0E30 61 PUSH2 0x0e1c 0E33 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0E2C memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0E2F stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0e1c label_0E34: // Incoming jump from 0x0E24, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0E24, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @0E39 stack[-6] // @0E39 stack[-5] // @0E3B stack[-7] // } 0E34 5B JUMPDEST 0E35 50 POP 0E36 50 POP 0E37 50 POP 0E38 50 POP 0E39 90 SWAP1 0E3A 50 POP 0E3B 90 SWAP1 0E3C 81 DUP2 0E3D 01 ADD 0E3E 90 SWAP1 0E3F 60 PUSH1 0x1f 0E41 16 AND 0E42 80 DUP1 0E43 15 ISZERO 0E44 61 PUSH2 0x0e61 0E47 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0E3E stack[-7] = stack[-5] + stack[-7] // @0E41 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0e61, if !(0x1f & stack[-5]) label_0E48: // Incoming jump from 0x0E47, if not !(0x1f & stack[-5]) // Inputs[10] // { // @0E48 stack[-1] // @0E49 stack[-2] // @0E4C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0E7F storage[0x10] // @0E9A stack[-6] // @0E9B stack[-7] // @0EA8 stack[-10] // @0EAA stack[-5] // @0EB1 stack[-4] // @0EB4 stack[-3] // } 0E48 80 DUP1 0E49 82 DUP3 0E4A 03 SUB 0E4B 80 DUP1 0E4C 51 MLOAD 0E4D 60 PUSH1 0x01 0E4F 83 DUP4 0E50 60 PUSH1 0x20 0E52 03 SUB 0E53 61 PUSH2 0x0100 0E56 0A EXP 0E57 03 SUB 0E58 19 NOT 0E59 16 AND 0E5A 81 DUP2 0E5B 52 MSTORE 0E5C 60 PUSH1 0x20 0E5E 01 ADD 0E5F 91 SWAP2 0E60 50 POP 0E61 5B JUMPDEST 0E62 50 POP 0E63 60 PUSH1 0x40 0E65 81 DUP2 0E66 81 DUP2 0E67 52 MSTORE 0E68 60 PUSH1 0x01 0E6A 62 PUSH3 0x8b6d85 0E6E 60 PUSH1 0xe0 0E70 1B SHL 0E71 03 SUB 0E72 19 NOT 0E73 82 DUP3 0E74 52 MSTORE 0E75 60 PUSH1 0x04 0E77 82 DUP3 0E78 01 ADD 0E79 90 SWAP1 0E7A 81 DUP2 0E7B 52 MSTORE 0E7C 60 PUSH1 0x10 0E7E 80 DUP1 0E7F 54 SLOAD 0E80 60 PUSH1 0x02 0E82 60 PUSH1 0x00 0E84 19 NOT 0E85 61 PUSH2 0x0100 0E88 60 PUSH1 0x01 0E8A 84 DUP5 0E8B 16 AND 0E8C 15 ISZERO 0E8D 02 MUL 0E8E 01 ADD 0E8F 90 SWAP1 0E90 91 SWAP2 0E91 16 AND 0E92 04 DIV 0E93 60 PUSH1 0x44 0E95 84 DUP5 0E96 01 ADD 0E97 81 DUP2 0E98 90 SWAP1 0E99 52 MSTORE 0E9A 96 SWAP7 0E9B 97 SWAP8 0E9C 50 POP 0E9D 60 PUSH1 0x60 0E9F 96 SWAP7 0EA0 60 PUSH1 0x01 0EA2 60 PUSH1 0x01 0EA4 60 PUSH1 0xa0 0EA6 1B SHL 0EA7 03 SUB 0EA8 8C DUP13 0EA9 16 AND 0EAA 96 SWAP7 0EAB 50 POP 0EAC 63 PUSH4 0xff74927b 0EB1 95 SWAP6 0EB2 50 POP 0EB3 90 SWAP1 0EB4 93 SWAP4 0EB5 50 POP 0EB6 87 DUP8 0EB7 92 SWAP3 0EB8 82 DUP3 0EB9 91 SWAP2 0EBA 60 PUSH1 0x24 0EBC 82 DUP3 0EBD 01 ADD 0EBE 91 SWAP2 0EBF 60 PUSH1 0x64 0EC1 01 ADD 0EC2 90 SWAP1 0EC3 86 DUP7 0EC4 90 SWAP1 0EC5 80 DUP1 0EC6 15 ISZERO 0EC7 61 PUSH2 0x0f11 0ECA 57 *JUMPI // Stack delta = +5 // Outputs[17] // { // @0E5B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0E67 memory[0x40:0x60] = 0x20 + (stack[-2] - stack[-1]) // @0E74 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = ~((0x8b6d85 << 0xe0) - 0x01) // @0E79 stack[-1] = 0x20 + (stack[-2] - stack[-1]) + 0x04 // @0E7B memory[0x20 + (stack[-2] - stack[-1]) + 0x04:0x20 + (stack[-2] - stack[-1]) + 0x04 + 0x20] = 0x40 // @0E99 memory[0x20 + (stack[-2] - stack[-1]) + 0x44:0x20 + (stack[-2] - stack[-1]) + 0x44 + 0x20] = (storage[0x10] & !(storage[0x10] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0E9B stack[-7] = stack[-6] // @0E9F stack[-6] = 0x60 // @0EAA stack[-5] = stack[-10] & (0x01 << 0xa0) - 0x01 // @0EB1 stack[-4] = 0xff74927b // @0EB4 stack[-3] = 0x10 // @0EB7 stack[-2] = stack[-6] // @0EB9 stack[0] = 0x20 + (stack[-2] - stack[-1]) + 0x04 // @0EBE stack[1] = 0x20 + (stack[-2] - stack[-1]) + 0x24 // @0EC2 stack[2] = 0x64 + 0x20 + (stack[-2] - stack[-1]) // @0EC4 stack[4] = (storage[0x10] & !(storage[0x10] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0EC4 stack[3] = 0x10 // } // Block ends with conditional jump to 0x0f11, if !((storage[0x10] & !(storage[0x10] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0ECB: // Incoming jump from 0x0ECA, if not !((storage[0x10] & !(storage[0x10] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0ECA, if not !((storage[0x10] & !(storage[0x10] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0ECB stack[-1] } 0ECB 80 DUP1 0ECC 60 PUSH1 0x1f 0ECE 10 LT 0ECF 61 PUSH2 0x0ee6 0ED2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ee6, if 0x1f < stack[-1] label_0ED3: // Incoming jump from 0x0ED2, if not 0x1f < stack[-1] // Inputs[4] // { // @0ED7 stack[-2] // @0ED8 storage[stack[-2]] // @0EDB stack[-3] // @0EDD stack[-1] // } 0ED3 61 PUSH2 0x0100 0ED6 80 DUP1 0ED7 83 DUP4 0ED8 54 SLOAD 0ED9 04 DIV 0EDA 02 MUL 0EDB 83 DUP4 0EDC 52 MSTORE 0EDD 91 SWAP2 0EDE 60 PUSH1 0x20 0EE0 01 ADD 0EE1 91 SWAP2 0EE2 61 PUSH2 0x0f11 0EE5 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0EDC memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0EE1 stack[-1] = stack[-1] // @0EE1 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0f11 label_0EE6: // Incoming jump from 0x0ED2, if 0x1f < stack[-1] // Inputs[5] // { // @0EE7 stack[-3] // @0EE8 stack[-1] // @0EEA stack[-2] // @0EF2 memory[0x00:0x20] // @0EF6 storage[keccak256(memory[0x00:0x20])] // } 0EE6 5B JUMPDEST 0EE7 82 DUP3 0EE8 01 ADD 0EE9 91 SWAP2 0EEA 90 SWAP1 0EEB 60 PUSH1 0x00 0EED 52 MSTORE 0EEE 60 PUSH1 0x20 0EF0 60 PUSH1 0x00 0EF2 20 SHA3 0EF3 90 SWAP1 0EF4 5B JUMPDEST 0EF5 81 DUP2 0EF6 54 SLOAD 0EF7 81 DUP2 0EF8 52 MSTORE 0EF9 90 SWAP1 0EFA 60 PUSH1 0x01 0EFC 01 ADD 0EFD 90 SWAP1 0EFE 60 PUSH1 0x20 0F00 01 ADD 0F01 80 DUP1 0F02 83 DUP4 0F03 11 GT 0F04 61 PUSH2 0x0ef4 0F07 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0EE9 stack[-3] = stack[-3] + stack[-1] // @0EED memory[0x00:0x20] = stack[-2] // @0EF8 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0EFD stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0F00 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0ef4, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0F08: // Incoming jump from 0x0F07, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0F07, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0F08 stack[-3] // @0F09 stack[-1] // } 0F08 82 DUP3 0F09 90 SWAP1 0F0A 03 SUB 0F0B 60 PUSH1 0x1f 0F0D 16 AND 0F0E 82 DUP3 0F0F 01 ADD 0F10 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0F10 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0F10 stack[-1] = stack[-3] // } // Block continues label_0F11: // Incoming jump from 0x0ECA, if !((storage[0x10] & !(storage[0x10] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0EE5 // Incoming jump from 0x0ECA, if !((storage[0x10] & !(storage[0x10] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0F10 // Inputs[6] // { // @0F14 stack[-6] // @0F15 stack[-3] // @0F17 stack[-4] // @0F19 stack[-7] // @0F1A memory[stack[-7]:stack[-7] + 0x20] // @0F1E memory[stack[-7]:stack[-7] + 0x20] // } 0F11 5B JUMPDEST 0F12 50 POP 0F13 50 POP 0F14 83 DUP4 0F15 81 DUP2 0F16 03 SUB 0F17 82 DUP3 0F18 52 MSTORE 0F19 84 DUP5 0F1A 51 MLOAD 0F1B 81 DUP2 0F1C 52 MSTORE 0F1D 84 DUP5 0F1E 51 MLOAD 0F1F 60 PUSH1 0x20 0F21 91 SWAP2 0F22 82 DUP3 0F23 01 ADD 0F24 91 SWAP2 0F25 86 DUP7 0F26 01 ADD 0F27 90 SWAP1 0F28 80 DUP1 0F29 83 DUP4 0F2A 83 DUP4 0F2B 60 PUSH1 0x00 0F2D 5B JUMPDEST 0F2E 83 DUP4 0F2F 81 DUP2 0F30 10 LT 0F31 15 ISZERO 0F32 61 PUSH2 0x0f45 0F35 57 *JUMPI // Stack delta = +4 // Outputs[9] // { // @0F18 memory[stack[-4]:stack[-4] + 0x20] = stack[-3] - stack[-6] // @0F1C memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-7]:stack[-7] + 0x20] // @0F24 stack[-3] = 0x20 + stack[-3] // @0F27 stack[-2] = stack[-7] + 0x20 // @0F27 stack[-1] = memory[stack[-7]:stack[-7] + 0x20] // @0F28 stack[0] = memory[stack[-7]:stack[-7] + 0x20] // @0F29 stack[1] = 0x20 + stack[-3] // @0F2A stack[2] = stack[-7] + 0x20 // @0F2B stack[3] = 0x00 // } // Block ends with conditional jump to 0x0f45, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) label_0F36: // Incoming jump from 0x0F35, if not !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Incoming jump from 0x0F35, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0F36 stack[-2] // @0F37 stack[-1] // @0F39 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0F3A stack[-3] // } 0F36 81 DUP2 0F37 81 DUP2 0F38 01 ADD 0F39 51 MLOAD 0F3A 83 DUP4 0F3B 82 DUP3 0F3C 01 ADD 0F3D 52 MSTORE 0F3E 60 PUSH1 0x20 0F40 01 ADD 0F41 61 PUSH2 0x0f2d 0F44 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0F3D memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0F40 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0f2d label_0F45: // Incoming jump from 0x0F35, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Incoming jump from 0x0F35, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0F4A stack[-6] // @0F4A stack[-5] // @0F4C stack[-7] // } 0F45 5B JUMPDEST 0F46 50 POP 0F47 50 POP 0F48 50 POP 0F49 50 POP 0F4A 90 SWAP1 0F4B 50 POP 0F4C 90 SWAP1 0F4D 81 DUP2 0F4E 01 ADD 0F4F 90 SWAP1 0F50 60 PUSH1 0x1f 0F52 16 AND 0F53 80 DUP1 0F54 15 ISZERO 0F55 61 PUSH2 0x0f72 0F58 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0F4F stack[-7] = stack[-5] + stack[-7] // @0F52 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0f72, if !(0x1f & stack[-5]) label_0F59: // Incoming jump from 0x0F58, if not !(0x1f & stack[-5]) // Inputs[7] // { // @0F59 stack[-1] // @0F5A stack[-2] // @0F5D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0F74 stack[-7] // @0F7E memory[0x40:0x60] // @0F83 stack[-9] // @0F85 address(stack[-9]).code.length // } 0F59 80 DUP1 0F5A 82 DUP3 0F5B 03 SUB 0F5C 80 DUP1 0F5D 51 MLOAD 0F5E 60 PUSH1 0x01 0F60 83 DUP4 0F61 60 PUSH1 0x20 0F63 03 SUB 0F64 61 PUSH2 0x0100 0F67 0A EXP 0F68 03 SUB 0F69 19 NOT 0F6A 16 AND 0F6B 81 DUP2 0F6C 52 MSTORE 0F6D 60 PUSH1 0x20 0F6F 01 ADD 0F70 91 SWAP2 0F71 50 POP 0F72 5B JUMPDEST 0F73 50 POP 0F74 94 SWAP5 0F75 50 POP 0F76 50 POP 0F77 50 POP 0F78 50 POP 0F79 50 POP 0F7A 60 PUSH1 0x00 0F7C 60 PUSH1 0x40 0F7E 51 MLOAD 0F7F 80 DUP1 0F80 83 DUP4 0F81 03 SUB 0F82 81 DUP2 0F83 86 DUP7 0F84 80 DUP1 0F85 3B EXTCODESIZE 0F86 15 ISZERO 0F87 80 DUP1 0F88 15 ISZERO 0F89 61 PUSH2 0x0f91 0F8C 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @0F6C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0F74 stack[-7] = 0x20 + (stack[-2] - stack[-1]) // @0F7A stack[-6] = 0x00 // @0F7E stack[-5] = memory[0x40:0x60] // @0F81 stack[-4] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @0F82 stack[-3] = memory[0x40:0x60] // @0F83 stack[-2] = stack[-9] // @0F86 stack[-1] = !address(stack[-9]).code.length // } // Block ends with conditional jump to 0x0f91, if !!address(stack[-9]).code.length label_0F8D: // Incoming jump from 0x0F8C, if not !!address(stack[-9]).code.length // Incoming jump from 0x0F8C, if not !!address(stack[-9]).code.length // Inputs[1] { @0F90 memory[0x00:0x00] } 0F8D 60 PUSH1 0x00 0F8F 80 DUP1 0F90 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F90 revert(memory[0x00:0x00]); } // Block terminates label_0F91: // Incoming jump from 0x0F8C, if !!address(stack[-9]).code.length // Incoming jump from 0x0F8C, if !!address(stack[-9]).code.length // Inputs[8] // { // @0F93 msg.gas // @0F94 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0F94 memory[stack[-3]:stack[-3] + stack[-4]] // @0F94 stack[-5] // @0F94 stack[-2] // @0F94 stack[-4] // @0F94 stack[-6] // @0F94 stack[-3] // } 0F91 5B JUMPDEST 0F92 50 POP 0F93 5A GAS 0F94 FA STATICCALL 0F95 15 ISZERO 0F96 80 DUP1 0F97 15 ISZERO 0F98 61 PUSH2 0x0fa5 0F9B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0F94 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0F95 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0fa5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0F9C: // Incoming jump from 0x0F9B, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0F9C returndata.length // @0FA0 returndata[0x00:0x00 + returndata.length] // @0FA1 returndata.length // @0FA4 memory[0x00:0x00 + returndata.length] // } 0F9C 3D RETURNDATASIZE 0F9D 60 PUSH1 0x00 0F9F 80 DUP1 0FA0 3E RETURNDATACOPY 0FA1 3D RETURNDATASIZE 0FA2 60 PUSH1 0x00 0FA4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FA0 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0FA4 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0FA5: // Incoming jump from 0x0F9B, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0FAC memory[0x40:0x60] // @0FAD returndata.length // @0FB1 returndata[0x00:0x00 + returndata.length] // @0FB4 returndata.length // } 0FA5 5B JUMPDEST 0FA6 50 POP 0FA7 50 POP 0FA8 50 POP 0FA9 50 POP 0FAA 60 PUSH1 0x40 0FAC 51 MLOAD 0FAD 3D RETURNDATASIZE 0FAE 60 PUSH1 0x00 0FB0 82 DUP3 0FB1 3E RETURNDATACOPY 0FB2 60 PUSH1 0x1f 0FB4 3D RETURNDATASIZE 0FB5 90 SWAP1 0FB6 81 DUP2 0FB7 01 ADD 0FB8 60 PUSH1 0x1f 0FBA 19 NOT 0FBB 16 AND 0FBC 82 DUP3 0FBD 01 ADD 0FBE 60 PUSH1 0x40 0FC0 52 MSTORE 0FC1 60 PUSH1 0x20 0FC3 81 DUP2 0FC4 10 LT 0FC5 15 ISZERO 0FC6 61 PUSH2 0x0fce 0FC9 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @0FAC stack[-4] = memory[0x40:0x60] // @0FB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0FB5 stack[-3] = returndata.length // @0FC0 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // } // Block ends with conditional jump to 0x0fce, if !(returndata.length < 0x20) label_0FCA: // Incoming jump from 0x0FC9, if not !(returndata.length < 0x20) // Inputs[1] { @0FCD memory[0x00:0x00] } 0FCA 60 PUSH1 0x00 0FCC 80 DUP1 0FCD FD *REVERT // Stack delta = +0 // Outputs[1] { @0FCD revert(memory[0x00:0x00]); } // Block terminates label_0FCE: // Incoming jump from 0x0FC9, if !(returndata.length < 0x20) // Inputs[4] // { // @0FCF stack[-2] // @0FD0 stack[-1] // @0FD4 memory[stack[-2]:stack[-2] + 0x20] // @0FD7 memory[0x40:0x60] // } 0FCE 5B JUMPDEST 0FCF 81 DUP2 0FD0 01 ADD 0FD1 90 SWAP1 0FD2 80 DUP1 0FD3 80 DUP1 0FD4 51 MLOAD 0FD5 60 PUSH1 0x40 0FD7 51 MLOAD 0FD8 93 SWAP4 0FD9 92 SWAP3 0FDA 91 SWAP2 0FDB 90 SWAP1 0FDC 84 DUP5 0FDD 60 PUSH1 0x01 0FDF 60 PUSH1 0x20 0FE1 1B SHL 0FE2 82 DUP3 0FE3 11 GT 0FE4 15 ISZERO 0FE5 61 PUSH2 0x0fed 0FE8 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0FD8 stack[-2] = memory[0x40:0x60] // @0FD9 stack[-1] = stack[-2] + stack[-1] // @0FDA stack[0] = stack[-2] // @0FDB stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @0FDB stack[1] = stack[-2] // @0FDC stack[3] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0fed, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_0FE9: // Incoming jump from 0x0FE8, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0FEC memory[0x00:0x00] } 0FE9 60 PUSH1 0x00 0FEB 80 DUP1 0FEC FD *REVERT // Stack delta = +0 // Outputs[1] { @0FEC revert(memory[0x00:0x00]); } // Block terminates label_0FED: // Incoming jump from 0x0FE8, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[4] // { // @0FEE stack[-2] // @0FEE stack[-1] // @0FEF stack[-4] // @0FF6 stack[-5] // } 0FED 5B JUMPDEST 0FEE 90 SWAP1 0FEF 83 DUP4 0FF0 01 ADD 0FF1 90 SWAP1 0FF2 60 PUSH1 0x20 0FF4 82 DUP3 0FF5 01 ADD 0FF6 85 DUP6 0FF7 81 DUP2 0FF8 11 GT 0FF9 15 ISZERO 0FFA 61 PUSH2 0x1002 0FFD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0FF1 stack[-2] = stack[-4] + stack[-2] // @0FF1 stack[-1] = stack[-1] // @0FF5 stack[0] = stack[-4] + stack[-2] + 0x20 // } // Block ends with conditional jump to 0x1002, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_0FFE: // Incoming jump from 0x0FFD, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @1001 memory[0x00:0x00] } 0FFE 60 PUSH1 0x00 1000 80 DUP1 1001 FD *REVERT // Stack delta = +0 // Outputs[1] { @1001 revert(memory[0x00:0x00]); } // Block terminates label_1002: // Incoming jump from 0x0FFD, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[4] // { // @1003 stack[-3] // @1004 memory[stack[-3]:stack[-3] + 0x20] // @100C stack[-1] // @100F stack[-6] // } 1002 5B JUMPDEST 1003 82 DUP3 1004 51 MLOAD 1005 60 PUSH1 0x01 1007 60 PUSH1 0x20 1009 1B SHL 100A 81 DUP2 100B 11 GT 100C 82 DUP3 100D 82 DUP3 100E 01 ADD 100F 88 DUP9 1010 10 LT 1011 17 OR 1012 15 ISZERO 1013 61 PUSH2 0x101b 1016 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1004 stack[0] = memory[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x101b, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) label_1017: // Incoming jump from 0x1016, if not !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[1] { @101A memory[0x00:0x00] } 1017 60 PUSH1 0x00 1019 80 DUP1 101A FD *REVERT // Stack delta = +0 // Outputs[1] { @101A revert(memory[0x00:0x00]); } // Block terminates label_101B: // Incoming jump from 0x1016, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[4] // { // @101C stack[-3] // @101D stack[-1] // @101F stack[-4] // @1020 memory[stack[-4]:stack[-4] + 0x20] // } 101B 5B JUMPDEST 101C 82 DUP3 101D 52 MSTORE 101E 50 POP 101F 81 DUP2 1020 51 MLOAD 1021 60 PUSH1 0x20 1023 91 SWAP2 1024 82 DUP3 1025 01 ADD 1026 92 SWAP3 1027 90 SWAP1 1028 91 SWAP2 1029 01 ADD 102A 90 SWAP1 102B 80 DUP1 102C 83 DUP4 102D 83 DUP4 102E 60 PUSH1 0x00 1030 5B JUMPDEST 1031 83 DUP4 1032 81 DUP2 1033 10 LT 1034 15 ISZERO 1035 61 PUSH2 0x1048 1038 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @101D memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @1026 stack[-4] = 0x20 + stack[-3] // @102A stack[-2] = memory[stack[-4]:stack[-4] + 0x20] // @102A stack[-3] = 0x20 + stack[-4] // @102B stack[-1] = memory[stack[-4]:stack[-4] + 0x20] // @102C stack[0] = 0x20 + stack[-3] // @102D stack[1] = 0x20 + stack[-4] // @102E stack[2] = 0x00 // } // Block ends with conditional jump to 0x1048, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_1039: // Incoming jump from 0x1038, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1038, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @1039 stack[-2] // @103A stack[-1] // @103C memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @103D stack[-3] // } 1039 81 DUP2 103A 81 DUP2 103B 01 ADD 103C 51 MLOAD 103D 83 DUP4 103E 82 DUP3 103F 01 ADD 1040 52 MSTORE 1041 60 PUSH1 0x20 1043 01 ADD 1044 61 PUSH2 0x1030 1047 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1040 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1043 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1030 label_1048: // Incoming jump from 0x1038, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1038, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @104D stack[-5] // @104D stack[-6] // @104F stack[-7] // } 1048 5B JUMPDEST 1049 50 POP 104A 50 POP 104B 50 POP 104C 50 POP 104D 90 SWAP1 104E 50 POP 104F 90 SWAP1 1050 81 DUP2 1051 01 ADD 1052 90 SWAP1 1053 60 PUSH1 0x1f 1055 16 AND 1056 80 DUP1 1057 15 ISZERO 1058 61 PUSH2 0x1075 105B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1052 stack[-7] = stack[-5] + stack[-7] // @1055 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1075, if !(0x1f & stack[-5]) label_105C: // Incoming jump from 0x105B, if not !(0x1f & stack[-5]) // Inputs[11] // { // @105C stack[-1] // @105D stack[-2] // @1060 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1079 stack[-14] // @1088 memory[0x00:0x40] // @108A storage[keccak256(memory[0x00:0x40])] // @10B1 stack[-6] // @10B2 stack[-7] // @10B8 stack[-5] // @10BB stack[-4] // @10BD stack[-3] // } 105C 80 DUP1 105D 82 DUP3 105E 03 SUB 105F 80 DUP1 1060 51 MLOAD 1061 60 PUSH1 0x01 1063 83 DUP4 1064 60 PUSH1 0x20 1066 03 SUB 1067 61 PUSH2 0x0100 106A 0A EXP 106B 03 SUB 106C 19 NOT 106D 16 AND 106E 81 DUP2 106F 52 MSTORE 1070 60 PUSH1 0x20 1072 01 ADD 1073 91 SWAP2 1074 50 POP 1075 5B JUMPDEST 1076 50 POP 1077 60 PUSH1 0x00 1079 8D DUP14 107A 81 DUP2 107B 52 MSTORE 107C 60 PUSH1 0x16 107E 60 PUSH1 0x20 1080 90 SWAP1 1081 81 DUP2 1082 52 MSTORE 1083 60 PUSH1 0x40 1085 91 SWAP2 1086 82 DUP3 1087 90 SWAP1 1088 20 SHA3 1089 80 DUP1 108A 54 SLOAD 108B 60 PUSH1 0x02 108D 60 PUSH1 0x01 108F 82 DUP3 1090 16 AND 1091 15 ISZERO 1092 61 PUSH2 0x0100 1095 02 MUL 1096 60 PUSH1 0x00 1098 19 NOT 1099 01 ADD 109A 90 SWAP1 109B 91 SWAP2 109C 16 AND 109D 04 DIV 109E 60 PUSH1 0x1f 10A0 81 DUP2 10A1 01 ADD 10A2 83 DUP4 10A3 90 SWAP1 10A4 04 DIV 10A5 83 DUP4 10A6 02 MUL 10A7 85 DUP6 10A8 01 ADD 10A9 83 DUP4 10AA 01 ADD 10AB 90 SWAP1 10AC 93 SWAP4 10AD 52 MSTORE 10AE 82 DUP3 10AF 84 DUP5 10B0 52 MSTORE 10B1 96 SWAP7 10B2 97 SWAP8 10B3 50 POP 10B4 60 PUSH1 0x60 10B6 96 SWAP7 10B7 92 SWAP3 10B8 95 SWAP6 10B9 50 POP 10BA 91 SWAP2 10BB 93 SWAP4 10BC 50 POP 10BD 91 SWAP2 10BE 50 POP 10BF 83 DUP4 10C0 01 ADD 10C1 82 DUP3 10C2 82 DUP3 10C3 80 DUP1 10C4 15 ISZERO 10C5 61 PUSH2 0x110f 10C8 57 *JUMPI // Stack delta = +1 // Outputs[13] // { // @106F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @107B memory[0x00:0x20] = stack[-14] // @1082 memory[0x20:0x40] = 0x16 // @10AD memory[0x40:0x60] = 0x20 + 0x20 + (stack[-2] - stack[-1]) + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02 + 0x1f) / 0x20) // @10B0 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = (storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02 // @10B2 stack[-7] = stack[-6] // @10B6 stack[-6] = 0x60 // @10B8 stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @10BB stack[-4] = keccak256(memory[0x00:0x40]) // @10BD stack[-3] = (storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02 // @10C0 stack[-2] = 0x20 + (stack[-2] - stack[-1]) + 0x20 // @10C1 stack[-1] = keccak256(memory[0x00:0x40]) // @10C2 stack[0] = (storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x110f, if !((storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02) label_10C9: // Incoming jump from 0x10C8, if not !((storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02) // Incoming jump from 0x10C8, if not !((storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02) // Inputs[1] { @10C9 stack[-1] } 10C9 80 DUP1 10CA 60 PUSH1 0x1f 10CC 10 LT 10CD 61 PUSH2 0x10e4 10D0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10e4, if 0x1f < stack[-1] label_10D1: // Incoming jump from 0x10D0, if not 0x1f < stack[-1] // Inputs[4] // { // @10D5 stack[-2] // @10D6 storage[stack[-2]] // @10D9 stack[-3] // @10DB stack[-1] // } 10D1 61 PUSH2 0x0100 10D4 80 DUP1 10D5 83 DUP4 10D6 54 SLOAD 10D7 04 DIV 10D8 02 MUL 10D9 83 DUP4 10DA 52 MSTORE 10DB 91 SWAP2 10DC 60 PUSH1 0x20 10DE 01 ADD 10DF 91 SWAP2 10E0 61 PUSH2 0x110f 10E3 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @10DA memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @10DF stack[-1] = stack[-1] // @10DF stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x110f label_10E4: // Incoming jump from 0x10D0, if 0x1f < stack[-1] // Inputs[5] // { // @10E5 stack[-3] // @10E6 stack[-1] // @10E8 stack[-2] // @10F0 memory[0x00:0x20] // @10F4 storage[keccak256(memory[0x00:0x20])] // } 10E4 5B JUMPDEST 10E5 82 DUP3 10E6 01 ADD 10E7 91 SWAP2 10E8 90 SWAP1 10E9 60 PUSH1 0x00 10EB 52 MSTORE 10EC 60 PUSH1 0x20 10EE 60 PUSH1 0x00 10F0 20 SHA3 10F1 90 SWAP1 10F2 5B JUMPDEST 10F3 81 DUP2 10F4 54 SLOAD 10F5 81 DUP2 10F6 52 MSTORE 10F7 90 SWAP1 10F8 60 PUSH1 0x01 10FA 01 ADD 10FB 90 SWAP1 10FC 60 PUSH1 0x20 10FE 01 ADD 10FF 80 DUP1 1100 83 DUP4 1101 11 GT 1102 61 PUSH2 0x10f2 1105 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @10E7 stack[-3] = stack[-3] + stack[-1] // @10EB memory[0x00:0x20] = stack[-2] // @10F6 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @10FB stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @10FE stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x10f2, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1106: // Incoming jump from 0x1105, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1105, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1106 stack[-3] // @1107 stack[-1] // } 1106 82 DUP3 1107 90 SWAP1 1108 03 SUB 1109 60 PUSH1 0x1f 110B 16 AND 110C 82 DUP3 110D 01 ADD 110E 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @110E stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @110E stack[-1] = stack[-3] // } // Block continues label_110F: // Incoming jump from 0x10E3 // Incoming jump from 0x10C8, if !((storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02) // Incoming jump from 0x10C8, if !((storage[keccak256(memory[0x00:0x40])] & ~0x00 + 0x0100 * !(storage[keccak256(memory[0x00:0x40])] & 0x01)) / 0x02) // Incoming jump from 0x110E // Inputs[4] // { // @1115 stack[-7] // @1115 stack[-6] // @111A stack[-16] // @111B stack[-10] // } 110F 5B JUMPDEST 1110 50 POP 1111 50 POP 1112 50 POP 1113 50 POP 1114 50 POP 1115 90 SWAP1 1116 50 POP 1117 61 PUSH2 0x1120 111A 8A DUP11 111B 85 DUP6 111C 61 PUSH2 0x196a 111F 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @1115 stack[-7] = stack[-6] // @1117 stack[-6] = 0x1120 // @111A stack[-5] = stack[-16] // @111B stack[-4] = stack[-10] // } // Block ends with call to 0x196a, returns to 0x1120 label_1120: // Incoming return from call to 0x196A at 0x111F // Inputs[2] // { // @1124 stack[-4] // @1125 stack[-2] // } 1120 5B JUMPDEST 1121 61 PUSH2 0x112a 1124 84 DUP5 1125 83 DUP4 1126 61 PUSH2 0x198b 1129 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1121 stack[0] = 0x112a // @1124 stack[1] = stack[-4] // @1125 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x198b 112A 5B JUMPDEST 112B 61 PUSH2 0x1134 112E 84 DUP5 112F 82 DUP3 1130 61 PUSH2 0x19ee 1133 56 *JUMP 1134 5B JUMPDEST 1135 60 PUSH1 0x40 1137 80 DUP1 1138 51 MLOAD 1139 60 PUSH1 0x01 113B 60 PUSH1 0x01 113D 60 PUSH1 0xa0 113F 1B SHL 1140 03 SUB 1141 8C DUP13 1142 16 AND 1143 81 DUP2 1144 52 MSTORE 1145 60 PUSH1 0x20 1147 81 DUP2 1148 01 ADD 1149 8B DUP12 114A 90 SWAP1 114B 52 MSTORE 114C 80 DUP1 114D 82 DUP3 114E 01 ADD 114F 86 DUP7 1150 90 SWAP1 1151 52 MSTORE 1152 90 SWAP1 1153 51 MLOAD 1154 7F PUSH32 0xce98476f2a1c16f3466ad65b59759356e098b8f100a498ebb025280fcc6759f6 1175 91 SWAP2 1176 81 DUP2 1177 90 SWAP1 1178 03 SUB 1179 60 PUSH1 0x60 117B 01 ADD 117C 90 SWAP1 117D A1 LOG1 117E 50 POP 117F 50 POP 1180 50 POP 1181 50 POP 1182 50 POP 1183 50 POP 1184 50 POP 1185 50 POP 1186 50 POP 1187 50 POP 1188 56 *JUMP label_1189: // Incoming jump from 0x04CB 1189 5B JUMPDEST 118A 60 PUSH1 0x00 118C 61 PUSH2 0x1193 118F 61 PUSH2 0x095a 1192 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @118A stack[0] = 0x00 // @118C stack[1] = 0x1193 // } // Block ends with call to 0x095a, returns to 0x1193 label_1193: // Incoming return from call to 0x095A at 0x1192 // Inputs[2] // { // @1194 stack[-3] // @1195 stack[-1] // } 1193 5B JUMPDEST 1194 82 DUP3 1195 10 LT 1196 61 PUSH2 0x11d0 1199 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11d0, if stack[-3] < stack[-1] label_119A: // Incoming jump from 0x1199, if not stack[-3] < stack[-1] // Inputs[3] // { // @119C memory[0x40:0x60] // @11CA memory[0x40:0x60] // @11CF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 119A 60 PUSH1 0x40 119C 51 MLOAD 119D 62 PUSH3 0x461bcd 11A1 60 PUSH1 0xe5 11A3 1B SHL 11A4 81 DUP2 11A5 52 MSTORE 11A6 60 PUSH1 0x04 11A8 01 ADD 11A9 80 DUP1 11AA 80 DUP1 11AB 60 PUSH1 0x20 11AD 01 ADD 11AE 82 DUP3 11AF 81 DUP2 11B0 03 SUB 11B1 82 DUP3 11B2 52 MSTORE 11B3 60 PUSH1 0x2c 11B5 81 DUP2 11B6 52 MSTORE 11B7 60 PUSH1 0x20 11B9 01 ADD 11BA 80 DUP1 11BB 61 PUSH2 0x2444 11BE 60 PUSH1 0x2c 11C0 91 SWAP2 11C1 39 CODECOPY 11C2 60 PUSH1 0x40 11C4 01 ADD 11C5 91 SWAP2 11C6 50 POP 11C7 50 POP 11C8 60 PUSH1 0x40 11CA 51 MLOAD 11CB 80 DUP1 11CC 91 SWAP2 11CD 03 SUB 11CE 90 SWAP1 11CF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @11A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11B2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @11B6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @11C1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x2444:0x2470] // @11CF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_11D0: // Incoming jump from 0x1199, if stack[-3] < stack[-1] // Inputs[2] // { // @11D3 stack[-2] // @11D5 storage[0x07] // } 11D0 5B JUMPDEST 11D1 60 PUSH1 0x07 11D3 82 DUP3 11D4 81 DUP2 11D5 54 SLOAD 11D6 81 DUP2 11D7 10 LT 11D8 61 PUSH2 0x11dd 11DB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @11D1 stack[0] = 0x07 // @11D3 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x11dd, if stack[-2] < storage[0x07] label_11DC: // Incoming jump from 0x11DB, if not stack[-2] < storage[0x07] 11DC FE *ASSERT // Stack delta = +0 // Outputs[1] { @11DC assert(); } // Block terminates label_11DD: // Incoming jump from 0x11DB, if stack[-2] < storage[0x07] // Inputs[7] // { // @11DE stack[-2] // @11DE stack[-1] // @11E6 memory[0x00:0x20] // @11E8 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @11E9 stack[-3] // @11EB stack[-5] // @11EC stack[-4] // } 11DD 5B JUMPDEST 11DE 90 SWAP1 11DF 60 PUSH1 0x00 11E1 52 MSTORE 11E2 60 PUSH1 0x20 11E4 60 PUSH1 0x00 11E6 20 SHA3 11E7 01 ADD 11E8 54 SLOAD 11E9 90 SWAP1 11EA 50 POP 11EB 91 SWAP2 11EC 90 SWAP1 11ED 50 POP 11EE 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @11E1 memory[0x00:0x20] = stack[-2] // @11EB stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_11EF: // Incoming call from 0x04D3, returns to 0x0307 // Inputs[5] // { // @11F2 storage[0x12] // @11F6 memory[0x40:0x60] // @1201 msg.sender // @1208 memory[0x40:0x60] // @1233 address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // } 11EF 5B JUMPDEST 11F0 60 PUSH1 0x12 11F2 54 SLOAD 11F3 60 PUSH1 0x40 11F5 80 DUP1 11F6 51 MLOAD 11F7 63 PUSH4 0x71be737d 11FC 60 PUSH1 0xe1 11FE 1B SHL 11FF 81 DUP2 1200 52 MSTORE 1201 33 CALLER 1202 60 PUSH1 0x04 1204 82 DUP3 1205 01 ADD 1206 52 MSTORE 1207 90 SWAP1 1208 51 MLOAD 1209 60 PUSH1 0x01 120B 60 PUSH1 0x01 120D 60 PUSH1 0xa0 120F 1B SHL 1210 03 SUB 1211 90 SWAP1 1212 92 SWAP3 1213 16 AND 1214 91 SWAP2 1215 60 PUSH1 0x00 1217 91 SWAP2 1218 83 DUP4 1219 91 SWAP2 121A 63 PUSH4 0xe37ce6fa 121F 91 SWAP2 1220 60 PUSH1 0x24 1222 80 DUP1 1223 82 DUP3 1224 01 ADD 1225 92 SWAP3 1226 60 PUSH1 0x20 1228 92 SWAP3 1229 90 SWAP1 122A 91 SWAP2 122B 90 SWAP1 122C 82 DUP3 122D 90 SWAP1 122E 03 SUB 122F 01 ADD 1230 81 DUP2 1231 86 DUP7 1232 80 DUP1 1233 3B EXTCODESIZE 1234 15 ISZERO 1235 80 DUP1 1236 15 ISZERO 1237 61 PUSH2 0x123f 123A 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @1200 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x71be737d << 0xe1 // @1206 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @1214 stack[0] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @1217 stack[1] = 0x00 // @1219 stack[2] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @121F stack[3] = 0xe37ce6fa // @1225 stack[4] = memory[0x40:0x60] + 0x24 // @1228 stack[5] = 0x20 // @122A stack[6] = memory[0x40:0x60] // @122F stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @1230 stack[8] = memory[0x40:0x60] // @1231 stack[9] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @1234 stack[10] = !address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x123f, if !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length label_123B: // Incoming jump from 0x123A, if not !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @123E memory[0x00:0x00] } 123B 60 PUSH1 0x00 123D 80 DUP1 123E FD *REVERT // Stack delta = +0 // Outputs[1] { @123E revert(memory[0x00:0x00]); } // Block terminates label_123F: // Incoming jump from 0x123A, if !!address(storage[0x12] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @1241 msg.gas // @1242 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1242 stack[-5] // @1242 stack[-6] // @1242 stack[-2] // @1242 stack[-3] // @1242 stack[-4] // @1242 memory[stack[-3]:stack[-3] + stack[-4]] // } 123F 5B JUMPDEST 1240 50 POP 1241 5A GAS 1242 FA STATICCALL 1243 15 ISZERO 1244 80 DUP1 1245 15 ISZERO 1246 61 PUSH2 0x1253 1249 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1242 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1243 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1253, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_124A: // Incoming jump from 0x1249, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @124A returndata.length // @124E returndata[0x00:0x00 + returndata.length] // @124F returndata.length // @1252 memory[0x00:0x00 + returndata.length] // } 124A 3D RETURNDATASIZE 124B 60 PUSH1 0x00 124D 80 DUP1 124E 3E RETURNDATACOPY 124F 3D RETURNDATASIZE 1250 60 PUSH1 0x00 1252 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @124E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1252 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1253: // Incoming jump from 0x1249, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @125A memory[0x40:0x60] // @125B returndata.length // } 1253 5B JUMPDEST 1254 50 POP 1255 50 POP 1256 50 POP 1257 50 POP 1258 60 PUSH1 0x40 125A 51 MLOAD 125B 3D RETURNDATASIZE 125C 60 PUSH1 0x20 125E 81 DUP2 125F 10 LT 1260 15 ISZERO 1261 61 PUSH2 0x1269 1264 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @125A stack[-4] = memory[0x40:0x60] // @125B stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1269, if !(returndata.length < 0x20) label_1265: // Incoming jump from 0x1264, if not !(returndata.length < 0x20) // Inputs[1] { @1268 memory[0x00:0x00] } 1265 60 PUSH1 0x00 1267 80 DUP1 1268 FD *REVERT // Stack delta = +0 // Outputs[1] { @1268 revert(memory[0x00:0x00]); } // Block terminates label_1269: // Incoming jump from 0x1264, if !(returndata.length < 0x20) // Inputs[3] // { // @126B stack[-2] // @126B memory[stack[-2]:stack[-2] + 0x20] // @126C stack[-3] // } 1269 5B JUMPDEST 126A 50 POP 126B 51 MLOAD 126C 90 SWAP1 126D 50 POP 126E 60 PUSH1 0x01 1270 81 DUP2 1271 15 ISZERO 1272 15 ISZERO 1273 14 EQ 1274 61 PUSH2 0x127c 1277 57 *JUMPI // Stack delta = -2 // Outputs[1] { @126C stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x127c, if !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 label_1278: // Incoming jump from 0x1277, if not !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 // Inputs[1] { @127B memory[0x00:0x00] } 1278 60 PUSH1 0x00 127A 80 DUP1 127B FD *REVERT // Stack delta = +0 // Outputs[1] { @127B revert(memory[0x00:0x00]); } // Block terminates label_127C: // Incoming jump from 0x1277, if !!memory[stack[-2]:stack[-2] + 0x20] == 0x01 // Inputs[2] // { // @1282 storage[0x0f] // @128C stack[-3] // } 127C 5B JUMPDEST 127D 50 POP 127E 50 POP 127F 60 PUSH1 0x0f 1281 80 DUP1 1282 54 SLOAD 1283 60 PUSH1 0xff 1285 19 NOT 1286 16 AND 1287 60 PUSH1 0x01 1289 17 OR 128A 90 SWAP1 128B 55 SSTORE 128C 56 *JUMP // Stack delta = -3 // Outputs[1] { @128B storage[0x0f] = 0x01 | (~0xff & storage[0x0f]) } // Block ends with unconditional jump to stack[-3] label_128D: // Incoming jump from 0x04F0 // Incoming call from 0x082A, returns to 0x082B // Incoming call from 0x1AB5, returns to 0x1AB6 // Incoming call from 0x18EA, returns to 0x18EB // Inputs[3] // { // @1290 stack[-1] // @129B memory[0x00:0x40] // @129C storage[keccak256(memory[0x00:0x40])] // } 128D 5B JUMPDEST 128E 60 PUSH1 0x00 1290 81 DUP2 1291 81 DUP2 1292 52 MSTORE 1293 60 PUSH1 0x01 1295 60 PUSH1 0x20 1297 52 MSTORE 1298 60 PUSH1 0x40 129A 81 DUP2 129B 20 SHA3 129C 54 SLOAD 129D 60 PUSH1 0x01 129F 60 PUSH1 0x01 12A1 60 PUSH1 0xa0 12A3 1B SHL 12A4 03 SUB 12A5 16 AND 12A6 80 DUP1 12A7 61 PUSH2 0x12e1 12AA 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @128E stack[0] = 0x00 // @1292 memory[0x00:0x20] = stack[-1] // @1297 memory[0x20:0x40] = 0x01 // @12A5 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x12e1, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_12AB: // Incoming jump from 0x12AA, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @12AD memory[0x40:0x60] // @12DB memory[0x40:0x60] // @12E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12AB 60 PUSH1 0x40 12AD 51 MLOAD 12AE 62 PUSH3 0x461bcd 12B2 60 PUSH1 0xe5 12B4 1B SHL 12B5 81 DUP2 12B6 52 MSTORE 12B7 60 PUSH1 0x04 12B9 01 ADD 12BA 80 DUP1 12BB 80 DUP1 12BC 60 PUSH1 0x20 12BE 01 ADD 12BF 82 DUP3 12C0 81 DUP2 12C1 03 SUB 12C2 82 DUP3 12C3 52 MSTORE 12C4 60 PUSH1 0x29 12C6 81 DUP2 12C7 52 MSTORE 12C8 60 PUSH1 0x20 12CA 01 ADD 12CB 80 DUP1 12CC 61 PUSH2 0x2319 12CF 60 PUSH1 0x29 12D1 91 SWAP2 12D2 39 CODECOPY 12D3 60 PUSH1 0x40 12D5 01 ADD 12D6 91 SWAP2 12D7 50 POP 12D8 50 POP 12D9 60 PUSH1 0x40 12DB 51 MLOAD 12DC 80 DUP1 12DD 91 SWAP2 12DE 03 SUB 12DF 90 SWAP1 12E0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @12B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12C3 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @12C7 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @12D2 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x2319:0x2342] // @12E0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_12E1: // Incoming return from call to 0x1966 at 0x13EB // Incoming jump from 0x12AA, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @12E2 stack[-4] // @12E2 stack[-1] // @12E3 stack[-3] // } 12E1 5B JUMPDEST 12E2 92 SWAP3 12E3 91 SWAP2 12E4 50 POP 12E5 50 POP 12E6 56 *JUMP // Stack delta = -3 // Outputs[1] { @12E2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_12E7: // Incoming call from 0x04F8, returns to 0x02BF // Inputs[2] // { // @12EA storage[0x13] // @12F4 stack[-1] // } 12E7 5B JUMPDEST 12E8 60 PUSH1 0x13 12EA 54 SLOAD 12EB 60 PUSH1 0x01 12ED 60 PUSH1 0x01 12EF 60 PUSH1 0xa0 12F1 1B SHL 12F2 03 SUB 12F3 16 AND 12F4 81 DUP2 12F5 56 *JUMP // Stack delta = +1 // Outputs[1] { @12F3 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x13] } // Block ends with unconditional jump to stack[-1] label_12F6: // Incoming call from 0x0500, returns to 0x022D // Inputs[2] // { // @12FA storage[0x10] // @12FE memory[0x40:0x60] // } 12F6 5B JUMPDEST 12F7 60 PUSH1 0x10 12F9 80 DUP1 12FA 54 SLOAD 12FB 60 PUSH1 0x40 12FD 80 DUP1 12FE 51 MLOAD 12FF 60 PUSH1 0x20 1301 60 PUSH1 0x02 1303 60 PUSH1 0x01 1305 85 DUP6 1306 16 AND 1307 15 ISZERO 1308 61 PUSH2 0x0100 130B 02 MUL 130C 60 PUSH1 0x00 130E 19 NOT 130F 01 ADD 1310 90 SWAP1 1311 94 SWAP5 1312 16 AND 1313 93 SWAP4 1314 90 SWAP1 1315 93 SWAP4 1316 04 DIV 1317 60 PUSH1 0x1f 1319 81 DUP2 131A 01 ADD 131B 84 DUP5 131C 90 SWAP1 131D 04 DIV 131E 84 DUP5 131F 02 MUL 1320 82 DUP3 1321 01 ADD 1322 84 DUP5 1323 01 ADD 1324 90 SWAP1 1325 92 SWAP3 1326 52 MSTORE 1327 81 DUP2 1328 81 DUP2 1329 52 MSTORE 132A 92 SWAP3 132B 91 SWAP2 132C 83 DUP4 132D 01 ADD 132E 82 DUP3 132F 82 DUP3 1330 80 DUP1 1331 15 ISZERO 1332 61 PUSH2 0x137c 1335 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1325 stack[2] = (storage[0x10] & ~0x00 + 0x0100 * !(storage[0x10] & 0x01)) / 0x02 // @1326 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x10] & ~0x00 + 0x0100 * !(storage[0x10] & 0x01)) / 0x02 + 0x1f) / 0x20) // @1329 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x10] & ~0x00 + 0x0100 * !(storage[0x10] & 0x01)) / 0x02 // @132A stack[0] = memory[0x40:0x60] // @132B stack[1] = 0x10 // @132D stack[3] = memory[0x40:0x60] + 0x20 // @132E stack[4] = 0x10 // @132F stack[5] = (storage[0x10] & ~0x00 + 0x0100 * !(storage[0x10] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x137c, if !((storage[0x10] & ~0x00 + 0x0100 * !(storage[0x10] & 0x01)) / 0x02) label_1336: // Incoming jump from 0x1335, if not !((storage[0x10] & ~0x00 + 0x0100 * !(storage[0x10] & 0x01)) / 0x02) // Inputs[1] { @1336 stack[-1] } 1336 80 DUP1 1337 60 PUSH1 0x1f 1339 10 LT 133A 61 PUSH2 0x1351 133D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1351, if 0x1f < stack[-1] label_133E: // Incoming jump from 0x133D, if not 0x1f < stack[-1] // Inputs[4] // { // @1342 stack[-2] // @1343 storage[stack[-2]] // @1346 stack[-3] // @1348 stack[-1] // } 133E 61 PUSH2 0x0100 1341 80 DUP1 1342 83 DUP4 1343 54 SLOAD 1344 04 DIV 1345 02 MUL 1346 83 DUP4 1347 52 MSTORE 1348 91 SWAP2 1349 60 PUSH1 0x20 134B 01 ADD 134C 91 SWAP2 134D 61 PUSH2 0x137c 1350 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1347 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @134C stack[-1] = stack[-1] // @134C stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x137c label_1351: // Incoming jump from 0x133D, if 0x1f < stack[-1] // Incoming jump from 0x149A, if 0x1f < stack[-1] // Incoming jump from 0x181F, if 0x1f < stack[-1] // Inputs[5] // { // @1352 stack[-3] // @1353 stack[-1] // @1355 stack[-2] // @135D memory[0x00:0x20] // @1361 storage[keccak256(memory[0x00:0x20])] // } 1351 5B JUMPDEST 1352 82 DUP3 1353 01 ADD 1354 91 SWAP2 1355 90 SWAP1 1356 60 PUSH1 0x00 1358 52 MSTORE 1359 60 PUSH1 0x20 135B 60 PUSH1 0x00 135D 20 SHA3 135E 90 SWAP1 135F 5B JUMPDEST 1360 81 DUP2 1361 54 SLOAD 1362 81 DUP2 1363 52 MSTORE 1364 90 SWAP1 1365 60 PUSH1 0x01 1367 01 ADD 1368 90 SWAP1 1369 60 PUSH1 0x20 136B 01 ADD 136C 80 DUP1 136D 83 DUP4 136E 11 GT 136F 61 PUSH2 0x135f 1372 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1354 stack[-3] = stack[-3] + stack[-1] // @1358 memory[0x00:0x20] = stack[-2] // @1363 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1368 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @136B stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x135f, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1373: // Incoming jump from 0x1372, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1372, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1373 stack[-3] // @1374 stack[-1] // } 1373 82 DUP3 1374 90 SWAP1 1375 03 SUB 1376 60 PUSH1 0x1f 1378 16 AND 1379 82 DUP3 137A 01 ADD 137B 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @137B stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @137B stack[-1] = stack[-3] // } // Block continues label_137C: // Incoming jump from 0x137B // Incoming jump from 0x1817, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x14AD // Incoming jump from 0x1492, if !((storage[0x11] & ~0x00 + 0x0100 * !(storage[0x11] & 0x01)) / 0x02) // Incoming jump from 0x1832 // Incoming jump from 0x1335, if !((storage[0x10] & ~0x00 + 0x0100 * !(storage[0x10] & 0x01)) / 0x02) // Incoming jump from 0x1350 // Inputs[1] { @1382 stack[-7] } 137C 5B JUMPDEST 137D 50 POP 137E 50 POP 137F 50 POP 1380 50 POP 1381 50 POP 1382 81 DUP2 1383 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_1384: // Incoming jump from 0x0526 // Incoming jump from 0x0AF3 // Inputs[1] { @138F stack[-1] } 1384 5B JUMPDEST 1385 60 PUSH1 0x00 1387 60 PUSH1 0x01 1389 60 PUSH1 0x01 138B 60 PUSH1 0xa0 138D 1B SHL 138E 03 SUB 138F 82 DUP3 1390 16 AND 1391 61 PUSH2 0x13cb 1394 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1385 stack[0] = 0x00 } // Block ends with conditional jump to 0x13cb, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1395: // Incoming jump from 0x1394, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1397 memory[0x40:0x60] // @13C5 memory[0x40:0x60] // @13CA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1395 60 PUSH1 0x40 1397 51 MLOAD 1398 62 PUSH3 0x461bcd 139C 60 PUSH1 0xe5 139E 1B SHL 139F 81 DUP2 13A0 52 MSTORE 13A1 60 PUSH1 0x04 13A3 01 ADD 13A4 80 DUP1 13A5 80 DUP1 13A6 60 PUSH1 0x20 13A8 01 ADD 13A9 82 DUP3 13AA 81 DUP2 13AB 03 SUB 13AC 82 DUP3 13AD 52 MSTORE 13AE 60 PUSH1 0x2a 13B0 81 DUP2 13B1 52 MSTORE 13B2 60 PUSH1 0x20 13B4 01 ADD 13B5 80 DUP1 13B6 61 PUSH2 0x22ef 13B9 60 PUSH1 0x2a 13BB 91 SWAP2 13BC 39 CODECOPY 13BD 60 PUSH1 0x40 13BF 01 ADD 13C0 91 SWAP2 13C1 50 POP 13C2 50 POP 13C3 60 PUSH1 0x40 13C5 51 MLOAD 13C6 80 DUP1 13C7 91 SWAP2 13C8 03 SUB 13C9 90 SWAP1 13CA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @13A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13AD memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @13B1 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2a // @13BC memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2a] = code[0x22ef:0x2319] // @13CA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_13CB: // Incoming jump from 0x1394, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @13D4 stack[-2] // @13E3 memory[0x00:0x40] // } 13CB 5B JUMPDEST 13CC 60 PUSH1 0x01 13CE 60 PUSH1 0x01 13D0 60 PUSH1 0xa0 13D2 1B SHL 13D3 03 SUB 13D4 82 DUP3 13D5 16 AND 13D6 60 PUSH1 0x00 13D8 90 SWAP1 13D9 81 DUP2 13DA 52 MSTORE 13DB 60 PUSH1 0x03 13DD 60 PUSH1 0x20 13DF 52 MSTORE 13E0 60 PUSH1 0x40 13E2 90 SWAP1 13E3 20 SHA3 13E4 61 PUSH2 0x12e1 13E7 90 SWAP1 13E8 61 PUSH2 0x1966 13EB 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @13DA memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @13DF memory[0x20:0x40] = 0x03 // @13E7 stack[0] = 0x12e1 // @13E7 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x1966, returns to 0x12E1 label_13EC: // Incoming call from 0x052E, returns to 0x0326 // Inputs[2] // { // @13EF storage[0x0e] // @13F0 stack[-1] // } 13EC 5B JUMPDEST 13ED 60 PUSH1 0x0e 13EF 54 SLOAD 13F0 81 DUP2 13F1 56 *JUMP // Stack delta = +1 // Outputs[1] { @13EF stack[0] = storage[0x0e] } // Block ends with unconditional jump to stack[-1] label_13F2: // Incoming call from 0x0536, returns to 0x022D // Inputs[2] // { // @13F6 storage[0x0a] // @13FA memory[0x40:0x60] // } 13F2 5B JUMPDEST 13F3 60 PUSH1 0x0a 13F5 80 DUP1 13F6 54 SLOAD 13F7 60 PUSH1 0x40 13F9 80 DUP1 13FA 51 MLOAD 13FB 60 PUSH1 0x20 13FD 60 PUSH1 0x1f 13FF 60 PUSH1 0x02 1401 60 PUSH1 0x00 1403 19 NOT 1404 61 PUSH2 0x0100 1407 60 PUSH1 0x01 1409 88 DUP9 140A 16 AND 140B 15 ISZERO 140C 02 MUL 140D 01 ADD 140E 90 SWAP1 140F 95 SWAP6 1410 16 AND 1411 94 SWAP5 1412 90 SWAP1 1413 94 SWAP5 1414 04 DIV 1415 93 SWAP4 1416 84 DUP5 1417 01 ADD 1418 81 DUP2 1419 90 SWAP1 141A 04 DIV 141B 81 DUP2 141C 02 MUL 141D 82 DUP3 141E 01 ADD 141F 81 DUP2 1420 01 ADD 1421 90 SWAP1 1422 92 SWAP3 1423 52 MSTORE 1424 82 DUP3 1425 81 DUP2 1426 52 MSTORE 1427 60 PUSH1 0x60 1429 93 SWAP4 142A 90 SWAP1 142B 92 SWAP3 142C 90 SWAP1 142D 91 SWAP2 142E 83 DUP4 142F 01 ADD 1430 82 DUP3 1431 82 DUP3 1432 80 DUP1 1433 15 ISZERO 1434 61 PUSH2 0x07b3 1437 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1423 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @1426 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02 // @1429 stack[0] = 0x60 // @142B stack[1] = memory[0x40:0x60] // @142C stack[3] = (storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02 // @142D stack[2] = 0x0a // @142F stack[4] = memory[0x40:0x60] + 0x20 // @1430 stack[5] = 0x0a // @1431 stack[6] = (storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x07b3, if !((storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02) label_1438: // Incoming jump from 0x1437, if not !((storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @1438 stack[-1] } 1438 80 DUP1 1439 60 PUSH1 0x1f 143B 10 LT 143C 61 PUSH2 0x0788 143F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0788, if 0x1f < stack[-1] label_1440: // Incoming jump from 0x143F, if not 0x1f < stack[-1] // Inputs[4] // { // @1444 stack[-2] // @1445 storage[stack[-2]] // @1448 stack[-3] // @144A stack[-1] // } 1440 61 PUSH2 0x0100 1443 80 DUP1 1444 83 DUP4 1445 54 SLOAD 1446 04 DIV 1447 02 MUL 1448 83 DUP4 1449 52 MSTORE 144A 91 SWAP2 144B 60 PUSH1 0x20 144D 01 ADD 144E 91 SWAP2 144F 61 PUSH2 0x07b3 1452 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1449 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @144E stack[-1] = stack[-1] // @144E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07b3 label_1453: // Incoming call from 0x053E, returns to 0x022D // Inputs[2] // { // @1457 storage[0x11] // @145B memory[0x40:0x60] // } 1453 5B JUMPDEST 1454 60 PUSH1 0x11 1456 80 DUP1 1457 54 SLOAD 1458 60 PUSH1 0x40 145A 80 DUP1 145B 51 MLOAD 145C 60 PUSH1 0x20 145E 60 PUSH1 0x02 1460 60 PUSH1 0x01 1462 85 DUP6 1463 16 AND 1464 15 ISZERO 1465 61 PUSH2 0x0100 1468 02 MUL 1469 60 PUSH1 0x00 146B 19 NOT 146C 01 ADD 146D 90 SWAP1 146E 94 SWAP5 146F 16 AND 1470 93 SWAP4 1471 90 SWAP1 1472 93 SWAP4 1473 04 DIV 1474 60 PUSH1 0x1f 1476 81 DUP2 1477 01 ADD 1478 84 DUP5 1479 90 SWAP1 147A 04 DIV 147B 84 DUP5 147C 02 MUL 147D 82 DUP3 147E 01 ADD 147F 84 DUP5 1480 01 ADD 1481 90 SWAP1 1482 92 SWAP3 1483 52 MSTORE 1484 81 DUP2 1485 81 DUP2 1486 52 MSTORE 1487 92 SWAP3 1488 91 SWAP2 1489 83 DUP4 148A 01 ADD 148B 82 DUP3 148C 82 DUP3 148D 80 DUP1 148E 15 ISZERO 148F 61 PUSH2 0x137c 1492 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1482 stack[2] = (storage[0x11] & ~0x00 + 0x0100 * !(storage[0x11] & 0x01)) / 0x02 // @1483 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x11] & ~0x00 + 0x0100 * !(storage[0x11] & 0x01)) / 0x02 + 0x1f) / 0x20) // @1486 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x11] & ~0x00 + 0x0100 * !(storage[0x11] & 0x01)) / 0x02 // @1487 stack[0] = memory[0x40:0x60] // @1488 stack[1] = 0x11 // @148A stack[3] = memory[0x40:0x60] + 0x20 // @148B stack[4] = 0x11 // @148C stack[5] = (storage[0x11] & ~0x00 + 0x0100 * !(storage[0x11] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x137c, if !((storage[0x11] & ~0x00 + 0x0100 * !(storage[0x11] & 0x01)) / 0x02) label_1493: // Incoming jump from 0x1492, if not !((storage[0x11] & ~0x00 + 0x0100 * !(storage[0x11] & 0x01)) / 0x02) // Inputs[1] { @1493 stack[-1] } 1493 80 DUP1 1494 60 PUSH1 0x1f 1496 10 LT 1497 61 PUSH2 0x1351 149A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1351, if 0x1f < stack[-1] label_149B: // Incoming jump from 0x149A, if not 0x1f < stack[-1] // Inputs[4] // { // @149F stack[-2] // @14A0 storage[stack[-2]] // @14A3 stack[-3] // @14A5 stack[-1] // } 149B 61 PUSH2 0x0100 149E 80 DUP1 149F 83 DUP4 14A0 54 SLOAD 14A1 04 DIV 14A2 02 MUL 14A3 83 DUP4 14A4 52 MSTORE 14A5 91 SWAP2 14A6 60 PUSH1 0x20 14A8 01 ADD 14A9 91 SWAP2 14AA 61 PUSH2 0x137c 14AD 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @14A4 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @14A9 stack[-1] = stack[-1] // @14A9 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x137c label_14AE: // Incoming jump from 0x056C 14AE 5B JUMPDEST 14AF 61 PUSH2 0x14b6 14B2 61 PUSH2 0x1896 14B5 56 *JUMP // Stack delta = +1 // Outputs[1] { @14AF stack[0] = 0x14b6 } // Block ends with call to 0x1896, returns to 0x14B6 label_14B6: // Incoming return from call to 0x1896 at 0x14B5 // Inputs[2] // { // @14BF stack[-1] // @14C0 stack[-3] // } 14B6 5B JUMPDEST 14B7 60 PUSH1 0x01 14B9 60 PUSH1 0x01 14BB 60 PUSH1 0xa0 14BD 1B SHL 14BE 03 SUB 14BF 16 AND 14C0 82 DUP3 14C1 60 PUSH1 0x01 14C3 60 PUSH1 0x01 14C5 60 PUSH1 0xa0 14C7 1B SHL 14C8 03 SUB 14C9 16 AND 14CA 14 EQ 14CB 15 ISZERO 14CC 61 PUSH2 0x151c 14CF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x151c, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_14D0: // Incoming jump from 0x14CF, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @14D3 memory[0x40:0x60] // @1512 memory[0x40:0x60] // @151B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 14D0 60 PUSH1 0x40 14D2 80 DUP1 14D3 51 MLOAD 14D4 62 PUSH3 0x461bcd 14D8 60 PUSH1 0xe5 14DA 1B SHL 14DB 81 DUP2 14DC 52 MSTORE 14DD 60 PUSH1 0x20 14DF 60 PUSH1 0x04 14E1 82 DUP3 14E2 01 ADD 14E3 52 MSTORE 14E4 60 PUSH1 0x19 14E6 60 PUSH1 0x24 14E8 82 DUP3 14E9 01 ADD 14EA 52 MSTORE 14EB 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 150C 60 PUSH1 0x44 150E 82 DUP3 150F 01 ADD 1510 52 MSTORE 1511 90 SWAP1 1512 51 MLOAD 1513 90 SWAP1 1514 81 DUP2 1515 90 SWAP1 1516 03 SUB 1517 60 PUSH1 0x64 1519 01 ADD 151A 90 SWAP1 151B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @14DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14E3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14EA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @1510 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @151B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_151C: // Incoming jump from 0x14CF, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @151D stack[-1] } 151C 5B JUMPDEST 151D 80 DUP1 151E 60 PUSH1 0x04 1520 60 PUSH1 0x00 1522 61 PUSH2 0x1529 1525 61 PUSH2 0x1896 1528 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @151D stack[0] = stack[-1] // @151E stack[1] = 0x04 // @1520 stack[2] = 0x00 // @1522 stack[3] = 0x1529 // } // Block ends with call to 0x1896, returns to 0x1529 label_1529: // Incoming return from call to 0x1896 at 0x1528 // Inputs[8] // { // @1532 stack[-1] // @1535 stack[-2] // @153C stack[-3] // @1549 memory[0x00:0x00 + 0x40 + stack[-2]] // @154B stack[-6] // @1555 memory[0x00:0x40] // @1557 storage[keccak256(memory[0x00:0x40])] // @155C stack[-4] // } 1529 5B JUMPDEST 152A 60 PUSH1 0x01 152C 60 PUSH1 0x01 152E 60 PUSH1 0xa0 1530 1B SHL 1531 03 SUB 1532 90 SWAP1 1533 81 DUP2 1534 16 AND 1535 82 DUP3 1536 52 MSTORE 1537 60 PUSH1 0x20 1539 80 DUP1 153A 83 DUP4 153B 01 ADD 153C 93 SWAP4 153D 90 SWAP1 153E 93 SWAP4 153F 52 MSTORE 1540 60 PUSH1 0x40 1542 91 SWAP2 1543 82 DUP3 1544 01 ADD 1545 60 PUSH1 0x00 1547 90 SWAP1 1548 81 DUP2 1549 20 SHA3 154A 91 SWAP2 154B 87 DUP8 154C 16 AND 154D 80 DUP1 154E 82 DUP3 154F 52 MSTORE 1550 91 SWAP2 1551 90 SWAP1 1552 93 SWAP4 1553 52 MSTORE 1554 91 SWAP2 1555 20 SHA3 1556 80 DUP1 1557 54 SLOAD 1558 60 PUSH1 0xff 155A 19 NOT 155B 16 AND 155C 92 SWAP3 155D 15 ISZERO 155E 15 ISZERO 155F 92 SWAP3 1560 90 SWAP1 1561 92 SWAP3 1562 17 OR 1563 90 SWAP1 1564 91 SWAP2 1565 55 SSTORE 1566 61 PUSH2 0x156d 1569 61 PUSH2 0x1896 156C 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @1536 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @153F memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @154F memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1553 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @1564 stack[-4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1565 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1566 stack[-3] = 0x156d // } // Block ends with call to 0x1896, returns to 0x156D label_156D: // Incoming return from call to 0x1896 at 0x156C // Inputs[7] // { // @1571 memory[0x40:0x60] // @1572 stack[-3] // @1578 memory[0x40:0x60] // @1581 stack[-1] // @15AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @15AF stack[-2] // @15B2 stack[-5] // } 156D 5B JUMPDEST 156E 60 PUSH1 0x40 1570 80 DUP1 1571 51 MLOAD 1572 84 DUP5 1573 15 ISZERO 1574 15 ISZERO 1575 81 DUP2 1576 52 MSTORE 1577 90 SWAP1 1578 51 MLOAD 1579 60 PUSH1 0x01 157B 60 PUSH1 0x01 157D 60 PUSH1 0xa0 157F 1B SHL 1580 03 SUB 1581 92 SWAP3 1582 90 SWAP1 1583 92 SWAP3 1584 16 AND 1585 91 SWAP2 1586 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 15A7 91 SWAP2 15A8 81 DUP2 15A9 90 SWAP1 15AA 03 SUB 15AB 60 PUSH1 0x20 15AD 01 ADD 15AE 90 SWAP1 15AF A3 LOG3 15B0 50 POP 15B1 50 POP 15B2 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1576 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-3] // @15AF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-5] label_15B3: // Incoming jump from 0x0B82 // Incoming jump from 0x0630 15B3 5B JUMPDEST 15B4 61 PUSH2 0x15c4 15B7 61 PUSH2 0x15be 15BA 61 PUSH2 0x1896 15BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15B4 stack[0] = 0x15c4 // @15B7 stack[1] = 0x15be // } // Block ends with call to 0x1896, returns to 0x15BE label_15BE: // Incoming return from call to 0x1896 at 0x15BD // Inputs[1] { @15BF stack[-4] } 15BE 5B JUMPDEST 15BF 83 DUP4 15C0 61 PUSH2 0x189a 15C3 56 *JUMP // Stack delta = +1 // Outputs[1] { @15BF stack[0] = stack[-4] } // Block ends with unconditional jump to 0x189a label_15C4: // Incoming return from call to 0x15BE at 0x15BD // Inputs[1] { @15C8 stack[-1] } 15C4 5B JUMPDEST 15C5 61 PUSH2 0x15ff 15C8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15ff, if stack[-1] label_15C9: // Incoming jump from 0x15C8, if not stack[-1] // Inputs[3] // { // @15CB memory[0x40:0x60] // @15F9 memory[0x40:0x60] // @15FE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 15C9 60 PUSH1 0x40 15CB 51 MLOAD 15CC 62 PUSH3 0x461bcd 15D0 60 PUSH1 0xe5 15D2 1B SHL 15D3 81 DUP2 15D4 52 MSTORE 15D5 60 PUSH1 0x04 15D7 01 ADD 15D8 80 DUP1 15D9 80 DUP1 15DA 60 PUSH1 0x20 15DC 01 ADD 15DD 82 DUP3 15DE 81 DUP2 15DF 03 SUB 15E0 82 DUP3 15E1 52 MSTORE 15E2 60 PUSH1 0x31 15E4 81 DUP2 15E5 52 MSTORE 15E6 60 PUSH1 0x20 15E8 01 ADD 15E9 80 DUP1 15EA 61 PUSH2 0x2413 15ED 60 PUSH1 0x31 15EF 91 SWAP2 15F0 39 CODECOPY 15F1 60 PUSH1 0x40 15F3 01 ADD 15F4 91 SWAP2 15F5 50 POP 15F6 50 POP 15F7 60 PUSH1 0x40 15F9 51 MLOAD 15FA 80 DUP1 15FB 91 SWAP2 15FC 03 SUB 15FD 90 SWAP1 15FE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @15D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15E1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @15E5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @15F0 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x2413:0x2444] // @15FE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_15FF: // Incoming jump from 0x15C8, if stack[-1] // Inputs[4] // { // @1603 stack[-4] // @1604 stack[-3] // @1605 stack[-2] // @1606 stack[-1] // } 15FF 5B JUMPDEST 1600 61 PUSH2 0x0ae3 1603 84 DUP5 1604 84 DUP5 1605 84 DUP5 1606 84 DUP5 1607 61 PUSH2 0x1a51 160A 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1600 stack[0] = 0x0ae3 // @1603 stack[1] = stack[-4] // @1604 stack[2] = stack[-3] // @1605 stack[3] = stack[-2] // @1606 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1a51 label_160B: // Incoming call from 0x0638, returns to 0x02BF // Inputs[2] // { // @160E storage[0x12] // @1618 stack[-1] // } 160B 5B JUMPDEST 160C 60 PUSH1 0x12 160E 54 SLOAD 160F 60 PUSH1 0x01 1611 60 PUSH1 0x01 1613 60 PUSH1 0xa0 1615 1B SHL 1616 03 SUB 1617 16 AND 1618 81 DUP2 1619 56 *JUMP // Stack delta = +1 // Outputs[1] { @1617 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x12] } // Block ends with unconditional jump to stack[-1] label_161A: // Incoming call from 0x0640, returns to 0x0211 // Inputs[2] // { // @161D storage[0x0f] // @1621 stack[-1] // } 161A 5B JUMPDEST 161B 60 PUSH1 0x0f 161D 54 SLOAD 161E 60 PUSH1 0xff 1620 16 AND 1621 81 DUP2 1622 56 *JUMP // Stack delta = +1 // Outputs[1] { @1620 stack[0] = 0xff & storage[0x0f] } // Block ends with unconditional jump to stack[-1] label_1623: // Incoming jump from 0x065D // Inputs[1] { @1629 stack[-1] } 1623 5B JUMPDEST 1624 60 PUSH1 0x60 1626 61 PUSH2 0x162e 1629 82 DUP3 162A 61 PUSH2 0x1879 162D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1624 stack[0] = 0x60 // @1626 stack[1] = 0x162e // @1629 stack[2] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x162E label_162E: // Incoming return from call to 0x1879 at 0x162D // Inputs[1] { @1632 stack[-1] } 162E 5B JUMPDEST 162F 61 PUSH2 0x1669 1632 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1669, if stack[-1] label_1633: // Incoming jump from 0x1632, if not stack[-1] // Inputs[3] // { // @1635 memory[0x40:0x60] // @1663 memory[0x40:0x60] // @1668 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1633 60 PUSH1 0x40 1635 51 MLOAD 1636 62 PUSH3 0x461bcd 163A 60 PUSH1 0xe5 163C 1B SHL 163D 81 DUP2 163E 52 MSTORE 163F 60 PUSH1 0x04 1641 01 ADD 1642 80 DUP1 1643 80 DUP1 1644 60 PUSH1 0x20 1646 01 ADD 1647 82 DUP3 1648 81 DUP2 1649 03 SUB 164A 82 DUP3 164B 52 MSTORE 164C 60 PUSH1 0x2f 164E 81 DUP2 164F 52 MSTORE 1650 60 PUSH1 0x20 1652 01 ADD 1653 80 DUP1 1654 61 PUSH2 0x23c3 1657 60 PUSH1 0x2f 1659 91 SWAP2 165A 39 CODECOPY 165B 60 PUSH1 0x40 165D 01 ADD 165E 91 SWAP2 165F 50 POP 1660 50 POP 1661 60 PUSH1 0x40 1663 51 MLOAD 1664 80 DUP1 1665 91 SWAP2 1666 03 SUB 1667 90 SWAP1 1668 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @163E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @164B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @164F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2f // @165A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2f] = code[0x23c3:0x23f2] // @1668 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1669: // Incoming jump from 0x1632, if stack[-1] // Inputs[4] // { // @166C stack[-2] // @167B memory[0x00:0x40] // @167D storage[keccak256(memory[0x00:0x40])] // @167F memory[0x40:0x60] // } 1669 5B JUMPDEST 166A 60 PUSH1 0x00 166C 82 DUP3 166D 81 DUP2 166E 52 MSTORE 166F 60 PUSH1 0x0b 1671 60 PUSH1 0x20 1673 90 SWAP1 1674 81 DUP2 1675 52 MSTORE 1676 60 PUSH1 0x40 1678 91 SWAP2 1679 82 DUP3 167A 90 SWAP1 167B 20 SHA3 167C 80 DUP1 167D 54 SLOAD 167E 83 DUP4 167F 51 MLOAD 1680 60 PUSH1 0x1f 1682 60 PUSH1 0x02 1684 60 PUSH1 0x00 1686 19 NOT 1687 61 PUSH2 0x0100 168A 60 PUSH1 0x01 168C 86 DUP7 168D 16 AND 168E 15 ISZERO 168F 02 MUL 1690 01 ADD 1691 90 SWAP1 1692 93 SWAP4 1693 16 AND 1694 92 SWAP3 1695 90 SWAP1 1696 92 SWAP3 1697 04 DIV 1698 91 SWAP2 1699 82 DUP3 169A 01 ADD 169B 84 DUP5 169C 90 SWAP1 169D 04 DIV 169E 84 DUP5 169F 02 MUL 16A0 81 DUP2 16A1 01 ADD 16A2 84 DUP5 16A3 01 ADD 16A4 90 SWAP1 16A5 94 SWAP5 16A6 52 MSTORE 16A7 80 DUP1 16A8 84 DUP5 16A9 52 MSTORE 16AA 90 SWAP1 16AB 91 SWAP2 16AC 83 DUP4 16AD 01 ADD 16AE 82 DUP3 16AF 82 DUP3 16B0 80 DUP1 16B1 15 ISZERO 16B2 61 PUSH2 0x16fc 16B5 57 *JUMPI // Stack delta = +6 // Outputs[10] // { // @166E memory[0x00:0x20] = stack[-2] // @1675 memory[0x20:0x40] = 0x0b // @16A5 stack[0] = memory[0x40:0x60] // @16A6 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @16A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @16AA stack[2] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @16AB stack[1] = keccak256(memory[0x00:0x40]) // @16AD stack[3] = memory[0x40:0x60] + 0x20 // @16AE stack[4] = keccak256(memory[0x00:0x40]) // @16AF stack[5] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x16fc, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_16B6: // Incoming jump from 0x16B5, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @16B6 stack[-1] } 16B6 80 DUP1 16B7 60 PUSH1 0x1f 16B9 10 LT 16BA 61 PUSH2 0x16d1 16BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16d1, if 0x1f < stack[-1] label_16BE: // Incoming jump from 0x16BD, if not 0x1f < stack[-1] // Inputs[4] // { // @16C2 stack[-2] // @16C3 storage[stack[-2]] // @16C6 stack[-3] // @16C8 stack[-1] // } 16BE 61 PUSH2 0x0100 16C1 80 DUP1 16C2 83 DUP4 16C3 54 SLOAD 16C4 04 DIV 16C5 02 MUL 16C6 83 DUP4 16C7 52 MSTORE 16C8 91 SWAP2 16C9 60 PUSH1 0x20 16CB 01 ADD 16CC 91 SWAP2 16CD 61 PUSH2 0x16fc 16D0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @16C7 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @16CC stack[-1] = stack[-1] // @16CC stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x16fc label_16D1: // Incoming jump from 0x17B7, if 0x1f < stack[-1] // Incoming jump from 0x16BD, if 0x1f < stack[-1] // Inputs[5] // { // @16D2 stack[-3] // @16D3 stack[-1] // @16D5 stack[-2] // @16DD memory[0x00:0x20] // @16E1 storage[keccak256(memory[0x00:0x20])] // } 16D1 5B JUMPDEST 16D2 82 DUP3 16D3 01 ADD 16D4 91 SWAP2 16D5 90 SWAP1 16D6 60 PUSH1 0x00 16D8 52 MSTORE 16D9 60 PUSH1 0x20 16DB 60 PUSH1 0x00 16DD 20 SHA3 16DE 90 SWAP1 16DF 5B JUMPDEST 16E0 81 DUP2 16E1 54 SLOAD 16E2 81 DUP2 16E3 52 MSTORE 16E4 90 SWAP1 16E5 60 PUSH1 0x01 16E7 01 ADD 16E8 90 SWAP1 16E9 60 PUSH1 0x20 16EB 01 ADD 16EC 80 DUP1 16ED 83 DUP4 16EE 11 GT 16EF 61 PUSH2 0x16df 16F2 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @16D4 stack[-3] = stack[-3] + stack[-1] // @16D8 memory[0x00:0x20] = stack[-2] // @16E3 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @16E8 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @16EB stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x16df, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_16F3: // Incoming jump from 0x16F2, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x16F2, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @16F3 stack[-3] // @16F4 stack[-1] // } 16F3 82 DUP3 16F4 90 SWAP1 16F5 03 SUB 16F6 60 PUSH1 0x1f 16F8 16 AND 16F9 82 DUP3 16FA 01 ADD 16FB 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @16FB stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @16FB stack[-1] = stack[-3] // } // Block continues label_16FC: // Incoming jump from 0x16B5, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x16D0 // Incoming jump from 0x17CA // Incoming jump from 0x16FB // Incoming jump from 0x17AF, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[4] // { // @1702 stack[-6] // @1702 stack[-7] // @1704 stack[-9] // @1705 stack[-8] // } 16FC 5B JUMPDEST 16FD 50 POP 16FE 50 POP 16FF 50 POP 1700 50 POP 1701 50 POP 1702 90 SWAP1 1703 50 POP 1704 91 SWAP2 1705 90 SWAP1 1706 50 POP 1707 56 *JUMP // Stack delta = -8 // Outputs[1] { @1704 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_1708: // Incoming jump from 0x067A // Inputs[4] // { // @1710 stack[-1] // @1716 memory[0x00:0x40] // @1717 storage[keccak256(memory[0x00:0x40])] // @171B stack[-2] // } 1708 5B JUMPDEST 1709 60 PUSH1 0x17 170B 60 PUSH1 0x20 170D 52 MSTORE 170E 60 PUSH1 0x00 1710 90 SWAP1 1711 81 DUP2 1712 52 MSTORE 1713 60 PUSH1 0x40 1715 90 SWAP1 1716 20 SHA3 1717 54 SLOAD 1718 60 PUSH1 0xff 171A 16 AND 171B 81 DUP2 171C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @170D memory[0x20:0x40] = 0x17 // @1712 memory[0x00:0x20] = stack[-1] // @171A stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_171D: // Incoming jump from 0x0697 // Inputs[1] { @1723 stack[-1] } 171D 5B JUMPDEST 171E 60 PUSH1 0x60 1720 61 PUSH2 0x1728 1723 82 DUP3 1724 61 PUSH2 0x1879 1727 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @171E stack[0] = 0x60 // @1720 stack[1] = 0x1728 // @1723 stack[2] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x1728 label_1728: // Incoming return from call to 0x1879 at 0x1727 // Inputs[1] { @172C stack[-1] } 1728 5B JUMPDEST 1729 61 PUSH2 0x1763 172C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1763, if stack[-1] label_172D: // Incoming jump from 0x172C, if not stack[-1] // Inputs[3] // { // @172F memory[0x40:0x60] // @175D memory[0x40:0x60] // @1762 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 172D 60 PUSH1 0x40 172F 51 MLOAD 1730 62 PUSH3 0x461bcd 1734 60 PUSH1 0xe5 1736 1B SHL 1737 81 DUP2 1738 52 MSTORE 1739 60 PUSH1 0x04 173B 01 ADD 173C 80 DUP1 173D 80 DUP1 173E 60 PUSH1 0x20 1740 01 ADD 1741 82 DUP3 1742 81 DUP2 1743 03 SUB 1744 82 DUP3 1745 52 MSTORE 1746 60 PUSH1 0x2f 1748 81 DUP2 1749 52 MSTORE 174A 60 PUSH1 0x20 174C 01 ADD 174D 80 DUP1 174E 61 PUSH2 0x23c3 1751 60 PUSH1 0x2f 1753 91 SWAP2 1754 39 CODECOPY 1755 60 PUSH1 0x40 1757 01 ADD 1758 91 SWAP2 1759 50 POP 175A 50 POP 175B 60 PUSH1 0x40 175D 51 MLOAD 175E 80 DUP1 175F 91 SWAP2 1760 03 SUB 1761 90 SWAP1 1762 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1738 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1745 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1749 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2f // @1754 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2f] = code[0x23c3:0x23f2] // @1762 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1763: // Incoming jump from 0x172C, if stack[-1] // Inputs[4] // { // @1766 stack[-2] // @1775 memory[0x00:0x40] // @1777 storage[keccak256(memory[0x00:0x40])] // @1779 memory[0x40:0x60] // } 1763 5B JUMPDEST 1764 60 PUSH1 0x00 1766 82 DUP3 1767 81 DUP2 1768 52 MSTORE 1769 60 PUSH1 0x0c 176B 60 PUSH1 0x20 176D 90 SWAP1 176E 81 DUP2 176F 52 MSTORE 1770 60 PUSH1 0x40 1772 91 SWAP2 1773 82 DUP3 1774 90 SWAP1 1775 20 SHA3 1776 80 DUP1 1777 54 SLOAD 1778 83 DUP4 1779 51 MLOAD 177A 60 PUSH1 0x1f 177C 60 PUSH1 0x02 177E 60 PUSH1 0x00 1780 19 NOT 1781 61 PUSH2 0x0100 1784 60 PUSH1 0x01 1786 86 DUP7 1787 16 AND 1788 15 ISZERO 1789 02 MUL 178A 01 ADD 178B 90 SWAP1 178C 93 SWAP4 178D 16 AND 178E 92 SWAP3 178F 90 SWAP1 1790 92 SWAP3 1791 04 DIV 1792 91 SWAP2 1793 82 DUP3 1794 01 ADD 1795 84 DUP5 1796 90 SWAP1 1797 04 DIV 1798 84 DUP5 1799 02 MUL 179A 81 DUP2 179B 01 ADD 179C 84 DUP5 179D 01 ADD 179E 90 SWAP1 179F 94 SWAP5 17A0 52 MSTORE 17A1 80 DUP1 17A2 84 DUP5 17A3 52 MSTORE 17A4 90 SWAP1 17A5 91 SWAP2 17A6 83 DUP4 17A7 01 ADD 17A8 82 DUP3 17A9 82 DUP3 17AA 80 DUP1 17AB 15 ISZERO 17AC 61 PUSH2 0x16fc 17AF 57 *JUMPI // Stack delta = +6 // Outputs[10] // { // @1768 memory[0x00:0x20] = stack[-2] // @176F memory[0x20:0x40] = 0x0c // @179F stack[0] = memory[0x40:0x60] // @17A0 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @17A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @17A4 stack[2] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @17A5 stack[1] = keccak256(memory[0x00:0x40]) // @17A7 stack[3] = memory[0x40:0x60] + 0x20 // @17A8 stack[4] = keccak256(memory[0x00:0x40]) // @17A9 stack[5] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x16fc, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_17B0: // Incoming jump from 0x17AF, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @17B0 stack[-1] } 17B0 80 DUP1 17B1 60 PUSH1 0x1f 17B3 10 LT 17B4 61 PUSH2 0x16d1 17B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16d1, if 0x1f < stack[-1] label_17B8: // Incoming jump from 0x17B7, if not 0x1f < stack[-1] // Inputs[4] // { // @17BC stack[-2] // @17BD storage[stack[-2]] // @17C0 stack[-3] // @17C2 stack[-1] // } 17B8 61 PUSH2 0x0100 17BB 80 DUP1 17BC 83 DUP4 17BD 54 SLOAD 17BE 04 DIV 17BF 02 MUL 17C0 83 DUP4 17C1 52 MSTORE 17C2 91 SWAP2 17C3 60 PUSH1 0x20 17C5 01 ADD 17C6 91 SWAP2 17C7 61 PUSH2 0x16fc 17CA 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @17C1 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @17C6 stack[-1] = stack[-1] // @17C6 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x16fc label_17CB: // Incoming jump from 0x06B4 // Inputs[4] // { // @17D5 stack[-1] // @17DD memory[0x00:0x40] // @17DF storage[keccak256(memory[0x00:0x40])] // @17E1 memory[0x40:0x60] // } 17CB 5B JUMPDEST 17CC 60 PUSH1 0x16 17CE 60 PUSH1 0x20 17D0 90 SWAP1 17D1 81 DUP2 17D2 52 MSTORE 17D3 60 PUSH1 0x00 17D5 91 SWAP2 17D6 82 DUP3 17D7 52 MSTORE 17D8 60 PUSH1 0x40 17DA 91 SWAP2 17DB 82 DUP3 17DC 90 SWAP1 17DD 20 SHA3 17DE 80 DUP1 17DF 54 SLOAD 17E0 83 DUP4 17E1 51 MLOAD 17E2 60 PUSH1 0x1f 17E4 60 PUSH1 0x02 17E6 60 PUSH1 0x00 17E8 19 NOT 17E9 61 PUSH2 0x0100 17EC 60 PUSH1 0x01 17EE 86 DUP7 17EF 16 AND 17F0 15 ISZERO 17F1 02 MUL 17F2 01 ADD 17F3 90 SWAP1 17F4 93 SWAP4 17F5 16 AND 17F6 92 SWAP3 17F7 90 SWAP1 17F8 92 SWAP3 17F9 04 DIV 17FA 91 SWAP2 17FB 82 DUP3 17FC 01 ADD 17FD 84 DUP5 17FE 90 SWAP1 17FF 04 DIV 1800 84 DUP5 1801 02 MUL 1802 81 DUP2 1803 01 ADD 1804 84 DUP5 1805 01 ADD 1806 90 SWAP1 1807 94 SWAP5 1808 52 MSTORE 1809 80 DUP1 180A 84 DUP5 180B 52 MSTORE 180C 90 SWAP1 180D 91 SWAP2 180E 83 DUP4 180F 01 ADD 1810 82 DUP3 1811 82 DUP3 1812 80 DUP1 1813 15 ISZERO 1814 61 PUSH2 0x137c 1817 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @17D2 memory[0x20:0x40] = 0x16 // @17D7 memory[0x00:0x20] = stack[-1] // @1807 stack[-1] = memory[0x40:0x60] // @1808 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @180B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @180C stack[1] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @180D stack[0] = keccak256(memory[0x00:0x40]) // @180F stack[2] = memory[0x40:0x60] + 0x20 // @1810 stack[3] = keccak256(memory[0x00:0x40]) // @1811 stack[4] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x137c, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_1818: // Incoming jump from 0x1817, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @1818 stack[-1] } 1818 80 DUP1 1819 60 PUSH1 0x1f 181B 10 LT 181C 61 PUSH2 0x1351 181F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1351, if 0x1f < stack[-1] label_1820: // Incoming jump from 0x181F, if not 0x1f < stack[-1] // Inputs[4] // { // @1824 stack[-2] // @1825 storage[stack[-2]] // @1828 stack[-3] // @182A stack[-1] // } 1820 61 PUSH2 0x0100 1823 80 DUP1 1824 83 DUP4 1825 54 SLOAD 1826 04 DIV 1827 02 MUL 1828 83 DUP4 1829 52 MSTORE 182A 91 SWAP2 182B 60 PUSH1 0x20 182D 01 ADD 182E 91 SWAP2 182F 61 PUSH2 0x137c 1832 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1829 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @182E stack[-1] = stack[-1] // @182E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x137c label_1833: // Incoming jump from 0x06D1 // Inputs[4] // { // @183B stack[-1] // @1841 memory[0x00:0x40] // @1842 storage[keccak256(memory[0x00:0x40])] // @1843 stack[-2] // } 1833 5B JUMPDEST 1834 60 PUSH1 0x14 1836 60 PUSH1 0x20 1838 52 MSTORE 1839 60 PUSH1 0x00 183B 90 SWAP1 183C 81 DUP2 183D 52 MSTORE 183E 60 PUSH1 0x40 1840 90 SWAP1 1841 20 SHA3 1842 54 SLOAD 1843 81 DUP2 1844 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1838 memory[0x20:0x40] = 0x14 // @183D memory[0x00:0x20] = stack[-1] // @1842 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1845: // Incoming jump from 0x06FF // Incoming jump from 0x08B0 // Incoming call from 0x1935, returns to 0x1936 // Inputs[6] // { // @184E stack[-2] // @1861 memory[0x00:0x40] // @1862 stack[-1] // @186C memory[0x00:0x40] // @186D storage[keccak256(memory[0x00:0x40])] // @1871 stack[-3] // } 1845 5B JUMPDEST 1846 60 PUSH1 0x01 1848 60 PUSH1 0x01 184A 60 PUSH1 0xa0 184C 1B SHL 184D 03 SUB 184E 91 SWAP2 184F 82 DUP3 1850 16 AND 1851 60 PUSH1 0x00 1853 90 SWAP1 1854 81 DUP2 1855 52 MSTORE 1856 60 PUSH1 0x04 1858 60 PUSH1 0x20 185A 90 SWAP1 185B 81 DUP2 185C 52 MSTORE 185D 60 PUSH1 0x40 185F 80 DUP1 1860 83 DUP4 1861 20 SHA3 1862 93 SWAP4 1863 90 SWAP1 1864 94 SWAP5 1865 16 AND 1866 82 DUP3 1867 52 MSTORE 1868 91 SWAP2 1869 90 SWAP1 186A 91 SWAP2 186B 52 MSTORE 186C 20 SHA3 186D 54 SLOAD 186E 60 PUSH1 0xff 1870 16 AND 1871 90 SWAP1 1872 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1855 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @185C memory[0x20:0x40] = 0x04 // @1867 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @186B memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1871 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1873: // Incoming call from 0x0707, returns to 0x0326 // Inputs[2] // { // @1876 storage[0x0d] // @1877 stack[-1] // } 1873 5B JUMPDEST 1874 60 PUSH1 0x0d 1876 54 SLOAD 1877 81 DUP2 1878 56 *JUMP // Stack delta = +1 // Outputs[1] { @1876 stack[0] = storage[0x0d] } // Block ends with unconditional jump to stack[-1] label_1879: // Incoming call from 0x1D7D, returns to 0x1D7E // Incoming call from 0x18A4, returns to 0x18A5 // Incoming call from 0x1993, returns to 0x1994 // Incoming call from 0x1727, returns to 0x1728 // Incoming call from 0x162D, returns to 0x162E // Incoming call from 0x07C8, returns to 0x07C9 // Inputs[4] // { // @187C stack[-1] // @1887 memory[0x00:0x40] // @1888 storage[keccak256(memory[0x00:0x40])] // @1894 stack[-2] // } 1879 5B JUMPDEST 187A 60 PUSH1 0x00 187C 90 SWAP1 187D 81 DUP2 187E 52 MSTORE 187F 60 PUSH1 0x01 1881 60 PUSH1 0x20 1883 52 MSTORE 1884 60 PUSH1 0x40 1886 90 SWAP1 1887 20 SHA3 1888 54 SLOAD 1889 60 PUSH1 0x01 188B 60 PUSH1 0x01 188D 60 PUSH1 0xa0 188F 1B SHL 1890 03 SUB 1891 16 AND 1892 15 ISZERO 1893 15 ISZERO 1894 90 SWAP1 1895 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @187E memory[0x00:0x20] = stack[-1] // @1883 memory[0x20:0x40] = 0x01 // @1894 stack[-2] = !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_1896: // Incoming call from 0x156C, returns to 0x156D // Incoming call from 0x1528, returns to 0x1529 // Incoming call from 0x08AB, returns to 0x08AC // Incoming call from 0x14B5, returns to 0x14B6 // Incoming call from 0x15BD, returns to 0x15BE // Incoming call from 0x088F, returns to 0x0890 // Incoming call from 0x096A, returns to 0x096B // Inputs[2] // { // @1897 msg.sender // @1898 stack[-1] // } 1896 5B JUMPDEST 1897 33 CALLER 1898 90 SWAP1 1899 56 *JUMP // Stack delta = +0 // Outputs[1] { @1898 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_189A: // Incoming jump from 0x15C3 // Incoming jump from 0x0970 // Inputs[1] { @18A0 stack[-1] } 189A 5B JUMPDEST 189B 60 PUSH1 0x00 189D 61 PUSH2 0x18a5 18A0 82 DUP3 18A1 61 PUSH2 0x1879 18A4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @189B stack[0] = 0x00 // @189D stack[1] = 0x18a5 // @18A0 stack[2] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x18A5 label_18A5: // Incoming return from call to 0x1879 at 0x18A4 // Inputs[1] { @18A9 stack[-1] } 18A5 5B JUMPDEST 18A6 61 PUSH2 0x18e0 18A9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18e0, if stack[-1] label_18AA: // Incoming jump from 0x18A9, if not stack[-1] // Inputs[3] // { // @18AC memory[0x40:0x60] // @18DA memory[0x40:0x60] // @18DF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 18AA 60 PUSH1 0x40 18AC 51 MLOAD 18AD 62 PUSH3 0x461bcd 18B1 60 PUSH1 0xe5 18B3 1B SHL 18B4 81 DUP2 18B5 52 MSTORE 18B6 60 PUSH1 0x04 18B8 01 ADD 18B9 80 DUP1 18BA 80 DUP1 18BB 60 PUSH1 0x20 18BD 01 ADD 18BE 82 DUP3 18BF 81 DUP2 18C0 03 SUB 18C1 82 DUP3 18C2 52 MSTORE 18C3 60 PUSH1 0x2c 18C5 81 DUP2 18C6 52 MSTORE 18C7 60 PUSH1 0x20 18C9 01 ADD 18CA 80 DUP1 18CB 61 PUSH2 0x228b 18CE 60 PUSH1 0x2c 18D0 91 SWAP2 18D1 39 CODECOPY 18D2 60 PUSH1 0x40 18D4 01 ADD 18D5 91 SWAP2 18D6 50 POP 18D7 50 POP 18D8 60 PUSH1 0x40 18DA 51 MLOAD 18DB 80 DUP1 18DC 91 SWAP2 18DD 03 SUB 18DE 90 SWAP1 18DF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @18B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18C2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @18C6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @18D1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x228b:0x22b7] // @18DF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_18E0: // Incoming jump from 0x18A9, if stack[-1] // Inputs[1] { @18E6 stack[-2] } 18E0 5B JUMPDEST 18E1 60 PUSH1 0x00 18E3 61 PUSH2 0x18eb 18E6 83 DUP4 18E7 61 PUSH2 0x128d 18EA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18E1 stack[0] = 0x00 // @18E3 stack[1] = 0x18eb // @18E6 stack[2] = stack[-2] // } // Block ends with call to 0x128d, returns to 0x18EB label_18EB: // Incoming return from call to 0x128D at 0x18EA // Inputs[3] // { // @18EC stack[-1] // @18EC stack[-2] // @18F8 stack[-5] // } 18EB 5B JUMPDEST 18EC 90 SWAP1 18ED 50 POP 18EE 80 DUP1 18EF 60 PUSH1 0x01 18F1 60 PUSH1 0x01 18F3 60 PUSH1 0xa0 18F5 1B SHL 18F6 03 SUB 18F7 16 AND 18F8 84 DUP5 18F9 60 PUSH1 0x01 18FB 60 PUSH1 0x01 18FD 60 PUSH1 0xa0 18FF 1B SHL 1900 03 SUB 1901 16 AND 1902 14 EQ 1903 80 DUP1 1904 61 PUSH2 0x1926 1907 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @18EC stack[-2] = stack[-1] // @1902 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x1926, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_1908: // Incoming jump from 0x1907, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @1909 stack[-5] // @1916 stack[-4] // } 1908 50 POP 1909 83 DUP4 190A 60 PUSH1 0x01 190C 60 PUSH1 0x01 190E 60 PUSH1 0xa0 1910 1B SHL 1911 03 SUB 1912 16 AND 1913 61 PUSH2 0x191b 1916 84 DUP5 1917 61 PUSH2 0x07be 191A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1912 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1913 stack[0] = 0x191b // @1916 stack[1] = stack[-4] // } // Block ends with call to 0x07be, returns to 0x191B label_191B: // Incoming return from call to 0x07BE at 0x191A // Inputs[2] // { // @1924 stack[-1] // @1925 stack[-2] // } 191B 5B JUMPDEST 191C 60 PUSH1 0x01 191E 60 PUSH1 0x01 1920 60 PUSH1 0xa0 1922 1B SHL 1923 03 SUB 1924 16 AND 1925 14 EQ // Stack delta = -1 // Outputs[1] { @1925 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1926: // Incoming jump from 0x1907, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x1925 // Inputs[1] { @1927 stack[-1] } 1926 5B JUMPDEST 1927 80 DUP1 1928 61 PUSH2 0x1936 192B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1936, if stack[-1] label_192C: // Incoming jump from 0x192B, if not stack[-1] // Inputs[2] // { // @1930 stack[-2] // @1931 stack[-5] // } 192C 50 POP 192D 61 PUSH2 0x1936 1930 81 DUP2 1931 85 DUP6 1932 61 PUSH2 0x1845 1935 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @192D stack[-1] = 0x1936 // @1930 stack[0] = stack[-2] // @1931 stack[1] = stack[-5] // } // Block ends with call to 0x1845, returns to 0x1936 label_1936: // Incoming return from call to 0x1845 at 0x1935 // Incoming jump from 0x192B, if stack[-1] // Inputs[3] // { // @1937 stack[-6] // @1937 stack[-1] // @1938 stack[-5] // } 1936 5B JUMPDEST 1937 94 SWAP5 1938 93 SWAP4 1939 50 POP 193A 50 POP 193B 50 POP 193C 50 POP 193D 56 *JUMP // Stack delta = -5 // Outputs[1] { @1937 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_193E: // Incoming jump from 0x1A5B // Incoming jump from 0x09B6 // Inputs[3] // { // @1942 stack[-3] // @1943 stack[-2] // @1944 stack[-1] // } 193E 5B JUMPDEST 193F 61 PUSH2 0x1949 1942 83 DUP4 1943 83 DUP4 1944 83 DUP4 1945 61 PUSH2 0x1aa3 1948 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @193F stack[0] = 0x1949 // @1942 stack[1] = stack[-3] // @1943 stack[2] = stack[-2] // @1944 stack[3] = stack[-1] // } // Block ends with call to 0x1aa3, returns to 0x1949 label_1949: // Incoming return from call to 0x1AA3 at 0x1948 // Inputs[2] // { // @194D stack[-3] // @194E stack[-1] // } 1949 5B JUMPDEST 194A 61 PUSH2 0x1953 194D 83 DUP4 194E 82 DUP3 194F 61 PUSH2 0x1be7 1952 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @194A stack[0] = 0x1953 // @194D stack[1] = stack[-3] // @194E stack[2] = stack[-1] // } // Block ends with call to 0x1be7, returns to 0x1953 label_1953: // Incoming return from call to 0x1BE7 at 0x1952 // Inputs[2] // { // @1957 stack[-2] // @1958 stack[-1] // } 1953 5B JUMPDEST 1954 61 PUSH2 0x09b7 1957 82 DUP3 1958 82 DUP3 1959 61 PUSH2 0x1cdc 195C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1954 stack[0] = 0x09b7 // @1957 stack[1] = stack[-2] // @1958 stack[2] = stack[-1] // } // Block ends with call to 0x1cdc, returns to 0x09B7 label_195D: // Incoming call from 0x1E0E, returns to 0x1E0F // Incoming call from 0x0C35, returns to 0x0C36 // Incoming call from 0x1B8A, returns to 0x1B8B // Inputs[3] // { // @195E stack[-1] // @195F storage[stack[-1]] // @1965 stack[-2] // } 195D 5B JUMPDEST 195E 80 DUP1 195F 54 SLOAD 1960 60 PUSH1 0x01 1962 01 ADD 1963 90 SWAP1 1964 55 SSTORE 1965 56 *JUMP // Stack delta = -2 // Outputs[1] { @1964 storage[stack[-1]] = 0x01 + storage[stack[-1]] } // Block ends with unconditional jump to stack[-2] label_1966: // Incoming call from 0x0CA9, returns to 0x0CAA // Incoming call from 0x13EB, returns to 0x12E1 // Inputs[3] // { // @1967 stack[-1] // @1967 storage[stack[-1]] // @1968 stack[-2] // } 1966 5B JUMPDEST 1967 54 SLOAD 1968 90 SWAP1 1969 56 *JUMP // Stack delta = -1 // Outputs[1] { @1968 stack[-2] = storage[stack[-1]] } // Block ends with unconditional jump to stack[-2] label_196A: // Incoming call from 0x111F, returns to 0x1120 // Inputs[2] // { // @196E stack[-2] // @196F stack[-1] // } 196A 5B JUMPDEST 196B 61 PUSH2 0x1974 196E 82 DUP3 196F 82 DUP3 1970 61 PUSH2 0x1d1a 1973 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @196B stack[0] = 0x1974 // @196E stack[1] = stack[-2] // @196F stack[2] = stack[-1] // } // Block ends with call to 0x1d1a, returns to 0x1974 label_1974: // Incoming return from call to 0x1D1A at 0x1973 // Inputs[2] // { // @1978 stack[-2] // @1979 stack[-1] // } 1974 5B JUMPDEST 1975 61 PUSH2 0x197e 1978 82 DUP3 1979 82 DUP3 197A 61 PUSH2 0x1cdc 197D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1975 stack[0] = 0x197e // @1978 stack[1] = stack[-2] // @1979 stack[2] = stack[-1] // } // Block ends with call to 0x1cdc, returns to 0x197E label_197E: // Incoming return from call to 0x1CDC at 0x197D // Inputs[1] { @1982 stack[-1] } 197E 5B JUMPDEST 197F 61 PUSH2 0x1987 1982 81 DUP2 1983 61 PUSH2 0x1e4b 1986 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @197F stack[0] = 0x1987 // @1982 stack[1] = stack[-1] // } // Block ends with call to 0x1e4b, returns to 0x1987 label_1987: // Incoming return from call to 0x1E4B at 0x1986 // Inputs[1] { @198A stack[-3] } 1987 5B JUMPDEST 1988 50 POP 1989 50 POP 198A 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_198B: // Incoming jump from 0x1129 // Inputs[1] { @198F stack[-2] } 198B 5B JUMPDEST 198C 61 PUSH2 0x1994 198F 82 DUP3 1990 61 PUSH2 0x1879 1993 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @198C stack[0] = 0x1994 // @198F stack[1] = stack[-2] // } // Block ends with call to 0x1879, returns to 0x1994 label_1994: // Incoming return from call to 0x1879 at 0x1993 // Inputs[1] { @1998 stack[-1] } 1994 5B JUMPDEST 1995 61 PUSH2 0x19cf 1998 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x19cf, if stack[-1] label_1999: // Incoming jump from 0x1998, if not stack[-1] // Inputs[3] // { // @199B memory[0x40:0x60] // @19C9 memory[0x40:0x60] // @19CE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1999 60 PUSH1 0x40 199B 51 MLOAD 199C 62 PUSH3 0x461bcd 19A0 60 PUSH1 0xe5 19A2 1B SHL 19A3 81 DUP2 19A4 52 MSTORE 19A5 60 PUSH1 0x04 19A7 01 ADD 19A8 80 DUP1 19A9 80 DUP1 19AA 60 PUSH1 0x20 19AC 01 ADD 19AD 82 DUP3 19AE 81 DUP2 19AF 03 SUB 19B0 82 DUP3 19B1 52 MSTORE 19B2 60 PUSH1 0x2c 19B4 81 DUP2 19B5 52 MSTORE 19B6 60 PUSH1 0x20 19B8 01 ADD 19B9 80 DUP1 19BA 61 PUSH2 0x236e 19BD 60 PUSH1 0x2c 19BF 91 SWAP2 19C0 39 CODECOPY 19C1 60 PUSH1 0x40 19C3 01 ADD 19C4 91 SWAP2 19C5 50 POP 19C6 50 POP 19C7 60 PUSH1 0x40 19C9 51 MLOAD 19CA 80 DUP1 19CB 91 SWAP2 19CC 03 SUB 19CD 90 SWAP1 19CE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @19A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @19B1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @19B5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @19C0 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x236e:0x239a] // @19CE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_19CF: // Incoming jump from 0x1998, if stack[-1] // Inputs[4] // { // @19D2 stack[-2] // @19E0 memory[0x00:0x40] // @19E1 stack[-1] // @19E2 memory[stack[-1]:stack[-1] + 0x20] // } 19CF 5B JUMPDEST 19D0 60 PUSH1 0x00 19D2 82 DUP3 19D3 81 DUP2 19D4 52 MSTORE 19D5 60 PUSH1 0x0b 19D7 60 PUSH1 0x20 19D9 90 SWAP1 19DA 81 DUP2 19DB 52 MSTORE 19DC 60 PUSH1 0x40 19DE 90 SWAP1 19DF 91 SWAP2 19E0 20 SHA3 19E1 82 DUP3 19E2 51 MLOAD 19E3 61 PUSH2 0x09b7 19E6 92 SWAP3 19E7 84 DUP5 19E8 01 ADD 19E9 90 SWAP1 19EA 61 PUSH2 0x2151 19ED 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @19D4 memory[0x00:0x20] = stack[-2] // @19DB memory[0x20:0x40] = 0x0b // @19E0 stack[1] = keccak256(memory[0x00:0x40]) // @19E6 stack[0] = 0x09b7 // @19E9 stack[2] = stack[-1] + 0x20 // @19E9 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2151 19EE 5B JUMPDEST 19EF 61 PUSH2 0x19f7 19F2 82 DUP3 19F3 61 PUSH2 0x1879 19F6 56 *JUMP 19F7 5B JUMPDEST 19F8 61 PUSH2 0x1a32 19FB 57 *JUMPI 19FC 60 PUSH1 0x40 19FE 51 MLOAD 19FF 62 PUSH3 0x461bcd 1A03 60 PUSH1 0xe5 1A05 1B SHL 1A06 81 DUP2 1A07 52 MSTORE 1A08 60 PUSH1 0x04 1A0A 01 ADD 1A0B 80 DUP1 1A0C 80 DUP1 1A0D 60 PUSH1 0x20 1A0F 01 ADD 1A10 82 DUP3 1A11 81 DUP2 1A12 03 SUB 1A13 82 DUP3 1A14 52 MSTORE 1A15 60 PUSH1 0x2c 1A17 81 DUP2 1A18 52 MSTORE 1A19 60 PUSH1 0x20 1A1B 01 ADD 1A1C 80 DUP1 1A1D 61 PUSH2 0x236e 1A20 60 PUSH1 0x2c 1A22 91 SWAP2 1A23 39 CODECOPY 1A24 60 PUSH1 0x40 1A26 01 ADD 1A27 91 SWAP2 1A28 50 POP 1A29 50 POP 1A2A 60 PUSH1 0x40 1A2C 51 MLOAD 1A2D 80 DUP1 1A2E 91 SWAP2 1A2F 03 SUB 1A30 90 SWAP1 1A31 FD *REVERT 1A32 5B JUMPDEST 1A33 60 PUSH1 0x00 1A35 82 DUP3 1A36 81 DUP2 1A37 52 MSTORE 1A38 60 PUSH1 0x0c 1A3A 60 PUSH1 0x20 1A3C 90 SWAP1 1A3D 81 DUP2 1A3E 52 MSTORE 1A3F 60 PUSH1 0x40 1A41 90 SWAP1 1A42 91 SWAP2 1A43 20 SHA3 1A44 82 DUP3 1A45 51 MLOAD 1A46 61 PUSH2 0x09b7 1A49 92 SWAP3 1A4A 84 DUP5 1A4B 01 ADD 1A4C 90 SWAP1 1A4D 61 PUSH2 0x2151 1A50 56 *JUMP label_1A51: // Incoming jump from 0x160A // Inputs[3] // { // @1A55 stack[-4] // @1A56 stack[-3] // @1A57 stack[-2] // } 1A51 5B JUMPDEST 1A52 61 PUSH2 0x1a5c 1A55 84 DUP5 1A56 84 DUP5 1A57 84 DUP5 1A58 61 PUSH2 0x193e 1A5B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A52 stack[0] = 0x1a5c // @1A55 stack[1] = stack[-4] // @1A56 stack[2] = stack[-3] // @1A57 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x193e 1A5C 5B JUMPDEST 1A5D 61 PUSH2 0x1a68 1A60 84 DUP5 1A61 84 DUP5 1A62 84 DUP5 1A63 84 DUP5 1A64 61 PUSH2 0x1e8f 1A67 56 *JUMP 1A68 5B JUMPDEST 1A69 61 PUSH2 0x0ae3 1A6C 57 *JUMPI 1A6D 60 PUSH1 0x40 1A6F 51 MLOAD 1A70 62 PUSH3 0x461bcd 1A74 60 PUSH1 0xe5 1A76 1B SHL 1A77 81 DUP2 1A78 52 MSTORE 1A79 60 PUSH1 0x04 1A7B 01 ADD 1A7C 80 DUP1 1A7D 80 DUP1 1A7E 60 PUSH1 0x20 1A80 01 ADD 1A81 82 DUP3 1A82 81 DUP2 1A83 03 SUB 1A84 82 DUP3 1A85 52 MSTORE 1A86 60 PUSH1 0x32 1A88 81 DUP2 1A89 52 MSTORE 1A8A 60 PUSH1 0x20 1A8C 01 ADD 1A8D 80 DUP1 1A8E 61 PUSH2 0x2235 1A91 60 PUSH1 0x32 1A93 91 SWAP2 1A94 39 CODECOPY 1A95 60 PUSH1 0x40 1A97 01 ADD 1A98 91 SWAP2 1A99 50 POP 1A9A 50 POP 1A9B 60 PUSH1 0x40 1A9D 51 MLOAD 1A9E 80 DUP1 1A9F 91 SWAP2 1AA0 03 SUB 1AA1 90 SWAP1 1AA2 FD *REVERT label_1AA3: // Incoming call from 0x1948, returns to 0x1949 // Inputs[2] // { // @1AA4 stack[-3] // @1AB1 stack[-1] // } 1AA3 5B JUMPDEST 1AA4 82 DUP3 1AA5 60 PUSH1 0x01 1AA7 60 PUSH1 0x01 1AA9 60 PUSH1 0xa0 1AAB 1B SHL 1AAC 03 SUB 1AAD 16 AND 1AAE 61 PUSH2 0x1ab6 1AB1 82 DUP3 1AB2 61 PUSH2 0x128d 1AB5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AAD stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1AAE stack[1] = 0x1ab6 // @1AB1 stack[2] = stack[-1] // } // Block ends with call to 0x128d, returns to 0x1AB6 label_1AB6: // Incoming return from call to 0x128D at 0x1AB5 // Inputs[2] // { // @1ABF stack[-1] // @1AC0 stack[-2] // } 1AB6 5B JUMPDEST 1AB7 60 PUSH1 0x01 1AB9 60 PUSH1 0x01 1ABB 60 PUSH1 0xa0 1ABD 1B SHL 1ABE 03 SUB 1ABF 16 AND 1AC0 14 EQ 1AC1 61 PUSH2 0x1afb 1AC4 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1afb, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1AC5: // Incoming jump from 0x1AC4, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @1AC7 memory[0x40:0x60] // @1AF5 memory[0x40:0x60] // @1AFA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AC5 60 PUSH1 0x40 1AC7 51 MLOAD 1AC8 62 PUSH3 0x461bcd 1ACC 60 PUSH1 0xe5 1ACE 1B SHL 1ACF 81 DUP2 1AD0 52 MSTORE 1AD1 60 PUSH1 0x04 1AD3 01 ADD 1AD4 80 DUP1 1AD5 80 DUP1 1AD6 60 PUSH1 0x20 1AD8 01 ADD 1AD9 82 DUP3 1ADA 81 DUP2 1ADB 03 SUB 1ADC 82 DUP3 1ADD 52 MSTORE 1ADE 60 PUSH1 0x29 1AE0 81 DUP2 1AE1 52 MSTORE 1AE2 60 PUSH1 0x20 1AE4 01 ADD 1AE5 80 DUP1 1AE6 61 PUSH2 0x239a 1AE9 60 PUSH1 0x29 1AEB 91 SWAP2 1AEC 39 CODECOPY 1AED 60 PUSH1 0x40 1AEF 01 ADD 1AF0 91 SWAP2 1AF1 50 POP 1AF2 50 POP 1AF3 60 PUSH1 0x40 1AF5 51 MLOAD 1AF6 80 DUP1 1AF7 91 SWAP2 1AF8 03 SUB 1AF9 90 SWAP1 1AFA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1AD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1ADD memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1AE1 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @1AEC memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x239a:0x23c3] // @1AFA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AFB: // Incoming jump from 0x1AC4, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1B04 stack[-2] } 1AFB 5B JUMPDEST 1AFC 60 PUSH1 0x01 1AFE 60 PUSH1 0x01 1B00 60 PUSH1 0xa0 1B02 1B SHL 1B03 03 SUB 1B04 82 DUP3 1B05 16 AND 1B06 61 PUSH2 0x1b40 1B09 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b40, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1B0A: // Incoming jump from 0x1B09, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1B0C memory[0x40:0x60] // @1B3A memory[0x40:0x60] // @1B3F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B0A 60 PUSH1 0x40 1B0C 51 MLOAD 1B0D 62 PUSH3 0x461bcd 1B11 60 PUSH1 0xe5 1B13 1B SHL 1B14 81 DUP2 1B15 52 MSTORE 1B16 60 PUSH1 0x04 1B18 01 ADD 1B19 80 DUP1 1B1A 80 DUP1 1B1B 60 PUSH1 0x20 1B1D 01 ADD 1B1E 82 DUP3 1B1F 81 DUP2 1B20 03 SUB 1B21 82 DUP3 1B22 52 MSTORE 1B23 60 PUSH1 0x24 1B25 81 DUP2 1B26 52 MSTORE 1B27 60 PUSH1 0x20 1B29 01 ADD 1B2A 80 DUP1 1B2B 61 PUSH2 0x2267 1B2E 60 PUSH1 0x24 1B30 91 SWAP2 1B31 39 CODECOPY 1B32 60 PUSH1 0x40 1B34 01 ADD 1B35 91 SWAP2 1B36 50 POP 1B37 50 POP 1B38 60 PUSH1 0x40 1B3A 51 MLOAD 1B3B 80 DUP1 1B3C 91 SWAP2 1B3D 03 SUB 1B3E 90 SWAP1 1B3F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B22 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1B26 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @1B31 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x2267:0x228b] // @1B3F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B40: // Incoming jump from 0x1B09, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1B44 stack[-1] } 1B40 5B JUMPDEST 1B41 61 PUSH2 0x1b49 1B44 81 DUP2 1B45 61 PUSH2 0x1fe6 1B48 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B41 stack[0] = 0x1b49 // @1B44 stack[1] = stack[-1] // } // Block ends with call to 0x1fe6, returns to 0x1B49 label_1B49: // Incoming return from call to 0x1FE6 at 0x1B48 // Inputs[2] // { // @1B52 stack[-3] // @1B61 memory[0x00:0x40] // } 1B49 5B JUMPDEST 1B4A 60 PUSH1 0x01 1B4C 60 PUSH1 0x01 1B4E 60 PUSH1 0xa0 1B50 1B SHL 1B51 03 SUB 1B52 83 DUP4 1B53 16 AND 1B54 60 PUSH1 0x00 1B56 90 SWAP1 1B57 81 DUP2 1B58 52 MSTORE 1B59 60 PUSH1 0x03 1B5B 60 PUSH1 0x20 1B5D 52 MSTORE 1B5E 60 PUSH1 0x40 1B60 90 SWAP1 1B61 20 SHA3 1B62 61 PUSH2 0x1b6a 1B65 90 SWAP1 1B66 61 PUSH2 0x2023 1B69 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1B58 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1B5D memory[0x20:0x40] = 0x03 // @1B65 stack[0] = 0x1b6a // @1B65 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2023, returns to 0x1B6A label_1B6A: // Incoming return from call to 0x2023 at 0x1B69 // Inputs[2] // { // @1B73 stack[-2] // @1B82 memory[0x00:0x40] // } 1B6A 5B JUMPDEST 1B6B 60 PUSH1 0x01 1B6D 60 PUSH1 0x01 1B6F 60 PUSH1 0xa0 1B71 1B SHL 1B72 03 SUB 1B73 82 DUP3 1B74 16 AND 1B75 60 PUSH1 0x00 1B77 90 SWAP1 1B78 81 DUP2 1B79 52 MSTORE 1B7A 60 PUSH1 0x03 1B7C 60 PUSH1 0x20 1B7E 52 MSTORE 1B7F 60 PUSH1 0x40 1B81 90 SWAP1 1B82 20 SHA3 1B83 61 PUSH2 0x1b8b 1B86 90 SWAP1 1B87 61 PUSH2 0x195d 1B8A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1B79 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1B7E memory[0x20:0x40] = 0x03 // @1B86 stack[0] = 0x1b8b // @1B86 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x195d, returns to 0x1B8B label_1B8B: // Incoming return from call to 0x195D at 0x1B8A // Inputs[8] // { // @1B8E stack[-1] // @1B9A memory[0x00:0x40] // @1B9C storage[keccak256(memory[0x00:0x40])] // @1BAF stack[-2] // @1BB9 memory[0x40:0x60] // @1BBD stack[-3] // @1BE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1BE6 stack[-4] // } 1B8B 5B JUMPDEST 1B8C 60 PUSH1 0x00 1B8E 81 DUP2 1B8F 81 DUP2 1B90 52 MSTORE 1B91 60 PUSH1 0x01 1B93 60 PUSH1 0x20 1B95 52 MSTORE 1B96 60 PUSH1 0x40 1B98 80 DUP1 1B99 82 DUP3 1B9A 20 SHA3 1B9B 80 DUP1 1B9C 54 SLOAD 1B9D 60 PUSH1 0x01 1B9F 60 PUSH1 0x01 1BA1 60 PUSH1 0xa0 1BA3 1B SHL 1BA4 03 SUB 1BA5 19 NOT 1BA6 16 AND 1BA7 60 PUSH1 0x01 1BA9 60 PUSH1 0x01 1BAB 60 PUSH1 0xa0 1BAD 1B SHL 1BAE 03 SUB 1BAF 86 DUP7 1BB0 81 DUP2 1BB1 16 AND 1BB2 91 SWAP2 1BB3 82 DUP3 1BB4 17 OR 1BB5 90 SWAP1 1BB6 92 SWAP3 1BB7 55 SSTORE 1BB8 91 SWAP2 1BB9 51 MLOAD 1BBA 84 DUP5 1BBB 93 SWAP4 1BBC 91 SWAP2 1BBD 87 DUP8 1BBE 16 AND 1BBF 91 SWAP2 1BC0 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1BE1 91 SWAP2 1BE2 A4 LOG4 1BE3 50 POP 1BE4 50 POP 1BE5 50 POP 1BE6 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1B90 memory[0x00:0x20] = stack[-1] // @1B95 memory[0x20:0x40] = 0x01 // @1BB7 storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1BE2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); // } // Block ends with unconditional jump to stack[-4] label_1BE7: // Incoming call from 0x1952, returns to 0x1953 // Inputs[3] // { // @1BF0 stack[-2] // @1BFF memory[0x00:0x40] // @1C00 storage[keccak256(memory[0x00:0x40])] // } 1BE7 5B JUMPDEST 1BE8 60 PUSH1 0x01 1BEA 60 PUSH1 0x01 1BEC 60 PUSH1 0xa0 1BEE 1B SHL 1BEF 03 SUB 1BF0 82 DUP3 1BF1 16 AND 1BF2 60 PUSH1 0x00 1BF4 90 SWAP1 1BF5 81 DUP2 1BF6 52 MSTORE 1BF7 60 PUSH1 0x05 1BF9 60 PUSH1 0x20 1BFB 52 MSTORE 1BFC 60 PUSH1 0x40 1BFE 81 DUP2 1BFF 20 SHA3 1C00 54 SLOAD 1C01 61 PUSH2 0x1c11 1C04 90 SWAP1 1C05 60 PUSH1 0x01 1C07 63 PUSH4 0xffffffff 1C0C 61 PUSH2 0x203a 1C0F 16 AND 1C10 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1BF4 stack[0] = 0x00 // @1BF6 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1BFB memory[0x20:0x40] = 0x05 // @1C04 stack[2] = storage[keccak256(memory[0x00:0x40])] // @1C04 stack[1] = 0x1c11 // @1C05 stack[3] = 0x01 // } // Block ends with call to 0x203a & 0xffffffff, returns to 0x1C11 label_1C11: // Incoming return from call to 0x203A at 0x1C10 // Inputs[5] // { // @1C14 stack[-3] // @1C1F memory[0x00:0x40] // @1C20 storage[keccak256(memory[0x00:0x40])] // @1C21 stack[-1] // @1C22 stack[-2] // } 1C11 5B JUMPDEST 1C12 60 PUSH1 0x00 1C14 83 DUP4 1C15 81 DUP2 1C16 52 MSTORE 1C17 60 PUSH1 0x06 1C19 60 PUSH1 0x20 1C1B 52 MSTORE 1C1C 60 PUSH1 0x40 1C1E 90 SWAP1 1C1F 20 SHA3 1C20 54 SLOAD 1C21 90 SWAP1 1C22 91 SWAP2 1C23 50 POP 1C24 80 DUP1 1C25 82 DUP3 1C26 14 EQ 1C27 61 PUSH2 0x1cac 1C2A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1C16 memory[0x00:0x20] = stack[-3] // @1C1B memory[0x20:0x40] = 0x06 // @1C21 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @1C22 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x1cac, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_1C2B: // Incoming jump from 0x1C2A, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @1C33 stack[-4] // @1C42 memory[0x00:0x40] // @1C44 storage[keccak256(memory[0x00:0x40])] // @1C45 stack[-2] // } 1C2B 60 PUSH1 0x01 1C2D 60 PUSH1 0x01 1C2F 60 PUSH1 0xa0 1C31 1B SHL 1C32 03 SUB 1C33 84 DUP5 1C34 16 AND 1C35 60 PUSH1 0x00 1C37 90 SWAP1 1C38 81 DUP2 1C39 52 MSTORE 1C3A 60 PUSH1 0x05 1C3C 60 PUSH1 0x20 1C3E 52 MSTORE 1C3F 60 PUSH1 0x40 1C41 81 DUP2 1C42 20 SHA3 1C43 80 DUP1 1C44 54 SLOAD 1C45 84 DUP5 1C46 90 SWAP1 1C47 81 DUP2 1C48 10 LT 1C49 61 PUSH2 0x1c4e 1C4C 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @1C37 stack[0] = 0x00 // @1C39 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1C3E memory[0x20:0x40] = 0x05 // @1C42 stack[1] = keccak256(memory[0x00:0x40]) // @1C46 stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1c4e, if stack[-2] < storage[keccak256(memory[0x00:0x40])] label_1C4D: // Incoming jump from 0x1C4C, if not stack[-2] < storage[keccak256(memory[0x00:0x40])] 1C4D FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C4D assert(); } // Block terminates label_1C4E: // Incoming jump from 0x1C4C, if stack[-2] < storage[keccak256(memory[0x00:0x40])] // Inputs[9] // { // @1C4F stack[-2] // @1C4F stack[-1] // @1C57 memory[0x00:0x20] // @1C59 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1C5A stack[-3] // @1C61 stack[-7] // @1C81 memory[0x00:0x40] // @1C82 stack[-4] // @1C84 storage[keccak256(memory[0x00:0x40])] // } 1C4E 5B JUMPDEST 1C4F 90 SWAP1 1C50 60 PUSH1 0x00 1C52 52 MSTORE 1C53 60 PUSH1 0x20 1C55 60 PUSH1 0x00 1C57 20 SHA3 1C58 01 ADD 1C59 54 SLOAD 1C5A 90 SWAP1 1C5B 50 POP 1C5C 80 DUP1 1C5D 60 PUSH1 0x05 1C5F 60 PUSH1 0x00 1C61 87 DUP8 1C62 60 PUSH1 0x01 1C64 60 PUSH1 0x01 1C66 60 PUSH1 0xa0 1C68 1B SHL 1C69 03 SUB 1C6A 16 AND 1C6B 60 PUSH1 0x01 1C6D 60 PUSH1 0x01 1C6F 60 PUSH1 0xa0 1C71 1B SHL 1C72 03 SUB 1C73 16 AND 1C74 81 DUP2 1C75 52 MSTORE 1C76 60 PUSH1 0x20 1C78 01 ADD 1C79 90 SWAP1 1C7A 81 DUP2 1C7B 52 MSTORE 1C7C 60 PUSH1 0x20 1C7E 01 ADD 1C7F 60 PUSH1 0x00 1C81 20 SHA3 1C82 83 DUP4 1C83 81 DUP2 1C84 54 SLOAD 1C85 81 DUP2 1C86 10 LT 1C87 61 PUSH2 0x1c8c 1C8A 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @1C52 memory[0x00:0x20] = stack[-2] // @1C5A stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1C5C stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1C75 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-7] // @1C7B memory[0x20:0x40] = 0x05 // @1C81 stack[-1] = keccak256(memory[0x00:0x40]) // @1C82 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x1c8c, if stack[-4] < storage[keccak256(memory[0x00:0x40])] label_1C8B: // Incoming jump from 0x1C8A, if not stack[-4] < storage[keccak256(memory[0x00:0x40])] 1C8B FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C8B assert(); } // Block terminates label_1C8C: // Incoming jump from 0x1C8A, if stack[-4] < storage[keccak256(memory[0x00:0x40])] // Inputs[7] // { // @1C8F stack[-2] // @1C96 memory[0x00:0x20] // @1C98 stack[-1] // @1C9A stack[-3] // @1C9E stack[-4] // @1CA8 memory[0x00:0x40] // @1CA9 stack[-5] // } 1C8C 5B JUMPDEST 1C8D 60 PUSH1 0x00 1C8F 91 SWAP2 1C90 82 DUP3 1C91 52 MSTORE 1C92 60 PUSH1 0x20 1C94 80 DUP1 1C95 83 DUP4 1C96 20 SHA3 1C97 90 SWAP1 1C98 91 SWAP2 1C99 01 ADD 1C9A 92 SWAP3 1C9B 90 SWAP1 1C9C 92 SWAP3 1C9D 55 SSTORE 1C9E 91 SWAP2 1C9F 82 DUP3 1CA0 52 MSTORE 1CA1 60 PUSH1 0x06 1CA3 90 SWAP1 1CA4 52 MSTORE 1CA5 60 PUSH1 0x40 1CA7 90 SWAP1 1CA8 20 SHA3 1CA9 81 DUP2 1CAA 90 SWAP1 1CAB 55 SSTORE // Stack delta = -4 // Outputs[5] // { // @1C91 memory[0x00:0x20] = stack[-2] // @1C9D storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @1CA0 memory[0x00:0x20] = stack[-4] // @1CA4 memory[0x20:0x40] = 0x06 // @1CAB storage[keccak256(memory[0x00:0x40])] = stack[-5] // } // Block continues label_1CAC: // Incoming jump from 0x1C2A, if stack[-1] == storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1CAB // Inputs[3] // { // @1CB5 stack[-4] // @1CC4 memory[0x00:0x40] // @1CC6 storage[keccak256(memory[0x00:0x40])] // } 1CAC 5B JUMPDEST 1CAD 60 PUSH1 0x01 1CAF 60 PUSH1 0x01 1CB1 60 PUSH1 0xa0 1CB3 1B SHL 1CB4 03 SUB 1CB5 84 DUP5 1CB6 16 AND 1CB7 60 PUSH1 0x00 1CB9 90 SWAP1 1CBA 81 DUP2 1CBB 52 MSTORE 1CBC 60 PUSH1 0x05 1CBE 60 PUSH1 0x20 1CC0 52 MSTORE 1CC1 60 PUSH1 0x40 1CC3 90 SWAP1 1CC4 20 SHA3 1CC5 80 DUP1 1CC6 54 SLOAD 1CC7 90 SWAP1 1CC8 61 PUSH2 0x1cd5 1CCB 90 SWAP1 1CCC 60 PUSH1 0x00 1CCE 19 NOT 1CCF 83 DUP4 1CD0 01 ADD 1CD1 61 PUSH2 0x21cf 1CD4 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1CBB memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1CC0 memory[0x20:0x40] = 0x05 // @1CC7 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1CCB stack[1] = 0x1cd5 // @1CCB stack[2] = keccak256(memory[0x00:0x40]) // @1CD0 stack[3] = storage[keccak256(memory[0x00:0x40])] + ~0x00 // } // Block ends with call to 0x21cf, returns to 0x1CD5 label_1CD5: // Incoming return from call to 0x21CF at 0x1CD4 // Inputs[1] { @1CDB stack[-6] } 1CD5 5B JUMPDEST 1CD6 50 POP 1CD7 50 POP 1CD8 50 POP 1CD9 50 POP 1CDA 50 POP 1CDB 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_1CDC: // Incoming call from 0x197D, returns to 0x197E // Incoming call from 0x195C, returns to 0x09B7 // Inputs[7] // { // @1CE5 stack[-1] // @1CE6 stack[-2] // @1CF8 memory[0x00:0x40] // @1CFA storage[keccak256(memory[0x00:0x40])] // @1D04 memory[0x00:0x40] // @1D16 memory[0x00:0x20] // @1D19 stack[-3] // } 1CDC 5B JUMPDEST 1CDD 60 PUSH1 0x01 1CDF 60 PUSH1 0x01 1CE1 60 PUSH1 0xa0 1CE3 1B SHL 1CE4 03 SUB 1CE5 90 SWAP1 1CE6 91 SWAP2 1CE7 16 AND 1CE8 60 PUSH1 0x00 1CEA 90 SWAP1 1CEB 81 DUP2 1CEC 52 MSTORE 1CED 60 PUSH1 0x05 1CEF 60 PUSH1 0x20 1CF1 81 DUP2 1CF2 81 DUP2 1CF3 52 MSTORE 1CF4 60 PUSH1 0x40 1CF6 80 DUP1 1CF7 84 DUP5 1CF8 20 SHA3 1CF9 80 DUP1 1CFA 54 SLOAD 1CFB 86 DUP7 1CFC 86 DUP7 1CFD 52 MSTORE 1CFE 60 PUSH1 0x06 1D00 84 DUP5 1D01 52 MSTORE 1D02 91 SWAP2 1D03 85 DUP6 1D04 20 SHA3 1D05 82 DUP3 1D06 90 SWAP1 1D07 55 SSTORE 1D08 92 SWAP3 1D09 82 DUP3 1D0A 52 MSTORE 1D0B 60 PUSH1 0x01 1D0D 81 DUP2 1D0E 01 ADD 1D0F 83 DUP4 1D10 55 SSTORE 1D11 91 SWAP2 1D12 83 DUP4 1D13 52 MSTORE 1D14 90 SWAP1 1D15 91 SWAP2 1D16 20 SHA3 1D17 01 ADD 1D18 55 SSTORE 1D19 56 *JUMP // Stack delta = -3 // Outputs[9] // { // @1CEC memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1CF3 memory[0x20:0x40] = 0x05 // @1CFD memory[0x00:0x20] = stack[-1] // @1D01 memory[0x20:0x40] = 0x06 // @1D07 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @1D0A memory[0x20:0x40] = 0x05 // @1D10 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @1D13 memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @1D18 storage[keccak256(memory[0x00:0x20]) + storage[keccak256(memory[0x00:0x40])]] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_1D1A: // Incoming call from 0x1973, returns to 0x1974 // Inputs[1] { @1D23 stack[-2] } 1D1A 5B JUMPDEST 1D1B 60 PUSH1 0x01 1D1D 60 PUSH1 0x01 1D1F 60 PUSH1 0xa0 1D21 1B SHL 1D22 03 SUB 1D23 82 DUP3 1D24 16 AND 1D25 61 PUSH2 0x1d75 1D28 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d75, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1D29: // Incoming jump from 0x1D28, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1D2C memory[0x40:0x60] // @1D6B memory[0x40:0x60] // @1D74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1D29 60 PUSH1 0x40 1D2B 80 DUP1 1D2C 51 MLOAD 1D2D 62 PUSH3 0x461bcd 1D31 60 PUSH1 0xe5 1D33 1B SHL 1D34 81 DUP2 1D35 52 MSTORE 1D36 60 PUSH1 0x20 1D38 60 PUSH1 0x04 1D3A 82 DUP3 1D3B 01 ADD 1D3C 81 DUP2 1D3D 90 SWAP1 1D3E 52 MSTORE 1D3F 60 PUSH1 0x24 1D41 82 DUP3 1D42 01 ADD 1D43 52 MSTORE 1D44 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 1D65 60 PUSH1 0x44 1D67 82 DUP3 1D68 01 ADD 1D69 52 MSTORE 1D6A 90 SWAP1 1D6B 51 MLOAD 1D6C 90 SWAP1 1D6D 81 DUP2 1D6E 90 SWAP1 1D6F 03 SUB 1D70 60 PUSH1 0x64 1D72 01 ADD 1D73 90 SWAP1 1D74 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1D35 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D3E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D43 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1D69 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @1D74 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1D75: // Incoming jump from 0x1D28, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1D79 stack[-1] } 1D75 5B JUMPDEST 1D76 61 PUSH2 0x1d7e 1D79 81 DUP2 1D7A 61 PUSH2 0x1879 1D7D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D76 stack[0] = 0x1d7e // @1D79 stack[1] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x1D7E label_1D7E: // Incoming return from call to 0x1879 at 0x1D7D // Inputs[1] { @1D7F stack[-1] } 1D7E 5B JUMPDEST 1D7F 15 ISZERO 1D80 61 PUSH2 0x1dd0 1D83 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1dd0, if !stack[-1] label_1D84: // Incoming jump from 0x1D83, if not !stack[-1] // Inputs[3] // { // @1D87 memory[0x40:0x60] // @1DC6 memory[0x40:0x60] // @1DCF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1D84 60 PUSH1 0x40 1D86 80 DUP1 1D87 51 MLOAD 1D88 62 PUSH3 0x461bcd 1D8C 60 PUSH1 0xe5 1D8E 1B SHL 1D8F 81 DUP2 1D90 52 MSTORE 1D91 60 PUSH1 0x20 1D93 60 PUSH1 0x04 1D95 82 DUP3 1D96 01 ADD 1D97 52 MSTORE 1D98 60 PUSH1 0x1c 1D9A 60 PUSH1 0x24 1D9C 82 DUP3 1D9D 01 ADD 1D9E 52 MSTORE 1D9F 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 1DC0 60 PUSH1 0x44 1DC2 82 DUP3 1DC3 01 ADD 1DC4 52 MSTORE 1DC5 90 SWAP1 1DC6 51 MLOAD 1DC7 90 SWAP1 1DC8 81 DUP2 1DC9 90 SWAP1 1DCA 03 SUB 1DCB 60 PUSH1 0x64 1DCD 01 ADD 1DCE 90 SWAP1 1DCF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1D90 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D97 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D9E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @1DC4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @1DCF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1DD0: // Incoming jump from 0x1D83, if !stack[-1] // Inputs[5] // { // @1DD3 stack[-1] // @1DE1 memory[0x00:0x40] // @1DE3 storage[keccak256(memory[0x00:0x40])] // @1DF6 stack[-2] // @1E06 memory[0x00:0x40] // } 1DD0 5B JUMPDEST 1DD1 60 PUSH1 0x00 1DD3 81 DUP2 1DD4 81 DUP2 1DD5 52 MSTORE 1DD6 60 PUSH1 0x01 1DD8 60 PUSH1 0x20 1DDA 90 SWAP1 1DDB 81 DUP2 1DDC 52 MSTORE 1DDD 60 PUSH1 0x40 1DDF 80 DUP1 1DE0 83 DUP4 1DE1 20 SHA3 1DE2 80 DUP1 1DE3 54 SLOAD 1DE4 60 PUSH1 0x01 1DE6 60 PUSH1 0x01 1DE8 60 PUSH1 0xa0 1DEA 1B SHL 1DEB 03 SUB 1DEC 19 NOT 1DED 16 AND 1DEE 60 PUSH1 0x01 1DF0 60 PUSH1 0x01 1DF2 60 PUSH1 0xa0 1DF4 1B SHL 1DF5 03 SUB 1DF6 87 DUP8 1DF7 16 AND 1DF8 90 SWAP1 1DF9 81 DUP2 1DFA 17 OR 1DFB 90 SWAP1 1DFC 91 SWAP2 1DFD 55 SSTORE 1DFE 83 DUP4 1DFF 52 MSTORE 1E00 60 PUSH1 0x03 1E02 90 SWAP1 1E03 91 SWAP2 1E04 52 MSTORE 1E05 90 SWAP1 1E06 20 SHA3 1E07 61 PUSH2 0x1e0f 1E0A 90 SWAP1 1E0B 61 PUSH2 0x195d 1E0E 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @1DD5 memory[0x00:0x20] = stack[-1] // @1DDC memory[0x20:0x40] = 0x01 // @1DFD storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1DFF memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1E04 memory[0x20:0x40] = 0x03 // @1E0A stack[0] = 0x1e0f // @1E0A stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x195d, returns to 0x1E0F label_1E0F: // Incoming return from call to 0x195D at 0x1E0E // Inputs[5] // { // @1E12 memory[0x40:0x60] // @1E13 stack[-1] // @1E1D stack[-2] // @1E47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1E4A stack[-3] // } 1E0F 5B JUMPDEST 1E10 60 PUSH1 0x40 1E12 51 MLOAD 1E13 81 DUP2 1E14 90 SWAP1 1E15 60 PUSH1 0x01 1E17 60 PUSH1 0x01 1E19 60 PUSH1 0xa0 1E1B 1B SHL 1E1C 03 SUB 1E1D 84 DUP5 1E1E 16 AND 1E1F 90 SWAP1 1E20 60 PUSH1 0x00 1E22 90 SWAP1 1E23 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1E44 90 SWAP1 1E45 82 DUP3 1E46 90 SWAP1 1E47 A4 LOG4 1E48 50 POP 1E49 50 POP 1E4A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E47 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); } // Block ends with unconditional jump to stack[-3] label_1E4B: // Incoming call from 0x1986, returns to 0x1987 // Inputs[4] // { // @1E4F storage[0x07] // @1E52 stack[-1] // @1E5D memory[0x00:0x40] // @1E8E stack[-2] // } 1E4B 5B JUMPDEST 1E4C 60 PUSH1 0x07 1E4E 80 DUP1 1E4F 54 SLOAD 1E50 60 PUSH1 0x00 1E52 83 DUP4 1E53 81 DUP2 1E54 52 MSTORE 1E55 60 PUSH1 0x08 1E57 60 PUSH1 0x20 1E59 52 MSTORE 1E5A 60 PUSH1 0x40 1E5C 81 DUP2 1E5D 20 SHA3 1E5E 82 DUP3 1E5F 90 SWAP1 1E60 55 SSTORE 1E61 60 PUSH1 0x01 1E63 82 DUP3 1E64 01 ADD 1E65 83 DUP4 1E66 55 SSTORE 1E67 91 SWAP2 1E68 90 SWAP1 1E69 91 SWAP2 1E6A 52 MSTORE 1E6B 7F PUSH32 0xa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688 1E8C 01 ADD 1E8D 55 SSTORE 1E8E 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @1E54 memory[0x00:0x20] = stack[-1] // @1E59 memory[0x20:0x40] = 0x08 // @1E60 storage[keccak256(memory[0x00:0x40])] = storage[0x07] // @1E66 storage[0x07] = storage[0x07] + 0x01 // @1E6A memory[0x00:0x20] = 0x07 // @1E8D storage[0xa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688 + storage[0x07]] = stack[-1] // } // Block ends with unconditional jump to stack[-2] 1E8F 5B JUMPDEST 1E90 60 PUSH1 0x00 1E92 61 PUSH2 0x1ea3 1E95 84 DUP5 1E96 60 PUSH1 0x01 1E98 60 PUSH1 0x01 1E9A 60 PUSH1 0xa0 1E9C 1B SHL 1E9D 03 SUB 1E9E 16 AND 1E9F 61 PUSH2 0x2083 1EA2 56 *JUMP 1EA3 5B JUMPDEST 1EA4 61 PUSH2 0x1eaf 1EA7 57 *JUMPI 1EA8 50 POP 1EA9 60 PUSH1 0x01 1EAB 61 PUSH2 0x1936 1EAE 56 *JUMP 1EAF 5B JUMPDEST 1EB0 60 PUSH1 0x00 1EB2 84 DUP5 1EB3 60 PUSH1 0x01 1EB5 60 PUSH1 0x01 1EB7 60 PUSH1 0xa0 1EB9 1B SHL 1EBA 03 SUB 1EBB 16 AND 1EBC 63 PUSH4 0x150b7a02 1EC1 61 PUSH2 0x1ec8 1EC4 61 PUSH2 0x1896 1EC7 56 *JUMP 1EC8 5B JUMPDEST 1EC9 88 DUP9 1ECA 87 DUP8 1ECB 87 DUP8 1ECC 60 PUSH1 0x40 1ECE 51 MLOAD 1ECF 85 DUP6 1ED0 63 PUSH4 0xffffffff 1ED5 16 AND 1ED6 60 PUSH1 0xe0 1ED8 1B SHL 1ED9 81 DUP2 1EDA 52 MSTORE 1EDB 60 PUSH1 0x04 1EDD 01 ADD 1EDE 80 DUP1 1EDF 85 DUP6 1EE0 60 PUSH1 0x01 1EE2 60 PUSH1 0x01 1EE4 60 PUSH1 0xa0 1EE6 1B SHL 1EE7 03 SUB 1EE8 16 AND 1EE9 60 PUSH1 0x01 1EEB 60 PUSH1 0x01 1EED 60 PUSH1 0xa0 1EEF 1B SHL 1EF0 03 SUB 1EF1 16 AND 1EF2 81 DUP2 1EF3 52 MSTORE 1EF4 60 PUSH1 0x20 1EF6 01 ADD 1EF7 84 DUP5 1EF8 60 PUSH1 0x01 1EFA 60 PUSH1 0x01 1EFC 60 PUSH1 0xa0 1EFE 1B SHL 1EFF 03 SUB 1F00 16 AND 1F01 60 PUSH1 0x01 1F03 60 PUSH1 0x01 1F05 60 PUSH1 0xa0 1F07 1B SHL 1F08 03 SUB 1F09 16 AND 1F0A 81 DUP2 1F0B 52 MSTORE 1F0C 60 PUSH1 0x20 1F0E 01 ADD 1F0F 83 DUP4 1F10 81 DUP2 1F11 52 MSTORE 1F12 60 PUSH1 0x20 1F14 01 ADD 1F15 80 DUP1 1F16 60 PUSH1 0x20 1F18 01 ADD 1F19 82 DUP3 1F1A 81 DUP2 1F1B 03 SUB 1F1C 82 DUP3 1F1D 52 MSTORE 1F1E 83 DUP4 1F1F 81 DUP2 1F20 81 DUP2 1F21 51 MLOAD 1F22 81 DUP2 1F23 52 MSTORE 1F24 60 PUSH1 0x20 1F26 01 ADD 1F27 91 SWAP2 1F28 50 POP 1F29 80 DUP1 1F2A 51 MLOAD 1F2B 90 SWAP1 1F2C 60 PUSH1 0x20 1F2E 01 ADD 1F2F 90 SWAP1 1F30 80 DUP1 1F31 83 DUP4 1F32 83 DUP4 1F33 60 PUSH1 0x00 1F35 5B JUMPDEST 1F36 83 DUP4 1F37 81 DUP2 1F38 10 LT 1F39 15 ISZERO 1F3A 61 PUSH2 0x1f4d 1F3D 57 *JUMPI 1F3E 81 DUP2 1F3F 81 DUP2 1F40 01 ADD 1F41 51 MLOAD 1F42 83 DUP4 1F43 82 DUP3 1F44 01 ADD 1F45 52 MSTORE 1F46 60 PUSH1 0x20 1F48 01 ADD 1F49 61 PUSH2 0x1f35 1F4C 56 *JUMP 1F4D 5B JUMPDEST 1F4E 50 POP 1F4F 50 POP 1F50 50 POP 1F51 50 POP 1F52 90 SWAP1 1F53 50 POP 1F54 90 SWAP1 1F55 81 DUP2 1F56 01 ADD 1F57 90 SWAP1 1F58 60 PUSH1 0x1f 1F5A 16 AND 1F5B 80 DUP1 1F5C 15 ISZERO 1F5D 61 PUSH2 0x1f7a 1F60 57 *JUMPI 1F61 80 DUP1 1F62 82 DUP3 1F63 03 SUB 1F64 80 DUP1 1F65 51 MLOAD 1F66 60 PUSH1 0x01 1F68 83 DUP4 1F69 60 PUSH1 0x20 1F6B 03 SUB 1F6C 61 PUSH2 0x0100 1F6F 0A EXP 1F70 03 SUB 1F71 19 NOT 1F72 16 AND 1F73 81 DUP2 1F74 52 MSTORE 1F75 60 PUSH1 0x20 1F77 01 ADD 1F78 91 SWAP2 1F79 50 POP 1F7A 5B JUMPDEST 1F7B 50 POP 1F7C 95 SWAP6 1F7D 50 POP 1F7E 50 POP 1F7F 50 POP 1F80 50 POP 1F81 50 POP 1F82 50 POP 1F83 60 PUSH1 0x20 1F85 60 PUSH1 0x40 1F87 51 MLOAD 1F88 80 DUP1 1F89 83 DUP4 1F8A 03 SUB 1F8B 81 DUP2 1F8C 60 PUSH1 0x00 1F8E 87 DUP8 1F8F 80 DUP1 1F90 3B EXTCODESIZE 1F91 15 ISZERO 1F92 80 DUP1 1F93 15 ISZERO 1F94 61 PUSH2 0x1f9c 1F97 57 *JUMPI 1F98 60 PUSH1 0x00 1F9A 80 DUP1 1F9B FD *REVERT 1F9C 5B JUMPDEST 1F9D 50 POP 1F9E 5A GAS 1F9F F1 CALL 1FA0 15 ISZERO 1FA1 80 DUP1 1FA2 15 ISZERO 1FA3 61 PUSH2 0x1fb0 1FA6 57 *JUMPI 1FA7 3D RETURNDATASIZE 1FA8 60 PUSH1 0x00 1FAA 80 DUP1 1FAB 3E RETURNDATACOPY 1FAC 3D RETURNDATASIZE 1FAD 60 PUSH1 0x00 1FAF FD *REVERT 1FB0 5B JUMPDEST 1FB1 50 POP 1FB2 50 POP 1FB3 50 POP 1FB4 50 POP 1FB5 60 PUSH1 0x40 1FB7 51 MLOAD 1FB8 3D RETURNDATASIZE 1FB9 60 PUSH1 0x20 1FBB 81 DUP2 1FBC 10 LT 1FBD 15 ISZERO 1FBE 61 PUSH2 0x1fc6 1FC1 57 *JUMPI 1FC2 60 PUSH1 0x00 1FC4 80 DUP1 1FC5 FD *REVERT 1FC6 5B JUMPDEST 1FC7 50 POP 1FC8 51 MLOAD 1FC9 60 PUSH1 0x01 1FCB 60 PUSH1 0x01 1FCD 60 PUSH1 0xe0 1FCF 1B SHL 1FD0 03 SUB 1FD1 19 NOT 1FD2 16 AND 1FD3 63 PUSH4 0x0a85bd01 1FD8 60 PUSH1 0xe1 1FDA 1B SHL 1FDB 14 EQ 1FDC 91 SWAP2 1FDD 50 POP 1FDE 50 POP 1FDF 94 SWAP5 1FE0 93 SWAP4 1FE1 50 POP 1FE2 50 POP 1FE3 50 POP 1FE4 50 POP 1FE5 56 *JUMP label_1FE6: // Incoming call from 0x1B48, returns to 0x1B49 // Inputs[3] // { // @1FE9 stack[-1] // @1FF4 memory[0x00:0x40] // @1FF5 storage[keccak256(memory[0x00:0x40])] // } 1FE6 5B JUMPDEST 1FE7 60 PUSH1 0x00 1FE9 81 DUP2 1FEA 81 DUP2 1FEB 52 MSTORE 1FEC 60 PUSH1 0x02 1FEE 60 PUSH1 0x20 1FF0 52 MSTORE 1FF1 60 PUSH1 0x40 1FF3 90 SWAP1 1FF4 20 SHA3 1FF5 54 SLOAD 1FF6 60 PUSH1 0x01 1FF8 60 PUSH1 0x01 1FFA 60 PUSH1 0xa0 1FFC 1B SHL 1FFD 03 SUB 1FFE 16 AND 1FFF 15 ISZERO 2000 61 PUSH2 0x2020 2003 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1FEB memory[0x00:0x20] = stack[-1] // @1FF0 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x2020, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_2004: // Incoming jump from 0x2003, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2006 stack[-1] // @2011 memory[0x00:0x40] // @2013 storage[keccak256(memory[0x00:0x40])] // @2022 stack[-2] // } 2004 60 PUSH1 0x00 2006 81 DUP2 2007 81 DUP2 2008 52 MSTORE 2009 60 PUSH1 0x02 200B 60 PUSH1 0x20 200D 52 MSTORE 200E 60 PUSH1 0x40 2010 90 SWAP1 2011 20 SHA3 2012 80 DUP1 2013 54 SLOAD 2014 60 PUSH1 0x01 2016 60 PUSH1 0x01 2018 60 PUSH1 0xa0 201A 1B SHL 201B 03 SUB 201C 19 NOT 201D 16 AND 201E 90 SWAP1 201F 55 SSTORE 2020 5B JUMPDEST 2021 50 POP 2022 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @2008 memory[0x00:0x20] = stack[-1] // @200D memory[0x20:0x40] = 0x02 // @201F storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_2023: // Incoming call from 0x1B69, returns to 0x1B6A // Inputs[2] // { // @2024 stack[-1] // @2025 storage[stack[-1]] // } 2023 5B JUMPDEST 2024 80 DUP1 2025 54 SLOAD 2026 61 PUSH2 0x2036 2029 90 SWAP1 202A 60 PUSH1 0x01 202C 63 PUSH4 0xffffffff 2031 61 PUSH2 0x203a 2034 16 AND 2035 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2029 stack[0] = 0x2036 // @2029 stack[1] = storage[stack[-1]] // @202A stack[2] = 0x01 // } // Block ends with call to 0x203a & 0xffffffff, returns to 0x2036 label_2036: // Incoming return from call to 0x203A at 0x2035 // Inputs[3] // { // @2037 stack[-1] // @2037 stack[-2] // @2039 stack[-3] // } 2036 5B JUMPDEST 2037 90 SWAP1 2038 55 SSTORE 2039 56 *JUMP // Stack delta = -3 // Outputs[1] { @2038 storage[stack[-2]] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_203A: // Incoming call from 0x1C10, returns to 0x1C11 // Incoming call from 0x2035, returns to 0x2036 // Inputs[3] // { // @2040 stack[-2] // @2041 stack[-1] // @2044 memory[0x40:0x60] // } 203A 5B JUMPDEST 203B 60 PUSH1 0x00 203D 61 PUSH2 0x207c 2040 83 DUP4 2041 83 DUP4 2042 60 PUSH1 0x40 2044 51 MLOAD 2045 80 DUP1 2046 60 PUSH1 0x40 2048 01 ADD 2049 60 PUSH1 0x40 204B 52 MSTORE 204C 80 DUP1 204D 60 PUSH1 0x1e 204F 81 DUP2 2050 52 MSTORE 2051 60 PUSH1 0x20 2053 01 ADD 2054 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 2075 81 DUP2 2076 52 MSTORE 2077 50 POP 2078 61 PUSH2 0x20ba 207B 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @203B stack[0] = 0x00 // @203D stack[1] = 0x207c // @2040 stack[2] = stack[-2] // @2041 stack[3] = stack[-1] // @2044 stack[4] = memory[0x40:0x60] // @204B memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2050 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @2076 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // } // Block ends with call to 0x20ba, returns to 0x207C label_207C: // Incoming return from call to 0x20BA at 0x207B // Inputs[3] // { // @207D stack[-5] // @207D stack[-1] // @207E stack[-4] // } 207C 5B JUMPDEST 207D 93 SWAP4 207E 92 SWAP3 207F 50 POP 2080 50 POP 2081 50 POP 2082 56 *JUMP // Stack delta = -4 // Outputs[1] { @207D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 2083 5B JUMPDEST 2084 60 PUSH1 0x00 2086 81 DUP2 2087 3F EXTCODEHASH 2088 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 20A9 81 DUP2 20AA 15 ISZERO 20AB 80 DUP1 20AC 15 ISZERO 20AD 90 SWAP1 20AE 61 PUSH2 0x1936 20B1 57 *JUMPI 20B2 50 POP 20B3 14 EQ 20B4 15 ISZERO 20B5 92 SWAP3 20B6 91 SWAP2 20B7 50 POP 20B8 50 POP 20B9 56 *JUMP label_20BA: // Incoming call from 0x207B, returns to 0x207C // Inputs[3] // { // @20BD stack[-1] // @20BE stack[-3] // @20BF stack[-2] // } 20BA 5B JUMPDEST 20BB 60 PUSH1 0x00 20BD 81 DUP2 20BE 84 DUP5 20BF 84 DUP5 20C0 11 GT 20C1 15 ISZERO 20C2 61 PUSH2 0x2149 20C5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20BB stack[0] = 0x00 // @20BD stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2149, if !(stack[-2] > stack[-3]) label_20C6: // Incoming jump from 0x20C5, if not !(stack[-2] > stack[-3]) // Inputs[4] // { // @20C8 memory[0x40:0x60] // @20DF stack[-1] // @20E2 memory[stack[-1]:stack[-1] + 0x20] // @20EB memory[stack[-1]:stack[-1] + 0x20] // } 20C6 60 PUSH1 0x40 20C8 51 MLOAD 20C9 62 PUSH3 0x461bcd 20CD 60 PUSH1 0xe5 20CF 1B SHL 20D0 81 DUP2 20D1 52 MSTORE 20D2 60 PUSH1 0x04 20D4 01 ADD 20D5 80 DUP1 20D6 80 DUP1 20D7 60 PUSH1 0x20 20D9 01 ADD 20DA 82 DUP3 20DB 81 DUP2 20DC 03 SUB 20DD 82 DUP3 20DE 52 MSTORE 20DF 83 DUP4 20E0 81 DUP2 20E1 81 DUP2 20E2 51 MLOAD 20E3 81 DUP2 20E4 52 MSTORE 20E5 60 PUSH1 0x20 20E7 01 ADD 20E8 91 SWAP2 20E9 50 POP 20EA 80 DUP1 20EB 51 MLOAD 20EC 90 SWAP1 20ED 60 PUSH1 0x20 20EF 01 ADD 20F0 90 SWAP1 20F1 80 DUP1 20F2 83 DUP4 20F3 83 DUP4 20F4 60 PUSH1 0x00 20F6 5B JUMPDEST 20F7 83 DUP4 20F8 81 DUP2 20F9 10 LT 20FA 15 ISZERO 20FB 61 PUSH2 0x210e 20FE 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @20D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @20D4 stack[0] = 0x04 + memory[0x40:0x60] // @20D5 stack[1] = 0x04 + memory[0x40:0x60] // @20DE memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @20E4 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @20E8 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @20F0 stack[3] = 0x20 + stack[-1] // @20F0 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @20F1 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @20F2 stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @20F3 stack[7] = 0x20 + stack[-1] // @20F4 stack[8] = 0x00 // } // Block ends with conditional jump to 0x210e, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_20FF: // Incoming jump from 0x20FE, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x20FE, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @20FF stack[-2] // @2100 stack[-1] // @2102 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2103 stack[-3] // } 20FF 81 DUP2 2100 81 DUP2 2101 01 ADD 2102 51 MLOAD 2103 83 DUP4 2104 82 DUP3 2105 01 ADD 2106 52 MSTORE 2107 60 PUSH1 0x20 2109 01 ADD 210A 61 PUSH2 0x20f6 210D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2106 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2109 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x20f6 label_210E: // Incoming jump from 0x20FE, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x20FE, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @2113 stack[-5] // @2113 stack[-6] // @2115 stack[-7] // } 210E 5B JUMPDEST 210F 50 POP 2110 50 POP 2111 50 POP 2112 50 POP 2113 90 SWAP1 2114 50 POP 2115 90 SWAP1 2116 81 DUP2 2117 01 ADD 2118 90 SWAP1 2119 60 PUSH1 0x1f 211B 16 AND 211C 80 DUP1 211D 15 ISZERO 211E 61 PUSH2 0x213b 2121 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2118 stack[-7] = stack[-5] + stack[-7] // @211B stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x213b, if !(0x1f & stack[-5]) label_2122: // Incoming jump from 0x2121, if not !(0x1f & stack[-5]) // Inputs[6] // { // @2122 stack[-1] // @2123 stack[-2] // @2126 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @213D stack[-5] // @2143 memory[0x40:0x60] // @2148 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 2122 80 DUP1 2123 82 DUP3 2124 03 SUB 2125 80 DUP1 2126 51 MLOAD 2127 60 PUSH1 0x01 2129 83 DUP4 212A 60 PUSH1 0x20 212C 03 SUB 212D 61 PUSH2 0x0100 2130 0A EXP 2131 03 SUB 2132 19 NOT 2133 16 AND 2134 81 DUP2 2135 52 MSTORE 2136 60 PUSH1 0x20 2138 01 ADD 2139 91 SWAP2 213A 50 POP 213B 5B JUMPDEST 213C 50 POP 213D 92 SWAP3 213E 50 POP 213F 50 POP 2140 50 POP 2141 60 PUSH1 0x40 2143 51 MLOAD 2144 80 DUP1 2145 91 SWAP2 2146 03 SUB 2147 90 SWAP1 2148 FD *REVERT // Stack delta = -5 // Outputs[2] // { // @2135 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2148 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_2149: // Incoming jump from 0x20C5, if !(stack[-2] > stack[-3]) // Inputs[3] // { // @214D stack[-4] // @214D stack[-5] // @214F stack[-6] // } 2149 5B JUMPDEST 214A 50 POP 214B 50 POP 214C 50 POP 214D 90 SWAP1 214E 03 SUB 214F 90 SWAP1 2150 56 *JUMP // Stack delta = -5 // Outputs[1] { @214F stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_2151: // Incoming jump from 0x0AC7 // Incoming jump from 0x19ED // Inputs[5] // { // @2152 stack[-3] // @2154 storage[stack[-3]] // @216E memory[0x00:0x20] // @2179 stack[-2] // @217A stack[-1] // } 2151 5B JUMPDEST 2152 82 DUP3 2153 80 DUP1 2154 54 SLOAD 2155 60 PUSH1 0x01 2157 81 DUP2 2158 60 PUSH1 0x01 215A 16 AND 215B 15 ISZERO 215C 61 PUSH2 0x0100 215F 02 MUL 2160 03 SUB 2161 16 AND 2162 60 PUSH1 0x02 2164 90 SWAP1 2165 04 DIV 2166 90 SWAP1 2167 60 PUSH1 0x00 2169 52 MSTORE 216A 60 PUSH1 0x20 216C 60 PUSH1 0x00 216E 20 SHA3 216F 90 SWAP1 2170 60 PUSH1 0x1f 2172 01 ADD 2173 60 PUSH1 0x20 2175 90 SWAP1 2176 04 DIV 2177 81 DUP2 2178 01 ADD 2179 92 SWAP3 217A 82 DUP3 217B 60 PUSH1 0x1f 217D 10 LT 217E 61 PUSH2 0x2192 2181 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2169 memory[0x00:0x20] = stack[-3] // @216F stack[0] = keccak256(memory[0x00:0x20]) // @2179 stack[1] = stack[-2] // @2179 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x2192, if 0x1f < stack[-1] label_2182: // Incoming jump from 0x2181, if not 0x1f < stack[-1] // Inputs[4] // { // @2182 stack[-1] // @2183 memory[stack[-1]:stack[-1] + 0x20] // @2188 stack[-3] // @218C stack[-5] // } 2182 80 DUP1 2183 51 MLOAD 2184 60 PUSH1 0xff 2186 19 NOT 2187 16 AND 2188 83 DUP4 2189 80 DUP1 218A 01 ADD 218B 17 OR 218C 85 DUP6 218D 55 SSTORE 218E 61 PUSH2 0x21bf 2191 56 *JUMP // Stack delta = +0 // Outputs[1] { @218D storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x21bf label_2192: // Incoming jump from 0x2181, if 0x1f < stack[-1] // Inputs[2] // { // @2193 stack[-3] // @2199 stack[-5] // } 2192 5B JUMPDEST 2193 82 DUP3 2194 80 DUP1 2195 01 ADD 2196 60 PUSH1 0x01 2198 01 ADD 2199 85 DUP6 219A 55 SSTORE 219B 82 DUP3 219C 15 ISZERO 219D 61 PUSH2 0x21bf 21A0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @219A storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x21bf, if !stack[-3] label_21A1: // Incoming jump from 0x21A0, if not !stack[-3] // Inputs[2] // { // @21A1 stack[-1] // @21A1 stack[-3] // } 21A1 91 SWAP2 21A2 82 DUP3 21A3 01 ADD 21A4 5B JUMPDEST 21A5 82 DUP3 21A6 81 DUP2 21A7 11 GT 21A8 15 ISZERO 21A9 61 PUSH2 0x21bf 21AC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @21A1 stack[-3] = stack[-1] // @21A3 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x21bf, if !(stack[-1] + stack[-3] > stack[-1]) label_21AD: // Incoming jump from 0x21AC, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x21AC, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @21AD stack[-3] // @21AE memory[stack[-3]:stack[-3] + 0x20] // @21AF stack[-2] // @21B1 stack[-1] // } 21AD 82 DUP3 21AE 51 MLOAD 21AF 82 DUP3 21B0 55 SSTORE 21B1 91 SWAP2 21B2 60 PUSH1 0x20 21B4 01 ADD 21B5 91 SWAP2 21B6 90 SWAP1 21B7 60 PUSH1 0x01 21B9 01 ADD 21BA 90 SWAP1 21BB 61 PUSH2 0x21a4 21BE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @21B0 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @21B5 stack[-3] = 0x20 + stack[-3] // @21BA stack[-2] = 0x01 + stack[-2] // @21BA stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x21a4 label_21BF: // Incoming jump from 0x21A0, if !stack[-3] // Incoming jump from 0x21AC, if !(stack[-1] > stack[-3]) // Incoming jump from 0x21AC, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2191 // Inputs[2] // { // @21C4 stack[-4] // @21C5 stack[-3] // } 21BF 5B JUMPDEST 21C0 50 POP 21C1 61 PUSH2 0x21cb 21C4 92 SWAP3 21C5 91 SWAP2 21C6 50 POP 21C7 61 PUSH2 0x21ef 21CA 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @21C4 stack[-4] = 0x21cb // @21C5 stack[-3] = stack[-4] // } // Block ends with call to 0x21ef, returns to 0x21CB label_21CB: // Incoming return from call to 0x21EF at 0x21CA // Incoming jump from 0x21FD, if !(stack[-2] > stack[-1]) // Incoming jump from 0x21FD, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @21CD stack[-3] // @21CD stack[-2] // } 21CB 5B JUMPDEST 21CC 50 POP 21CD 90 SWAP1 21CE 56 *JUMP // Stack delta = -2 // Outputs[1] { @21CD stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_21CF: // Incoming call from 0x1CD4, returns to 0x1CD5 // Inputs[3] // { // @21D0 stack[-2] // @21D1 storage[stack[-2]] // @21D2 stack[-1] // } 21CF 5B JUMPDEST 21D0 81 DUP2 21D1 54 SLOAD 21D2 81 DUP2 21D3 83 DUP4 21D4 55 SSTORE 21D5 81 DUP2 21D6 81 DUP2 21D7 11 GT 21D8 15 ISZERO 21D9 61 PUSH2 0x09b7 21DC 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @21D1 stack[0] = storage[stack[-2]] // @21D4 storage[stack[-2]] = stack[-1] // } // Block ends with conditional jump to 0x09b7, if !(storage[stack[-2]] > stack[-1]) label_21DD: // Incoming jump from 0x21DC, if not !(storage[stack[-2]] > stack[-1]) // Inputs[4] // { // @21DF stack[-3] // @21E5 memory[0x00:0x20] // @21E9 stack[-1] // @21ED stack[-2] // } 21DD 60 PUSH1 0x00 21DF 83 DUP4 21E0 81 DUP2 21E1 52 MSTORE 21E2 60 PUSH1 0x20 21E4 90 SWAP1 21E5 20 SHA3 21E6 61 PUSH2 0x09b7 21E9 91 SWAP2 21EA 81 DUP2 21EB 01 ADD 21EC 90 SWAP1 21ED 83 DUP4 21EE 01 ADD // Stack delta = +2 // Outputs[4] // { // @21E1 memory[0x00:0x20] = stack[-3] // @21E9 stack[-1] = 0x09b7 // @21EC stack[0] = keccak256(memory[0x00:0x20]) + stack[-1] // @21EE stack[1] = stack[-2] + keccak256(memory[0x00:0x20]) // } // Block continues label_21EF: // Incoming call from 0x21CA, returns to 0x21CB // Incoming jump from 0x21EE // Inputs[2] // { // @21F3 stack[-2] // @21F4 stack[-1] // } 21EF 5B JUMPDEST 21F0 61 PUSH2 0x07bb 21F3 91 SWAP2 21F4 90 SWAP1 21F5 5B JUMPDEST 21F6 80 DUP1 21F7 82 DUP3 21F8 11 GT 21F9 15 ISZERO 21FA 61 PUSH2 0x21cb 21FD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @21F3 stack[-2] = 0x07bb // @21F4 stack[-1] = stack[-2] // @21F4 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x21cb, if !(stack[-2] > stack[-1]) label_21FE: // Incoming jump from 0x21FD, if not !(stack[-2] > stack[-1]) // Incoming call from 0x21FD, returns to 0x07BB, if not !(stack[-2] > stack[-1]) // Inputs[1] { @2200 stack[-1] } 21FE 60 PUSH1 0x00 2200 81 DUP2 2201 55 SSTORE 2202 60 PUSH1 0x01 2204 01 ADD 2205 61 PUSH2 0x21f5 2208 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2201 storage[stack[-1]] = 0x00 // @2204 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x21f5 2209 FE *ASSERT 220A 45 GASLIMIT 220B 52 MSTORE 220C 43 NUMBER 220D 37 CALLDATACOPY 220E 32 ORIGIN 220F 31 BALANCE 2210 45 GASLIMIT 2211 6E PUSH15 0x756d657261626c653a206f776e6572 2221 20 SHA3 2222 69 PUSH10 0x6e646578206f7574206f 222D 66 PUSH7 0x20626f756e6473 2235 45 GASLIMIT 2236 52 MSTORE 2237 43 NUMBER 2238 37 CALLDATACOPY 2239 32 ORIGIN 223A 31 BALANCE 223B 3A GASPRICE 223C 20 SHA3 223D 74 PUSH21 0x72616e7366657220746f206e6f6e20455243373231 2253 52 MSTORE 2254 65 PUSH6 0x636569766572 225B 20 SHA3 225C 69 PUSH10 0x6d706c656d656e746572 2267 45 GASLIMIT 2268 52 MSTORE 2269 43 NUMBER 226A 37 CALLDATACOPY 226B 32 ORIGIN 226C 31 BALANCE 226D 3A GASPRICE 226E 20 SHA3 226F 74 PUSH21 0x72616e7366657220746f20746865207a65726f2061 2285 64 PUSH5 0x6472657373 228B 45 GASLIMIT 228C 52 MSTORE 228D 43 NUMBER 228E 37 CALLDATACOPY 228F 32 ORIGIN 2290 31 BALANCE 2291 3A GASPRICE 2292 20 SHA3 2293 6F PUSH16 0x70657261746f7220717565727920666f 22A4 72 PUSH19 0x206e6f6e6578697374656e7420746f6b656e45 22B8 52 MSTORE 22B9 43 NUMBER 22BA 37 CALLDATACOPY 22BB 32 ORIGIN 22BC 31 BALANCE 22BD 3A GASPRICE 22BE 20 SHA3 22BF 61 PUSH2 0x7070 22C2 72 PUSH19 0x6f76652063616c6c6572206973206e6f74206f 22D6 77 PUSH24 0x6e6572206e6f7220617070726f76656420666f7220616c6c 22EF 45 GASLIMIT 22F0 52 MSTORE 22F1 43 NUMBER 22F2 37 CALLDATACOPY 22F3 32 ORIGIN 22F4 31 BALANCE 22F5 3A GASPRICE 22F6 20 SHA3 22F7 62 PUSH3 0x616c61 22FB 6E PUSH15 0x636520717565727920666f72207468 230B 65 PUSH6 0x207a65726f20 2312 61 PUSH2 0x6464 2315 72 PUSH19 0x6573734552433732313a206f776e6572207175 2329 65 PUSH6 0x727920666f72 2330 20 SHA3 2331 6E PUSH15 0x6f6e6578697374656e7420746f6b65 2341 6E PUSH15 0x4552433732313a20617070726f7665 2351 64 PUSH5 0x2071756572 2357 79 PUSH26 0x20666f72206e6f6e6578697374656e7420746f6b656e45524337 2372 32 ORIGIN 2373 31 BALANCE 2374 4D 4D 2375 65 PUSH6 0x746164617461 237C 3A GASPRICE 237D 20 SHA3 237E 55 SSTORE 237F 52 MSTORE 2380 49 49 2381 20 SHA3 2382 73 PUSH20 0x6574206f66206e6f6e6578697374656e7420746f 2397 6B PUSH12 0x656e4552433732313a207472 23A4 61 PUSH2 0x6e73 23A7 66 PUSH7 0x6572206f662074 23AF 6F PUSH16 0x6b656e2074686174206973206e6f7420 23C0 6F PUSH16 0x776e4552433732314d65746164617461 23D1 3A GASPRICE 23D2 20 SHA3 23D3 55 SSTORE 23D4 52 MSTORE 23D5 49 49 23D6 20 SHA3 23D7 71 PUSH18 0x7565727920666f72206e6f6e657869737465 23EA 6E PUSH15 0x7420746f6b656e4552433732313a20 23FA 61 PUSH2 0x7070 23FD 72 PUSH19 0x6f76616c20746f2063757272656e74206f776e 2411 65 PUSH6 0x724552433732 2418 31 BALANCE 2419 3A GASPRICE 241A 20 SHA3 241B 74 PUSH21 0x72616e736665722063616c6c6572206973206e6f74 2431 20 SHA3 2432 6F PUSH16 0x776e6572206e6f7220617070726f7665 2443 64 PUSH5 0x4552433732 2449 31 BALANCE 244A 45 GASLIMIT 244B 6E PUSH15 0x756d657261626c653a20676c6f6261 245B 6C PUSH13 0x20696e646578206f7574206f66 2469 20 SHA3 246A 62 PUSH3 0x6f756e 246E 64 PUSH5 0x73a265627a 2474 7A PUSH27 0x72315820b17cc8de5c125bf1db18f217a6b5bc7c5312e723679b25 2490 AA AA 2491 88 DUP9 2492 35 CALLDATALOAD 2493 06 MOD 2494 D2 D2 2495 C7 C7 2496 F3 *RETURN 2497 79 PUSH26 0xe464736f6c63430005110032