Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x00c2 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x00c2, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x674fb1b4 0019 11 GT 001A 61 PUSH2 0x007f 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x007f, if 0x674fb1b4 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x674fb1b4 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xc9fd076e 0024 11 GT 0025 61 PUSH2 0x0059 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0059, if 0xc9fd076e > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc9fd076e > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc9fd076e 002F 14 EQ 0030 61 PUSH2 0x039e 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039e, if 0xc9fd076e == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc9fd076e == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd5e0da36 003A 14 EQ 003B 61 PUSH2 0x03cd 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cd, if 0xd5e0da36 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd5e0da36 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xd6eac95d 0045 14 EQ 0046 61 PUSH2 0x03fc 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fc, if 0xd6eac95d == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xd6eac95d == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe4dcb06b 0050 14 EQ 0051 61 PUSH2 0x0425 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0425, if 0xe4dcb06b == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe4dcb06b == stack[-1] 0055 61 PUSH2 0x00c2 0058 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00c2 label_0059: // Incoming jump from 0x0028, if 0xc9fd076e > stack[-1] // Inputs[1] { @005A stack[-1] } 0059 5B JUMPDEST 005A 80 DUP1 005B 63 PUSH4 0x674fb1b4 0060 14 EQ 0061 61 PUSH2 0x0302 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0302, if 0x674fb1b4 == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0x674fb1b4 == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0xa73b74fe 006B 14 EQ 006C 61 PUSH2 0x0331 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0331, if 0xa73b74fe == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xa73b74fe == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xb7760c8f 0076 14 EQ 0077 61 PUSH2 0x0372 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0372, if 0xb7760c8f == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xb7760c8f == stack[-1] 007B 61 PUSH2 0x00c2 007E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00c2 label_007F: // Incoming jump from 0x001D, if 0x674fb1b4 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0080 stack[-1] } 007F 5B JUMPDEST 0080 80 DUP1 0081 63 PUSH4 0x06fdde03 0086 14 EQ 0087 61 PUSH2 0x00c7 008A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c7, if 0x06fdde03 == stack[-1] label_008B: // Incoming jump from 0x008A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @008B stack[-1] } 008B 80 DUP1 008C 63 PUSH4 0x0aebeb4e 0091 14 EQ 0092 61 PUSH2 0x0151 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0151, if 0x0aebeb4e == stack[-1] label_0096: // Incoming jump from 0x0095, if not 0x0aebeb4e == stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0x0faee324 009C 14 EQ 009D 61 PUSH2 0x024c 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024c, if 0x0faee324 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x0faee324 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x111d9482 00A7 14 EQ 00A8 61 PUSH2 0x027b 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027b, if 0x111d9482 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x111d9482 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x2505c3d9 00B2 14 EQ 00B3 61 PUSH2 0x02aa 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02aa, if 0x2505c3d9 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x2505c3d9 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x369fb4a9 00BD 14 EQ 00BE 61 PUSH2 0x02d9 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d9, if 0x369fb4a9 == stack[-1] label_00C2: // Incoming jump from 0x0058 // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x007E // Incoming jump from 0x00C1, if not 0x369fb4a9 == stack[-1] // Inputs[1] { @00C6 memory[0x00:0x00] } 00C2 5B JUMPDEST 00C3 60 PUSH1 0x00 00C5 80 DUP1 00C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @00C6 revert(memory[0x00:0x00]); } // Block terminates label_00C7: // Incoming jump from 0x008A, if 0x06fdde03 == stack[-1] // Inputs[1] { @00C8 msg.value } 00C7 5B JUMPDEST 00C8 34 CALLVALUE 00C9 80 DUP1 00CA 15 ISZERO 00CB 61 PUSH2 0x00d3 00CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00C8 stack[0] = msg.value } // Block ends with conditional jump to 0x00d3, if !msg.value label_00CF: // Incoming jump from 0x00CE, if not !msg.value // Inputs[1] { @00D2 memory[0x00:0x00] } 00CF 60 PUSH1 0x00 00D1 80 DUP1 00D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D2 revert(memory[0x00:0x00]); } // Block terminates label_00D3: // Incoming jump from 0x00CE, if !msg.value 00D3 5B JUMPDEST 00D4 50 POP 00D5 61 PUSH2 0x00dc 00D8 61 PUSH2 0x0495 00DB 56 *JUMP // Stack delta = +0 // Outputs[1] { @00D5 stack[-1] = 0x00dc } // Block ends with call to 0x0495, returns to 0x00DC label_00DC: // Incoming return from call to 0x0495 at 0x00DB // Inputs[4] // { // @00E0 memory[0x40:0x60] // @00E6 stack[-1] // @00E7 memory[stack[-1]:stack[-1] + 0x20] // @00ED memory[stack[-1]:stack[-1] + 0x20] // } 00DC 5B JUMPDEST 00DD 60 PUSH1 0x40 00DF 80 DUP1 00E0 51 MLOAD 00E1 60 PUSH1 0x20 00E3 80 DUP1 00E4 82 DUP3 00E5 52 MSTORE 00E6 83 DUP4 00E7 51 MLOAD 00E8 81 DUP2 00E9 83 DUP4 00EA 01 ADD 00EB 52 MSTORE 00EC 83 DUP4 00ED 51 MLOAD 00EE 91 SWAP2 00EF 92 SWAP3 00F0 83 DUP4 00F1 92 SWAP3 00F2 90 SWAP1 00F3 83 DUP4 00F4 01 ADD 00F5 91 SWAP2 00F6 85 DUP6 00F7 01 ADD 00F8 90 SWAP1 00F9 80 DUP1 00FA 83 DUP4 00FB 83 DUP4 00FC 60 PUSH1 0x00 00FE 5B JUMPDEST 00FF 83 DUP4 0100 81 DUP2 0101 10 LT 0102 15 ISZERO 0103 61 PUSH2 0x0116 0106 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @00E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @00EB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @00EF stack[0] = memory[0x40:0x60] // @00F1 stack[1] = memory[0x40:0x60] // @00F5 stack[2] = memory[0x40:0x60] + 0x40 // @00F8 stack[3] = stack[-1] + 0x20 // @00F8 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @00F9 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @00FA stack[6] = memory[0x40:0x60] + 0x40 // @00FB stack[7] = stack[-1] + 0x20 // @00FC stack[8] = 0x00 // } // Block ends with conditional jump to 0x0116, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0107: // Incoming jump from 0x0106, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0106, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0107 stack[-2] // @0108 stack[-1] // @010A memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @010B stack[-3] // } 0107 81 DUP2 0108 81 DUP2 0109 01 ADD 010A 51 MLOAD 010B 83 DUP4 010C 82 DUP3 010D 01 ADD 010E 52 MSTORE 010F 60 PUSH1 0x20 0111 01 ADD 0112 61 PUSH2 0x00fe 0115 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @010E memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0111 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x00fe label_0116: // Incoming jump from 0x0106, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0106, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @011B stack[-5] // @011B stack[-6] // @011D stack[-7] // } 0116 5B JUMPDEST 0117 50 POP 0118 50 POP 0119 50 POP 011A 50 POP 011B 90 SWAP1 011C 50 POP 011D 90 SWAP1 011E 81 DUP2 011F 01 ADD 0120 90 SWAP1 0121 60 PUSH1 0x1f 0123 16 AND 0124 80 DUP1 0125 15 ISZERO 0126 61 PUSH2 0x0143 0129 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0120 stack[-7] = stack[-5] + stack[-7] // @0123 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0143, if !(0x1f & stack[-5]) label_012A: // Incoming jump from 0x0129, if not !(0x1f & stack[-5]) // Inputs[6] // { // @012A stack[-1] // @012B stack[-2] // @012E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0145 stack[-5] // @014B memory[0x40:0x60] // @0150 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 012A 80 DUP1 012B 82 DUP3 012C 03 SUB 012D 80 DUP1 012E 51 MLOAD 012F 60 PUSH1 0x01 0131 83 DUP4 0132 60 PUSH1 0x20 0134 03 SUB 0135 61 PUSH2 0x0100 0138 0A EXP 0139 03 SUB 013A 19 NOT 013B 16 AND 013C 81 DUP2 013D 52 MSTORE 013E 60 PUSH1 0x20 0140 01 ADD 0141 91 SWAP2 0142 50 POP 0143 5B JUMPDEST 0144 50 POP 0145 92 SWAP3 0146 50 POP 0147 50 POP 0148 50 POP 0149 60 PUSH1 0x40 014B 51 MLOAD 014C 80 DUP1 014D 91 SWAP2 014E 03 SUB 014F 90 SWAP1 0150 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @013D 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] // @0150 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0151: // Incoming jump from 0x0095, if 0x0aebeb4e == stack[-1] // Inputs[1] { @0158 msg.data.length } 0151 5B JUMPDEST 0152 61 PUSH2 0x016e 0155 60 PUSH1 0x04 0157 80 DUP1 0158 36 CALLDATASIZE 0159 03 SUB 015A 60 PUSH1 0x20 015C 81 DUP2 015D 10 LT 015E 15 ISZERO 015F 61 PUSH2 0x0167 0162 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0152 stack[0] = 0x016e // @0155 stack[1] = 0x04 // @0159 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0167, returns to 0x016E, if !(msg.data.length - 0x04 < 0x20) label_0163: // Incoming jump from 0x0162, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0166 memory[0x00:0x00] } 0163 60 PUSH1 0x00 0165 80 DUP1 0166 FD *REVERT // Stack delta = +0 // Outputs[1] { @0166 revert(memory[0x00:0x00]); } // Block terminates label_0167: // Incoming call from 0x0162, returns to 0x016E, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0169 stack[-2] // @0169 msg.data[stack[-2]:stack[-2] + 0x20] // } 0167 5B JUMPDEST 0168 50 POP 0169 35 CALLDATALOAD 016A 61 PUSH2 0x04be 016D 56 *JUMP // Stack delta = -1 // Outputs[1] { @0169 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x04be label_016E: // Incoming return from call to 0x03B4 at 0x03AF // Incoming return from call to 0x0388 at 0x0383 // Incoming return from call to 0x0318 at 0x0313 // Incoming return from call to 0x0167 at 0x0162 // Incoming return from call to 0x043B at 0x0436 // Inputs[4] // { // @0171 memory[0x40:0x60] // @0180 stack[-2] // @0183 memory[stack[-2]:stack[-2] + 0x20] // @018C memory[stack[-2]:stack[-2] + 0x20] // } 016E 5B JUMPDEST 016F 60 PUSH1 0x40 0171 51 MLOAD 0172 80 DUP1 0173 80 DUP1 0174 60 PUSH1 0x20 0176 01 ADD 0177 80 DUP1 0178 60 PUSH1 0x20 017A 01 ADD 017B 83 DUP4 017C 81 DUP2 017D 03 SUB 017E 83 DUP4 017F 52 MSTORE 0180 85 DUP6 0181 81 DUP2 0182 81 DUP2 0183 51 MLOAD 0184 81 DUP2 0185 52 MSTORE 0186 60 PUSH1 0x20 0188 01 ADD 0189 91 SWAP2 018A 50 POP 018B 80 DUP1 018C 51 MLOAD 018D 90 SWAP1 018E 60 PUSH1 0x20 0190 01 ADD 0191 90 SWAP1 0192 80 DUP1 0193 83 DUP4 0194 83 DUP4 0195 60 PUSH1 0x00 0197 5B JUMPDEST 0198 83 DUP4 0199 81 DUP2 019A 10 LT 019B 15 ISZERO 019C 61 PUSH2 0x01af 019F 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0171 stack[0] = memory[0x40:0x60] // @0172 stack[1] = memory[0x40:0x60] // @0176 stack[2] = 0x20 + memory[0x40:0x60] // @017F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0185 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0189 stack[3] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0191 stack[4] = 0x20 + stack[-2] // @0191 stack[5] = memory[stack[-2]:stack[-2] + 0x20] // @0192 stack[6] = memory[stack[-2]:stack[-2] + 0x20] // @0193 stack[7] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0194 stack[8] = 0x20 + stack[-2] // @0195 stack[9] = 0x00 // } // Block ends with conditional jump to 0x01af, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_01A0: // Incoming jump from 0x019F, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x019F, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @01A0 stack[-2] // @01A1 stack[-1] // @01A3 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @01A4 stack[-3] // } 01A0 81 DUP2 01A1 81 DUP2 01A2 01 ADD 01A3 51 MLOAD 01A4 83 DUP4 01A5 82 DUP3 01A6 01 ADD 01A7 52 MSTORE 01A8 60 PUSH1 0x20 01AA 01 ADD 01AB 61 PUSH2 0x0197 01AE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01A7 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @01AA stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0197 label_01AF: // Incoming jump from 0x019F, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x019F, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @01B4 stack[-6] // @01B4 stack[-5] // @01B6 stack[-7] // } 01AF 5B JUMPDEST 01B0 50 POP 01B1 50 POP 01B2 50 POP 01B3 50 POP 01B4 90 SWAP1 01B5 50 POP 01B6 90 SWAP1 01B7 81 DUP2 01B8 01 ADD 01B9 90 SWAP1 01BA 60 PUSH1 0x1f 01BC 16 AND 01BD 80 DUP1 01BE 15 ISZERO 01BF 61 PUSH2 0x01dc 01C2 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @01B9 stack[-7] = stack[-5] + stack[-7] // @01BC stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x01dc, if !(0x1f & stack[-5]) label_01C3: // Incoming jump from 0x01C2, if not !(0x1f & stack[-5]) // Inputs[8] // { // @01C3 stack[-1] // @01C4 stack[-2] // @01C7 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @01DE stack[-5] // @01E1 stack[-3] // @01E3 stack[-6] // @01E4 memory[stack[-6]:stack[-6] + 0x20] // @01E8 memory[stack[-6]:stack[-6] + 0x20] // } 01C3 80 DUP1 01C4 82 DUP3 01C5 03 SUB 01C6 80 DUP1 01C7 51 MLOAD 01C8 60 PUSH1 0x01 01CA 83 DUP4 01CB 60 PUSH1 0x20 01CD 03 SUB 01CE 61 PUSH2 0x0100 01D1 0A EXP 01D2 03 SUB 01D3 19 NOT 01D4 16 AND 01D5 81 DUP2 01D6 52 MSTORE 01D7 60 PUSH1 0x20 01D9 01 ADD 01DA 91 SWAP2 01DB 50 POP 01DC 5B JUMPDEST 01DD 50 POP 01DE 83 DUP4 01DF 81 DUP2 01E0 03 SUB 01E1 82 DUP3 01E2 52 MSTORE 01E3 84 DUP5 01E4 51 MLOAD 01E5 81 DUP2 01E6 52 MSTORE 01E7 84 DUP5 01E8 51 MLOAD 01E9 60 PUSH1 0x20 01EB 91 SWAP2 01EC 82 DUP3 01ED 01 ADD 01EE 91 SWAP2 01EF 86 DUP7 01F0 01 ADD 01F1 90 SWAP1 01F2 80 DUP1 01F3 83 DUP4 01F4 83 DUP4 01F5 60 PUSH1 0x00 01F7 5B JUMPDEST 01F8 83 DUP4 01F9 81 DUP2 01FA 10 LT 01FB 15 ISZERO 01FC 61 PUSH2 0x020f 01FF 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @01D6 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] // @01E2 memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-5] // @01E6 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @01EE stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @01F1 stack[-1] = stack[-6] + 0x20 // @01F1 stack[0] = memory[stack[-6]:stack[-6] + 0x20] // @01F2 stack[1] = memory[stack[-6]:stack[-6] + 0x20] // @01F3 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @01F4 stack[3] = stack[-6] + 0x20 // @01F5 stack[4] = 0x00 // } // Block ends with conditional jump to 0x020f, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_0200: // Incoming jump from 0x01FF, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x01FF, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x01FF, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[4] // { // @0200 stack[-2] // @0201 stack[-1] // @0203 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0204 stack[-3] // } 0200 81 DUP2 0201 81 DUP2 0202 01 ADD 0203 51 MLOAD 0204 83 DUP4 0205 82 DUP3 0206 01 ADD 0207 52 MSTORE 0208 60 PUSH1 0x20 020A 01 ADD 020B 61 PUSH2 0x01f7 020E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0207 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @020A stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x01f7 label_020F: // Incoming jump from 0x01FF, if !(stack[-1] < stack[-4]) // Incoming jump from 0x01FF, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x01FF, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @0214 stack[-6] // @0214 stack[-5] // @0216 stack[-7] // } 020F 5B JUMPDEST 0210 50 POP 0211 50 POP 0212 50 POP 0213 50 POP 0214 90 SWAP1 0215 50 POP 0216 90 SWAP1 0217 81 DUP2 0218 01 ADD 0219 90 SWAP1 021A 60 PUSH1 0x1f 021C 16 AND 021D 80 DUP1 021E 15 ISZERO 021F 61 PUSH2 0x023c 0222 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0219 stack[-7] = stack[-5] + stack[-7] // @021C stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x023c, if !(0x1f & stack[-5]) label_0223: // Incoming jump from 0x0222, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0223 stack[-1] // @0224 stack[-2] // @0227 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @023E stack[-7] // @0246 memory[0x40:0x60] // @024B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0223 80 DUP1 0224 82 DUP3 0225 03 SUB 0226 80 DUP1 0227 51 MLOAD 0228 60 PUSH1 0x01 022A 83 DUP4 022B 60 PUSH1 0x20 022D 03 SUB 022E 61 PUSH2 0x0100 0231 0A EXP 0232 03 SUB 0233 19 NOT 0234 16 AND 0235 81 DUP2 0236 52 MSTORE 0237 60 PUSH1 0x20 0239 01 ADD 023A 91 SWAP2 023B 50 POP 023C 5B JUMPDEST 023D 50 POP 023E 94 SWAP5 023F 50 POP 0240 50 POP 0241 50 POP 0242 50 POP 0243 50 POP 0244 60 PUSH1 0x40 0246 51 MLOAD 0247 80 DUP1 0248 91 SWAP2 0249 03 SUB 024A 90 SWAP1 024B F3 *RETURN // Stack delta = -7 // Outputs[2] // { // @0236 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] // @024B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_024C: // Incoming jump from 0x00A0, if 0x0faee324 == stack[-1] // Inputs[1] { @0253 msg.data.length } 024C 5B JUMPDEST 024D 61 PUSH2 0x016e 0250 60 PUSH1 0x04 0252 80 DUP1 0253 36 CALLDATASIZE 0254 03 SUB 0255 60 PUSH1 0x80 0257 81 DUP2 0258 10 LT 0259 15 ISZERO 025A 61 PUSH2 0x0262 025D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @024D stack[0] = 0x016e // @0250 stack[1] = 0x04 // @0254 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0262, if !(msg.data.length - 0x04 < 0x80) label_025E: // Incoming jump from 0x025D, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0261 memory[0x00:0x00] } 025E 60 PUSH1 0x00 0260 80 DUP1 0261 FD *REVERT // Stack delta = +0 // Outputs[1] { @0261 revert(memory[0x00:0x00]); } // Block terminates label_0262: // Incoming jump from 0x025D, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @0264 stack[-2] // @0265 msg.data[stack[-2]:stack[-2] + 0x20] // @026B msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0271 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0276 msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } 0262 5B JUMPDEST 0263 50 POP 0264 80 DUP1 0265 35 CALLDATALOAD 0266 90 SWAP1 0267 60 PUSH1 0x20 0269 81 DUP2 026A 01 ADD 026B 35 CALLDATALOAD 026C 90 SWAP1 026D 60 PUSH1 0x40 026F 81 DUP2 0270 01 ADD 0271 35 CALLDATALOAD 0272 90 SWAP1 0273 60 PUSH1 0x60 0275 01 ADD 0276 35 CALLDATALOAD 0277 61 PUSH2 0x07e3 027A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0266 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @026C stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0272 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0276 stack[1] = msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x07e3 label_027B: // Incoming jump from 0x00AB, if 0x111d9482 == stack[-1] // Inputs[1] { @0282 msg.data.length } 027B 5B JUMPDEST 027C 61 PUSH2 0x016e 027F 60 PUSH1 0x04 0281 80 DUP1 0282 36 CALLDATASIZE 0283 03 SUB 0284 60 PUSH1 0x80 0286 81 DUP2 0287 10 LT 0288 15 ISZERO 0289 61 PUSH2 0x0291 028C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @027C stack[0] = 0x016e // @027F stack[1] = 0x04 // @0283 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0291, if !(msg.data.length - 0x04 < 0x80) label_028D: // Incoming jump from 0x028C, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0290 memory[0x00:0x00] } 028D 60 PUSH1 0x00 028F 80 DUP1 0290 FD *REVERT // Stack delta = +0 // Outputs[1] { @0290 revert(memory[0x00:0x00]); } // Block terminates label_0291: // Incoming jump from 0x028C, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @0293 stack[-2] // @0294 msg.data[stack[-2]:stack[-2] + 0x20] // @029A msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02A0 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @02A5 msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } 0291 5B JUMPDEST 0292 50 POP 0293 80 DUP1 0294 35 CALLDATALOAD 0295 90 SWAP1 0296 60 PUSH1 0x20 0298 81 DUP2 0299 01 ADD 029A 35 CALLDATALOAD 029B 90 SWAP1 029C 60 PUSH1 0x40 029E 81 DUP2 029F 01 ADD 02A0 35 CALLDATALOAD 02A1 90 SWAP1 02A2 60 PUSH1 0x60 02A4 01 ADD 02A5 35 CALLDATALOAD 02A6 61 PUSH2 0x0b6f 02A9 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0295 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @029B stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02A1 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @02A5 stack[1] = msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b6f label_02AA: // Incoming jump from 0x00B6, if 0x2505c3d9 == stack[-1] // Inputs[1] { @02B1 msg.data.length } 02AA 5B JUMPDEST 02AB 61 PUSH2 0x016e 02AE 60 PUSH1 0x04 02B0 80 DUP1 02B1 36 CALLDATASIZE 02B2 03 SUB 02B3 60 PUSH1 0x80 02B5 81 DUP2 02B6 10 LT 02B7 15 ISZERO 02B8 61 PUSH2 0x02c0 02BB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02AB stack[0] = 0x016e // @02AE stack[1] = 0x04 // @02B2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x02c0, if !(msg.data.length - 0x04 < 0x80) label_02BC: // Incoming jump from 0x02BB, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @02BF memory[0x00:0x00] } 02BC 60 PUSH1 0x00 02BE 80 DUP1 02BF FD *REVERT // Stack delta = +0 // Outputs[1] { @02BF revert(memory[0x00:0x00]); } // Block terminates label_02C0: // Incoming jump from 0x02BB, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @02C2 stack[-2] // @02C3 msg.data[stack[-2]:stack[-2] + 0x20] // @02C9 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02CF msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @02D4 msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } 02C0 5B JUMPDEST 02C1 50 POP 02C2 80 DUP1 02C3 35 CALLDATALOAD 02C4 90 SWAP1 02C5 60 PUSH1 0x20 02C7 81 DUP2 02C8 01 ADD 02C9 35 CALLDATALOAD 02CA 90 SWAP1 02CB 60 PUSH1 0x40 02CD 81 DUP2 02CE 01 ADD 02CF 35 CALLDATALOAD 02D0 90 SWAP1 02D1 60 PUSH1 0x60 02D3 01 ADD 02D4 35 CALLDATALOAD 02D5 61 PUSH2 0x0eef 02D8 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @02C4 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @02CA stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02D0 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @02D4 stack[1] = msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0eef label_02D9: // Incoming jump from 0x00C1, if 0x369fb4a9 == stack[-1] // Inputs[1] { @02E0 msg.data.length } 02D9 5B JUMPDEST 02DA 61 PUSH2 0x016e 02DD 60 PUSH1 0x04 02DF 80 DUP1 02E0 36 CALLDATASIZE 02E1 03 SUB 02E2 60 PUSH1 0x60 02E4 81 DUP2 02E5 10 LT 02E6 15 ISZERO 02E7 61 PUSH2 0x02ef 02EA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02DA stack[0] = 0x016e // @02DD stack[1] = 0x04 // @02E1 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x02ef, if !(msg.data.length - 0x04 < 0x60) label_02EB: // Incoming jump from 0x02EA, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @02EE memory[0x00:0x00] } 02EB 60 PUSH1 0x00 02ED 80 DUP1 02EE FD *REVERT // Stack delta = +0 // Outputs[1] { @02EE revert(memory[0x00:0x00]); } // Block terminates label_02EF: // Incoming jump from 0x02EA, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @02F1 stack[-2] // @02F2 msg.data[stack[-2]:stack[-2] + 0x20] // @02F8 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02FD msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 02EF 5B JUMPDEST 02F0 50 POP 02F1 80 DUP1 02F2 35 CALLDATALOAD 02F3 90 SWAP1 02F4 60 PUSH1 0x20 02F6 81 DUP2 02F7 01 ADD 02F8 35 CALLDATALOAD 02F9 90 SWAP1 02FA 60 PUSH1 0x40 02FC 01 ADD 02FD 35 CALLDATALOAD 02FE 61 PUSH2 0x13f7 0301 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @02F3 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @02F9 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02FD stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x13f7 label_0302: // Incoming jump from 0x0064, if 0x674fb1b4 == stack[-1] // Inputs[1] { @0309 msg.data.length } 0302 5B JUMPDEST 0303 61 PUSH2 0x016e 0306 60 PUSH1 0x04 0308 80 DUP1 0309 36 CALLDATASIZE 030A 03 SUB 030B 60 PUSH1 0x80 030D 81 DUP2 030E 10 LT 030F 15 ISZERO 0310 61 PUSH2 0x0318 0313 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0303 stack[0] = 0x016e // @0306 stack[1] = 0x04 // @030A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0318, returns to 0x016E, if !(msg.data.length - 0x04 < 0x80) label_0314: // Incoming jump from 0x0313, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0317 memory[0x00:0x00] } 0314 60 PUSH1 0x00 0316 80 DUP1 0317 FD *REVERT // Stack delta = +0 // Outputs[1] { @0317 revert(memory[0x00:0x00]); } // Block terminates label_0318: // Incoming call from 0x0313, returns to 0x016E, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @031A stack[-2] // @031B msg.data[stack[-2]:stack[-2] + 0x20] // @0321 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0327 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @032C msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } 0318 5B JUMPDEST 0319 50 POP 031A 80 DUP1 031B 35 CALLDATALOAD 031C 90 SWAP1 031D 60 PUSH1 0x20 031F 81 DUP2 0320 01 ADD 0321 35 CALLDATALOAD 0322 90 SWAP1 0323 60 PUSH1 0x40 0325 81 DUP2 0326 01 ADD 0327 35 CALLDATALOAD 0328 90 SWAP1 0329 60 PUSH1 0x60 032B 01 ADD 032C 35 CALLDATALOAD 032D 61 PUSH2 0x1937 0330 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @031C stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0322 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0328 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @032C stack[1] = msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1937 label_0331: // Incoming jump from 0x006F, if 0xa73b74fe == stack[-1] // Inputs[1] { @0338 msg.data.length } 0331 5B JUMPDEST 0332 61 PUSH2 0x016e 0335 60 PUSH1 0x04 0337 80 DUP1 0338 36 CALLDATASIZE 0339 03 SUB 033A 60 PUSH1 0xe0 033C 81 DUP2 033D 10 LT 033E 15 ISZERO 033F 61 PUSH2 0x0347 0342 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0332 stack[0] = 0x016e // @0335 stack[1] = 0x04 // @0339 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0347, if !(msg.data.length - 0x04 < 0xe0) label_0343: // Incoming jump from 0x0342, if not !(msg.data.length - 0x04 < 0xe0) // Inputs[1] { @0346 memory[0x00:0x00] } 0343 60 PUSH1 0x00 0345 80 DUP1 0346 FD *REVERT // Stack delta = +0 // Outputs[1] { @0346 revert(memory[0x00:0x00]); } // Block terminates label_0347: // Incoming jump from 0x0342, if !(msg.data.length - 0x04 < 0xe0) // Inputs[8] // { // @0349 stack[-2] // @034A msg.data[stack[-2]:stack[-2] + 0x20] // @0350 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0356 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @035C msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0362 msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0368 msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @036D msg.data[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } 0347 5B JUMPDEST 0348 50 POP 0349 80 DUP1 034A 35 CALLDATALOAD 034B 90 SWAP1 034C 60 PUSH1 0x20 034E 81 DUP2 034F 01 ADD 0350 35 CALLDATALOAD 0351 90 SWAP1 0352 60 PUSH1 0x40 0354 81 DUP2 0355 01 ADD 0356 35 CALLDATALOAD 0357 90 SWAP1 0358 60 PUSH1 0x60 035A 81 DUP2 035B 01 ADD 035C 35 CALLDATALOAD 035D 90 SWAP1 035E 60 PUSH1 0x80 0360 81 DUP2 0361 01 ADD 0362 35 CALLDATALOAD 0363 90 SWAP1 0364 60 PUSH1 0xa0 0366 81 DUP2 0367 01 ADD 0368 35 CALLDATALOAD 0369 90 SWAP1 036A 60 PUSH1 0xc0 036C 01 ADD 036D 35 CALLDATALOAD 036E 61 PUSH2 0x1ee5 0371 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @034B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0351 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0357 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @035D stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0363 stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0369 stack[3] = msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @036D stack[4] = msg.data[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1ee5 label_0372: // Incoming jump from 0x007A, if 0xb7760c8f == stack[-1] // Inputs[1] { @0379 msg.data.length } 0372 5B JUMPDEST 0373 61 PUSH2 0x016e 0376 60 PUSH1 0x04 0378 80 DUP1 0379 36 CALLDATASIZE 037A 03 SUB 037B 60 PUSH1 0x40 037D 81 DUP2 037E 10 LT 037F 15 ISZERO 0380 61 PUSH2 0x0388 0383 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0373 stack[0] = 0x016e // @0376 stack[1] = 0x04 // @037A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0388, returns to 0x016E, if !(msg.data.length - 0x04 < 0x40) label_0384: // Incoming jump from 0x0383, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0387 memory[0x00:0x00] } 0384 60 PUSH1 0x00 0386 80 DUP1 0387 FD *REVERT // Stack delta = +0 // Outputs[1] { @0387 revert(memory[0x00:0x00]); } // Block terminates label_0388: // Incoming call from 0x0383, returns to 0x016E, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @038A stack[-2] // @038B msg.data[stack[-2]:stack[-2] + 0x20] // @0390 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0388 5B JUMPDEST 0389 50 POP 038A 80 DUP1 038B 35 CALLDATALOAD 038C 90 SWAP1 038D 60 PUSH1 0x20 038F 01 ADD 0390 35 CALLDATALOAD 0391 60 PUSH1 0x01 0393 60 PUSH1 0x01 0395 60 PUSH1 0xa0 0397 1B SHL 0398 03 SUB 0399 16 AND 039A 61 PUSH2 0x264c 039D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @038C stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0399 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x264c label_039E: // Incoming jump from 0x0033, if 0xc9fd076e == stack[-1] // Inputs[1] { @03A5 msg.data.length } 039E 5B JUMPDEST 039F 61 PUSH2 0x016e 03A2 60 PUSH1 0x04 03A4 80 DUP1 03A5 36 CALLDATASIZE 03A6 03 SUB 03A7 60 PUSH1 0x80 03A9 81 DUP2 03AA 10 LT 03AB 15 ISZERO 03AC 61 PUSH2 0x03b4 03AF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @039F stack[0] = 0x016e // @03A2 stack[1] = 0x04 // @03A6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03b4, returns to 0x016E, if !(msg.data.length - 0x04 < 0x80) label_03B0: // Incoming jump from 0x03AF, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @03B3 memory[0x00:0x00] } 03B0 60 PUSH1 0x00 03B2 80 DUP1 03B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B3 revert(memory[0x00:0x00]); } // Block terminates label_03B4: // Incoming call from 0x03AF, returns to 0x016E, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @03B6 stack[-2] // @03B7 msg.data[stack[-2]:stack[-2] + 0x20] // @03BD msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03C3 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @03C8 msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } 03B4 5B JUMPDEST 03B5 50 POP 03B6 80 DUP1 03B7 35 CALLDATALOAD 03B8 90 SWAP1 03B9 60 PUSH1 0x20 03BB 81 DUP2 03BC 01 ADD 03BD 35 CALLDATALOAD 03BE 90 SWAP1 03BF 60 PUSH1 0x40 03C1 81 DUP2 03C2 01 ADD 03C3 35 CALLDATALOAD 03C4 90 SWAP1 03C5 60 PUSH1 0x60 03C7 01 ADD 03C8 35 CALLDATALOAD 03C9 61 PUSH2 0x28c9 03CC 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @03B8 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @03BE stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03C4 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @03C8 stack[1] = msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x28c9 label_03CD: // Incoming jump from 0x003E, if 0xd5e0da36 == stack[-1] // Inputs[1] { @03D4 msg.data.length } 03CD 5B JUMPDEST 03CE 61 PUSH2 0x016e 03D1 60 PUSH1 0x04 03D3 80 DUP1 03D4 36 CALLDATASIZE 03D5 03 SUB 03D6 60 PUSH1 0x80 03D8 81 DUP2 03D9 10 LT 03DA 15 ISZERO 03DB 61 PUSH2 0x03e3 03DE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03CE stack[0] = 0x016e // @03D1 stack[1] = 0x04 // @03D5 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x03e3, if !(msg.data.length - 0x04 < 0x80) label_03DF: // Incoming jump from 0x03DE, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @03E2 memory[0x00:0x00] } 03DF 60 PUSH1 0x00 03E1 80 DUP1 03E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E2 revert(memory[0x00:0x00]); } // Block terminates label_03E3: // Incoming jump from 0x03DE, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @03E5 stack[-2] // @03E6 msg.data[stack[-2]:stack[-2] + 0x20] // @03EC msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03F2 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @03F7 msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } 03E3 5B JUMPDEST 03E4 50 POP 03E5 80 DUP1 03E6 35 CALLDATALOAD 03E7 90 SWAP1 03E8 60 PUSH1 0x20 03EA 81 DUP2 03EB 01 ADD 03EC 35 CALLDATALOAD 03ED 90 SWAP1 03EE 60 PUSH1 0x40 03F0 81 DUP2 03F1 01 ADD 03F2 35 CALLDATALOAD 03F3 90 SWAP1 03F4 60 PUSH1 0x60 03F6 01 ADD 03F7 35 CALLDATALOAD 03F8 61 PUSH2 0x2d54 03FB 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @03E7 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @03ED stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03F3 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @03F7 stack[1] = msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2d54 label_03FC: // Incoming jump from 0x0049, if 0xd6eac95d == stack[-1] // Inputs[1] { @0403 msg.data.length } 03FC 5B JUMPDEST 03FD 61 PUSH2 0x016e 0400 60 PUSH1 0x04 0402 80 DUP1 0403 36 CALLDATASIZE 0404 03 SUB 0405 60 PUSH1 0x60 0407 81 DUP2 0408 10 LT 0409 15 ISZERO 040A 61 PUSH2 0x0412 040D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03FD stack[0] = 0x016e // @0400 stack[1] = 0x04 // @0404 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0412, if !(msg.data.length - 0x04 < 0x60) label_040E: // Incoming jump from 0x040D, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0411 memory[0x00:0x00] } 040E 60 PUSH1 0x00 0410 80 DUP1 0411 FD *REVERT // Stack delta = +0 // Outputs[1] { @0411 revert(memory[0x00:0x00]); } // Block terminates label_0412: // Incoming jump from 0x040D, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0414 stack[-2] // @0415 msg.data[stack[-2]:stack[-2] + 0x20] // @041B msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0420 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 0412 5B JUMPDEST 0413 50 POP 0414 80 DUP1 0415 35 CALLDATALOAD 0416 90 SWAP1 0417 60 PUSH1 0x20 0419 81 DUP2 041A 01 ADD 041B 35 CALLDATALOAD 041C 90 SWAP1 041D 60 PUSH1 0x40 041F 01 ADD 0420 35 CALLDATALOAD 0421 61 PUSH2 0x3131 0424 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0416 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @041C stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0420 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x3131 label_0425: // Incoming jump from 0x0054, if 0xe4dcb06b == stack[-1] // Inputs[1] { @042C msg.data.length } 0425 5B JUMPDEST 0426 61 PUSH2 0x016e 0429 60 PUSH1 0x04 042B 80 DUP1 042C 36 CALLDATASIZE 042D 03 SUB 042E 60 PUSH1 0x20 0430 81 DUP2 0431 10 LT 0432 15 ISZERO 0433 61 PUSH2 0x043b 0436 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0426 stack[0] = 0x016e // @0429 stack[1] = 0x04 // @042D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x043b, returns to 0x016E, if !(msg.data.length - 0x04 < 0x20) label_0437: // Incoming jump from 0x0436, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @043A memory[0x00:0x00] } 0437 60 PUSH1 0x00 0439 80 DUP1 043A FD *REVERT // Stack delta = +0 // Outputs[1] { @043A revert(memory[0x00:0x00]); } // Block terminates label_043B: // Incoming call from 0x0436, returns to 0x016E, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @043C stack[-2] // @043D stack[-1] // @0444 msg.data[stack[-2]:stack[-2] + 0x20] // } 043B 5B JUMPDEST 043C 81 DUP2 043D 01 ADD 043E 90 SWAP1 043F 60 PUSH1 0x20 0441 81 DUP2 0442 01 ADD 0443 81 DUP2 0444 35 CALLDATALOAD 0445 64 PUSH5 0x0100000000 044B 81 DUP2 044C 11 GT 044D 15 ISZERO 044E 61 PUSH2 0x0456 0451 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @043E stack[-1] = stack[-2] // @043E stack[-2] = stack[-2] + stack[-1] // @0442 stack[0] = stack[-2] + 0x20 // @0444 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0456, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0452: // Incoming jump from 0x0451, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0455 memory[0x00:0x00] } 0452 60 PUSH1 0x00 0454 80 DUP1 0455 FD *REVERT // Stack delta = +0 // Outputs[1] { @0455 revert(memory[0x00:0x00]); } // Block terminates label_0456: // Incoming jump from 0x0451, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0457 stack[-3] // @0458 stack[-1] // @0459 stack[-4] // } 0456 5B JUMPDEST 0457 82 DUP3 0458 01 ADD 0459 83 DUP4 045A 60 PUSH1 0x20 045C 82 DUP3 045D 01 ADD 045E 11 GT 045F 15 ISZERO 0460 61 PUSH2 0x0468 0463 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0458 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0468, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0464: // Incoming jump from 0x0463, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0467 memory[0x00:0x00] } 0464 60 PUSH1 0x00 0466 80 DUP1 0467 FD *REVERT // Stack delta = +0 // Outputs[1] { @0467 revert(memory[0x00:0x00]); } // Block terminates label_0468: // Incoming jump from 0x0463, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0469 stack[-1] // @046A msg.data[stack[-1]:stack[-1] + 0x20] // @046F stack[-2] // @0470 stack[-4] // } 0468 5B JUMPDEST 0469 80 DUP1 046A 35 CALLDATALOAD 046B 90 SWAP1 046C 60 PUSH1 0x20 046E 01 ADD 046F 91 SWAP2 0470 84 DUP5 0471 60 PUSH1 0x01 0473 83 DUP4 0474 02 MUL 0475 84 DUP5 0476 01 ADD 0477 11 GT 0478 64 PUSH5 0x0100000000 047E 83 DUP4 047F 11 GT 0480 17 OR 0481 15 ISZERO 0482 61 PUSH2 0x048a 0485 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @046B stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @046F stack[0] = stack[-2] // @046F stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x048a, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0486: // Incoming jump from 0x0485, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0489 memory[0x00:0x00] } 0486 60 PUSH1 0x00 0488 80 DUP1 0489 FD *REVERT // Stack delta = +0 // Outputs[1] { @0489 revert(memory[0x00:0x00]); } // Block terminates label_048A: // Incoming jump from 0x0485, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @048C stack[-2] // @048C stack[-3] // @048D stack[-5] // @048F stack[-4] // } 048A 5B JUMPDEST 048B 50 POP 048C 90 SWAP1 048D 92 SWAP3 048E 50 POP 048F 90 SWAP1 0490 50 POP 0491 61 PUSH2 0x35fb 0494 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @048D stack[-5] = stack[-3] // @048F stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x35fb label_0495: // Incoming call from 0x00DB, returns to 0x00DC // Inputs[2] // { // @0498 memory[0x40:0x60] // @04BC stack[-1] // } 0495 5B JUMPDEST 0496 60 PUSH1 0x40 0498 51 MLOAD 0499 80 DUP1 049A 60 PUSH1 0x40 049C 01 ADD 049D 60 PUSH1 0x40 049F 52 MSTORE 04A0 80 DUP1 04A1 60 PUSH1 0x0d 04A3 81 DUP2 04A4 52 MSTORE 04A5 60 PUSH1 0x20 04A7 01 ADD 04A8 6C PUSH13 0x4d616b657244414f2d76312e31 04B6 60 PUSH1 0x98 04B8 1B SHL 04B9 81 DUP2 04BA 52 MSTORE 04BB 50 POP 04BC 81 DUP2 04BD 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0498 stack[0] = memory[0x40:0x60] // @049F memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @04A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0d // @04BA memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x4d616b657244414f2d76312e31 << 0x98 // } // Block ends with unconditional jump to stack[-1] label_04BE: // Incoming jump from 0x016D // Inputs[1] { @04C7 stack[-1] } 04BE 5B JUMPDEST 04BF 60 PUSH1 0x60 04C1 80 DUP1 04C2 60 PUSH1 0x00 04C4 61 PUSH2 0x04cc 04C7 84 DUP5 04C8 61 PUSH2 0x3804 04CB 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @04BF stack[0] = 0x60 // @04C1 stack[1] = 0x60 // @04C2 stack[2] = 0x00 // @04C4 stack[3] = 0x04cc // @04C7 stack[4] = stack[-1] // } // Block ends with call to 0x3804, returns to 0x04CC label_04CC: // Incoming return from call to 0x3804 at 0x04CB // Inputs[2] // { // @04CD stack[-1] // @04CD stack[-2] // } 04CC 5B JUMPDEST 04CD 90 SWAP1 04CE 50 POP 04CF 60 PUSH1 0x00 04D1 80 DUP1 04D2 61 PUSH2 0x04da 04D5 83 DUP4 04D6 61 PUSH2 0x3950 04D9 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @04CD stack[-2] = stack[-1] // @04CF stack[-1] = 0x00 // @04D1 stack[0] = 0x00 // @04D2 stack[1] = 0x04da // @04D5 stack[2] = stack[-1] // } // Block ends with call to 0x3950, returns to 0x04DA label_04DA: // Incoming return from call to 0x3950 at 0x04D9 // Inputs[9] // { // @04DB stack[-1] // @04DB stack[-3] // @04DD stack[-4] // @04DD stack[-2] // @04E5 memory[0x00:0x20] // @04EE memory[0x00:0x20] // @0501 memory[0x40:0x60] // @0515 memory[0x40:0x60] // @051C address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 04DA 5B JUMPDEST 04DB 91 SWAP2 04DC 50 POP 04DD 91 SWAP2 04DE 50 POP 04DF 60 PUSH1 0x00 04E1 80 DUP1 04E2 60 PUSH1 0x00 04E4 80 DUP1 04E5 51 MLOAD 04E6 60 PUSH1 0x20 04E8 61 PUSH2 0x4418 04EB 83 DUP4 04EC 39 CODECOPY 04ED 81 DUP2 04EE 51 MLOAD 04EF 91 SWAP2 04F0 52 MSTORE 04F1 60 PUSH1 0x01 04F3 60 PUSH1 0x01 04F5 60 PUSH1 0xa0 04F7 1B SHL 04F8 03 SUB 04F9 16 AND 04FA 63 PUSH4 0x36569e77 04FF 60 PUSH1 0x40 0501 51 MLOAD 0502 81 DUP2 0503 63 PUSH4 0xffffffff 0508 16 AND 0509 60 PUSH1 0xe0 050B 1B SHL 050C 81 DUP2 050D 52 MSTORE 050E 60 PUSH1 0x04 0510 01 ADD 0511 60 PUSH1 0x20 0513 60 PUSH1 0x40 0515 51 MLOAD 0516 80 DUP1 0517 83 DUP4 0518 03 SUB 0519 81 DUP2 051A 86 DUP7 051B 80 DUP1 051C 3B EXTCODESIZE 051D 15 ISZERO 051E 80 DUP1 051F 15 ISZERO 0520 61 PUSH2 0x0528 0523 57 *JUMPI // Stack delta = +9 // Outputs[16] // { // @04DB stack[-3] = stack[-1] // @04DD stack[-4] = stack[-2] // @04DF stack[-2] = 0x00 // @04E1 stack[-1] = 0x00 // @04EC memory[0x00:0x20] = code[0x4418:0x4438] // @04F0 memory[0x00:0x20] = memory[0x00:0x20] // @04F9 stack[0] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @04FA stack[1] = 0x36569e77 // @050D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @0510 stack[2] = 0x04 + memory[0x40:0x60] // @0511 stack[3] = 0x20 // @0515 stack[4] = memory[0x40:0x60] // @0518 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0519 stack[6] = memory[0x40:0x60] // @051A stack[7] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @051D stack[8] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x0528, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_0524: // Incoming jump from 0x0523, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @0527 memory[0x00:0x00] } 0524 60 PUSH1 0x00 0526 80 DUP1 0527 FD *REVERT // Stack delta = +0 // Outputs[1] { @0527 revert(memory[0x00:0x00]); } // Block terminates label_0528: // Incoming jump from 0x0523, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @052A msg.gas // @052B stack[-4] // @052B memory[stack[-3]:stack[-3] + stack[-4]] // @052B stack[-2] // @052B stack[-6] // @052B address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @052B stack[-3] // @052B stack[-5] // } 0528 5B JUMPDEST 0529 50 POP 052A 5A GAS 052B FA STATICCALL 052C 15 ISZERO 052D 80 DUP1 052E 15 ISZERO 052F 61 PUSH2 0x053c 0532 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @052B memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @052C stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x053c, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0533: // Incoming jump from 0x0532, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0533 returndata.length // @0537 returndata[0x00:0x00 + returndata.length] // @0538 returndata.length // @053B memory[0x00:0x00 + returndata.length] // } 0533 3D RETURNDATASIZE 0534 60 PUSH1 0x00 0536 80 DUP1 0537 3E RETURNDATACOPY 0538 3D RETURNDATASIZE 0539 60 PUSH1 0x00 053B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0537 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @053B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_053C: // Incoming jump from 0x0532, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0543 memory[0x40:0x60] // @0544 returndata.length // } 053C 5B JUMPDEST 053D 50 POP 053E 50 POP 053F 50 POP 0540 50 POP 0541 60 PUSH1 0x40 0543 51 MLOAD 0544 3D RETURNDATASIZE 0545 60 PUSH1 0x20 0547 81 DUP2 0548 10 LT 0549 15 ISZERO 054A 61 PUSH2 0x0552 054D 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0543 stack[-4] = memory[0x40:0x60] // @0544 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0552, if !(returndata.length < 0x20) label_054E: // Incoming jump from 0x054D, if not !(returndata.length < 0x20) // Inputs[1] { @0551 memory[0x00:0x00] } 054E 60 PUSH1 0x00 0550 80 DUP1 0551 FD *REVERT // Stack delta = +0 // Outputs[1] { @0551 revert(memory[0x00:0x00]); } // Block terminates label_0552: // Incoming jump from 0x054D, if !(returndata.length < 0x20) // Inputs[7] // { // @0554 stack[-2] // @0554 memory[stack[-2]:stack[-2] + 0x20] // @0558 memory[0x40:0x60] // @0567 stack[-6] // @0572 stack[-5] // @057B memory[0x40:0x60] // @0595 address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } 0552 5B JUMPDEST 0553 50 POP 0554 51 MLOAD 0555 60 PUSH1 0x40 0557 80 DUP1 0558 51 MLOAD 0559 63 PUSH4 0x09092f97 055E 60 PUSH1 0xe2 0560 1B SHL 0561 81 DUP2 0562 52 MSTORE 0563 60 PUSH1 0x04 0565 81 DUP2 0566 01 ADD 0567 87 DUP8 0568 90 SWAP1 0569 52 MSTORE 056A 60 PUSH1 0x01 056C 60 PUSH1 0x01 056E 60 PUSH1 0xa0 0570 1B SHL 0571 03 SUB 0572 86 DUP7 0573 81 DUP2 0574 16 AND 0575 60 PUSH1 0x24 0577 83 DUP4 0578 01 ADD 0579 52 MSTORE 057A 82 DUP3 057B 51 MLOAD 057C 93 SWAP4 057D 16 AND 057E 92 SWAP3 057F 63 PUSH4 0x2424be5c 0584 92 SWAP3 0585 60 PUSH1 0x44 0587 80 DUP1 0588 84 DUP5 0589 01 ADD 058A 93 SWAP4 058B 91 SWAP2 058C 92 SWAP3 058D 91 SWAP2 058E 82 DUP3 058F 90 SWAP1 0590 03 SUB 0591 01 ADD 0592 81 DUP2 0593 86 DUP7 0594 80 DUP1 0595 3B EXTCODESIZE 0596 15 ISZERO 0597 80 DUP1 0598 15 ISZERO 0599 61 PUSH2 0x05a1 059C 57 *JUMPI // Stack delta = +7 // Outputs[12] // { // @0562 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x09092f97 << 0xe2 // @0569 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-6] // @0579 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @057E stack[-2] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0584 stack[-1] = 0x2424be5c // @058A stack[0] = memory[0x40:0x60] + 0x44 // @058C stack[1] = 0x40 // @058D stack[2] = memory[0x40:0x60] // @0591 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @0592 stack[4] = memory[0x40:0x60] // @0593 stack[5] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0596 stack[6] = !address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x05a1, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length label_059D: // Incoming jump from 0x059C, if not !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @05A0 memory[0x00:0x00] } 059D 60 PUSH1 0x00 059F 80 DUP1 05A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A0 revert(memory[0x00:0x00]); } // Block terminates label_05A1: // Incoming jump from 0x059C, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @05A3 msg.gas // @05A4 stack[-4] // @05A4 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @05A4 stack[-2] // @05A4 stack[-3] // @05A4 memory[stack[-3]:stack[-3] + stack[-4]] // @05A4 stack[-6] // @05A4 stack[-5] // } 05A1 5B JUMPDEST 05A2 50 POP 05A3 5A GAS 05A4 FA STATICCALL 05A5 15 ISZERO 05A6 80 DUP1 05A7 15 ISZERO 05A8 61 PUSH2 0x05b5 05AB 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @05A4 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @05A5 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x05b5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_05AC: // Incoming jump from 0x05AB, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @05AC returndata.length // @05B0 returndata[0x00:0x00 + returndata.length] // @05B1 returndata.length // @05B4 memory[0x00:0x00 + returndata.length] // } 05AC 3D RETURNDATASIZE 05AD 60 PUSH1 0x00 05AF 80 DUP1 05B0 3E RETURNDATACOPY 05B1 3D RETURNDATASIZE 05B2 60 PUSH1 0x00 05B4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @05B0 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @05B4 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_05B5: // Incoming jump from 0x05AB, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @05BC memory[0x40:0x60] // @05BD returndata.length // } 05B5 5B JUMPDEST 05B6 50 POP 05B7 50 POP 05B8 50 POP 05B9 50 POP 05BA 60 PUSH1 0x40 05BC 51 MLOAD 05BD 3D RETURNDATASIZE 05BE 60 PUSH1 0x40 05C0 81 DUP2 05C1 10 LT 05C2 15 ISZERO 05C3 61 PUSH2 0x05cb 05C6 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @05BC stack[-4] = memory[0x40:0x60] // @05BD stack[-3] = returndata.length // } // Block ends with conditional jump to 0x05cb, if !(returndata.length < 0x40) label_05C7: // Incoming jump from 0x05C6, if not !(returndata.length < 0x40) // Inputs[1] { @05CA memory[0x00:0x00] } 05C7 60 PUSH1 0x00 05C9 80 DUP1 05CA FD *REVERT // Stack delta = +0 // Outputs[1] { @05CA revert(memory[0x00:0x00]); } // Block terminates label_05CB: // Incoming jump from 0x05C6, if !(returndata.length < 0x40) // Inputs[5] // { // @05CD stack[-2] // @05CE memory[stack[-2]:stack[-2] + 0x20] // @05D4 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @05D6 stack[-4] // @05D8 stack[-3] // } 05CB 5B JUMPDEST 05CC 50 POP 05CD 80 DUP1 05CE 51 MLOAD 05CF 60 PUSH1 0x20 05D1 90 SWAP1 05D2 91 SWAP2 05D3 01 ADD 05D4 51 MLOAD 05D5 90 SWAP1 05D6 92 SWAP3 05D7 50 POP 05D8 90 SWAP1 05D9 50 POP 05DA 81 DUP2 05DB 15 ISZERO 05DC 80 DUP1 05DD 15 ISZERO 05DE 61 PUSH2 0x05e5 05E1 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @05D6 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] // @05D8 stack[-3] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @05DB stack[-2] = !memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x05e5, if !!memory[stack[-2]:stack[-2] + 0x20] label_05E2: // Incoming jump from 0x05E1, if not !!memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @05E3 stack[-2] } 05E2 50 POP 05E3 80 DUP1 05E4 15 ISZERO 05E5 5B JUMPDEST 05E6 61 PUSH2 0x0629 05E9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0629, if !stack[-2] label_05EA: // Incoming jump from 0x05E9, if not !stack[-2] // Incoming jump from 0x05E9, if not stack[-1] // Inputs[3] // { // @05ED memory[0x40:0x60] // @061F memory[0x40:0x60] // @0628 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 05EA 60 PUSH1 0x40 05EC 80 DUP1 05ED 51 MLOAD 05EE 62 PUSH3 0x461bcd 05F2 60 PUSH1 0xe5 05F4 1B SHL 05F5 81 DUP2 05F6 52 MSTORE 05F7 60 PUSH1 0x20 05F9 60 PUSH1 0x04 05FB 82 DUP3 05FC 01 ADD 05FD 52 MSTORE 05FE 60 PUSH1 0x10 0600 60 PUSH1 0x24 0602 82 DUP3 0603 01 ADD 0604 52 MSTORE 0605 6F PUSH16 0x7661756c742d6861732d617373657473 0616 60 PUSH1 0x80 0618 1B SHL 0619 60 PUSH1 0x44 061B 82 DUP3 061C 01 ADD 061D 52 MSTORE 061E 90 SWAP1 061F 51 MLOAD 0620 90 SWAP1 0621 81 DUP2 0622 90 SWAP1 0623 03 SUB 0624 60 PUSH1 0x64 0626 01 ADD 0627 90 SWAP1 0628 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @05F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05FD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0604 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @061D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x7661756c742d6861732d617373657473 << 0x80 // @0628 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0629: // Incoming jump from 0x05E9, if !stack[-2] // Incoming jump from 0x05E9, if stack[-1] // Inputs[7] // { // @062A address(this) // @0637 memory[0x00:0x20] // @0640 memory[0x00:0x20] // @0651 stack[-5] // @0654 memory[0x40:0x60] // @0672 memory[0x40:0x60] // @0679 address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 0629 5B JUMPDEST 062A 30 ADDRESS 062B 60 PUSH1 0x01 062D 60 PUSH1 0x01 062F 60 PUSH1 0xa0 0631 1B SHL 0632 03 SUB 0633 16 AND 0634 60 PUSH1 0x00 0636 80 DUP1 0637 51 MLOAD 0638 60 PUSH1 0x20 063A 61 PUSH2 0x4418 063D 83 DUP4 063E 39 CODECOPY 063F 81 DUP2 0640 51 MLOAD 0641 91 SWAP2 0642 52 MSTORE 0643 60 PUSH1 0x01 0645 60 PUSH1 0x01 0647 60 PUSH1 0xa0 0649 1B SHL 064A 03 SUB 064B 16 AND 064C 63 PUSH4 0x8161b120 0651 87 DUP8 0652 60 PUSH1 0x40 0654 51 MLOAD 0655 82 DUP3 0656 63 PUSH4 0xffffffff 065B 16 AND 065C 60 PUSH1 0xe0 065E 1B SHL 065F 81 DUP2 0660 52 MSTORE 0661 60 PUSH1 0x04 0663 01 ADD 0664 80 DUP1 0665 82 DUP3 0666 81 DUP2 0667 52 MSTORE 0668 60 PUSH1 0x20 066A 01 ADD 066B 91 SWAP2 066C 50 POP 066D 50 POP 066E 60 PUSH1 0x20 0670 60 PUSH1 0x40 0672 51 MLOAD 0673 80 DUP1 0674 83 DUP4 0675 03 SUB 0676 81 DUP2 0677 86 DUP7 0678 80 DUP1 0679 3B EXTCODESIZE 067A 15 ISZERO 067B 80 DUP1 067C 15 ISZERO 067D 61 PUSH2 0x0685 0680 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @0633 stack[0] = (0x01 << 0xa0) - 0x01 & address(this) // @063E memory[0x00:0x20] = code[0x4418:0x4438] // @0642 memory[0x00:0x20] = memory[0x00:0x20] // @064B stack[1] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @064C stack[2] = 0x8161b120 // @0660 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x8161b120) << 0xe0 // @0667 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-5] // @066B stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @066E stack[4] = 0x20 // @0672 stack[5] = memory[0x40:0x60] // @0675 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0676 stack[7] = memory[0x40:0x60] // @0677 stack[8] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @067A stack[9] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x0685, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_0681: // Incoming jump from 0x0680, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @0684 memory[0x00:0x00] } 0681 60 PUSH1 0x00 0683 80 DUP1 0684 FD *REVERT // Stack delta = +0 // Outputs[1] { @0684 revert(memory[0x00:0x00]); } // Block terminates label_0685: // Incoming jump from 0x0680, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @0687 msg.gas // @0688 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0688 stack[-4] // @0688 memory[stack[-3]:stack[-3] + stack[-4]] // @0688 stack[-5] // @0688 stack[-2] // @0688 stack[-3] // @0688 stack[-6] // } 0685 5B JUMPDEST 0686 50 POP 0687 5A GAS 0688 FA STATICCALL 0689 15 ISZERO 068A 80 DUP1 068B 15 ISZERO 068C 61 PUSH2 0x0699 068F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0688 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0689 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0699, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0690: // Incoming jump from 0x068F, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0690 returndata.length // @0694 returndata[0x00:0x00 + returndata.length] // @0695 returndata.length // @0698 memory[0x00:0x00 + returndata.length] // } 0690 3D RETURNDATASIZE 0691 60 PUSH1 0x00 0693 80 DUP1 0694 3E RETURNDATACOPY 0695 3D RETURNDATASIZE 0696 60 PUSH1 0x00 0698 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0694 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0698 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0699: // Incoming jump from 0x068F, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @06A0 memory[0x40:0x60] // @06A1 returndata.length // } 0699 5B JUMPDEST 069A 50 POP 069B 50 POP 069C 50 POP 069D 50 POP 069E 60 PUSH1 0x40 06A0 51 MLOAD 06A1 3D RETURNDATASIZE 06A2 60 PUSH1 0x20 06A4 81 DUP2 06A5 10 LT 06A6 15 ISZERO 06A7 61 PUSH2 0x06af 06AA 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @06A0 stack[-4] = memory[0x40:0x60] // @06A1 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x06af, if !(returndata.length < 0x20) label_06AB: // Incoming jump from 0x06AA, if not !(returndata.length < 0x20) // Inputs[1] { @06AE memory[0x00:0x00] } 06AB 60 PUSH1 0x00 06AD 80 DUP1 06AE FD *REVERT // Stack delta = +0 // Outputs[1] { @06AE revert(memory[0x00:0x00]); } // Block terminates label_06AF: // Incoming jump from 0x06AA, if !(returndata.length < 0x20) // Inputs[3] // { // @06B1 memory[stack[-2]:stack[-2] + 0x20] // @06B1 stack[-2] // @06BB stack[-3] // } 06AF 5B JUMPDEST 06B0 50 POP 06B1 51 MLOAD 06B2 60 PUSH1 0x01 06B4 60 PUSH1 0x01 06B6 60 PUSH1 0xa0 06B8 1B SHL 06B9 03 SUB 06BA 16 AND 06BB 14 EQ 06BC 61 PUSH2 0x06f8 06BF 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x06f8, if (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] label_06C0: // Incoming jump from 0x06BF, if not (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[3] // { // @06C3 memory[0x40:0x60] // @06EE memory[0x40:0x60] // @06F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 06C0 60 PUSH1 0x40 06C2 80 DUP1 06C3 51 MLOAD 06C4 62 PUSH3 0x461bcd 06C8 60 PUSH1 0xe5 06CA 1B SHL 06CB 81 DUP2 06CC 52 MSTORE 06CD 60 PUSH1 0x20 06CF 60 PUSH1 0x04 06D1 82 DUP3 06D2 01 ADD 06D3 52 MSTORE 06D4 60 PUSH1 0x09 06D6 60 PUSH1 0x24 06D8 82 DUP3 06D9 01 ADD 06DA 52 MSTORE 06DB 68 PUSH9 0x3737ba16b7bbb732b9 06E5 60 PUSH1 0xb9 06E7 1B SHL 06E8 60 PUSH1 0x44 06EA 82 DUP3 06EB 01 ADD 06EC 52 MSTORE 06ED 90 SWAP1 06EE 51 MLOAD 06EF 90 SWAP1 06F0 81 DUP2 06F1 90 SWAP1 06F2 03 SUB 06F3 60 PUSH1 0x64 06F5 01 ADD 06F6 90 SWAP1 06F7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @06CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06D3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06DA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @06EC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x3737ba16b7bbb732b9 << 0xb9 // @06F7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_06F8: // Incoming jump from 0x06BF, if (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[6] // { // @06FC memory[0x40:0x60] // @070B stack[-5] // @0729 memory[0x40:0x60] // @072D memory[0x00:0x20] // @0736 memory[0x00:0x20] // @0753 address(memory[0x00:0x20]).code.length // } 06F8 5B JUMPDEST 06F9 60 PUSH1 0x40 06FB 80 DUP1 06FC 51 MLOAD 06FD 63 PUSH4 0x1f95f98d 0702 60 PUSH1 0xe3 0704 1B SHL 0705 81 DUP2 0706 52 MSTORE 0707 60 PUSH1 0x04 0709 81 DUP2 070A 01 ADD 070B 87 DUP8 070C 90 SWAP1 070D 52 MSTORE 070E 73 PUSH20 0x4dd58550eb15190a5b3dfae28bb14eec181fc267 0723 60 PUSH1 0x24 0725 82 DUP3 0726 01 ADD 0727 52 MSTORE 0728 90 SWAP1 0729 51 MLOAD 072A 60 PUSH1 0x00 072C 80 DUP1 072D 51 MLOAD 072E 60 PUSH1 0x20 0730 61 PUSH2 0x4418 0733 83 DUP4 0734 39 CODECOPY 0735 81 DUP2 0736 51 MLOAD 0737 91 SWAP2 0738 52 MSTORE 0739 91 SWAP2 073A 63 PUSH4 0xfcafcc68 073F 91 SWAP2 0740 60 PUSH1 0x44 0742 80 DUP1 0743 83 DUP4 0744 01 ADD 0745 92 SWAP3 0746 60 PUSH1 0x00 0748 92 SWAP3 0749 91 SWAP2 074A 90 SWAP1 074B 82 DUP3 074C 90 SWAP1 074D 03 SUB 074E 01 ADD 074F 81 DUP2 0750 83 DUP4 0751 87 DUP8 0752 80 DUP1 0753 3B EXTCODESIZE 0754 15 ISZERO 0755 80 DUP1 0756 15 ISZERO 0757 61 PUSH2 0x075f 075A 57 *JUMPI // Stack delta = +10 // Outputs[15] // { // @0706 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1f95f98d << 0xe3 // @070D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-5] // @0727 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x4dd58550eb15190a5b3dfae28bb14eec181fc267 // @0734 memory[0x00:0x20] = code[0x4418:0x4438] // @0738 memory[0x00:0x20] = memory[0x00:0x20] // @0739 stack[0] = memory[0x00:0x20] // @073F stack[1] = 0xfcafcc68 // @0745 stack[2] = memory[0x40:0x60] + 0x44 // @0748 stack[3] = 0x00 // @0749 stack[4] = memory[0x40:0x60] // @074E stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @074F stack[6] = memory[0x40:0x60] // @0750 stack[7] = 0x00 // @0751 stack[8] = memory[0x00:0x20] // @0754 stack[9] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x075f, if !!address(memory[0x00:0x20]).code.length label_075B: // Incoming jump from 0x075A, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @075E memory[0x00:0x00] } 075B 60 PUSH1 0x00 075D 80 DUP1 075E FD *REVERT // Stack delta = +0 // Outputs[1] { @075E revert(memory[0x00:0x00]); } // Block terminates label_075F: // Incoming jump from 0x075A, if !!address(memory[0x00:0x20]).code.length // Inputs[9] // { // @0761 msg.gas // @0762 stack[-7] // @0762 stack[-4] // @0762 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0762 stack[-5] // @0762 stack[-3] // @0762 stack[-6] // @0762 memory[stack[-4]:stack[-4] + stack[-5]] // @0762 stack[-2] // } 075F 5B JUMPDEST 0760 50 POP 0761 5A GAS 0762 F1 CALL 0763 15 ISZERO 0764 80 DUP1 0765 15 ISZERO 0766 61 PUSH2 0x0773 0769 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0762 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0763 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0773, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_076A: // Incoming jump from 0x0769, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @076A returndata.length // @076E returndata[0x00:0x00 + returndata.length] // @076F returndata.length // @0772 memory[0x00:0x00 + returndata.length] // } 076A 3D RETURNDATASIZE 076B 60 PUSH1 0x00 076D 80 DUP1 076E 3E RETURNDATACOPY 076F 3D RETURNDATASIZE 0770 60 PUSH1 0x00 0772 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @076E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0772 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0773: // Incoming jump from 0x0769, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[9] // { // @077A memory[0x40:0x60] // @07AE stack[-11] // @07B0 stack[-9] // @07B1 stack[-8] // @07B4 memory[0x40:0x60] // @07CB memory[0x40:0x60] // @07D8 stack[-10] // @07DF stack[-12] // @07E1 stack[-13] // } 0773 5B JUMPDEST 0774 50 POP 0775 50 POP 0776 50 POP 0777 50 POP 0778 60 PUSH1 0x40 077A 51 MLOAD 077B 80 DUP1 077C 60 PUSH1 0x40 077E 01 ADD 077F 60 PUSH1 0x40 0781 52 MSTORE 0782 80 DUP1 0783 60 PUSH1 0x19 0785 81 DUP2 0786 52 MSTORE 0787 60 PUSH1 0x20 0789 01 ADD 078A 7F PUSH32 0x4c6f67436c6f73652875696e743235362c627974657333322900000000000000 07AB 81 DUP2 07AC 52 MSTORE 07AD 50 POP 07AE 96 SWAP7 07AF 50 POP 07B0 84 DUP5 07B1 84 DUP5 07B2 60 PUSH1 0x40 07B4 51 MLOAD 07B5 60 PUSH1 0x20 07B7 01 ADD 07B8 80 DUP1 07B9 83 DUP4 07BA 81 DUP2 07BB 52 MSTORE 07BC 60 PUSH1 0x20 07BE 01 ADD 07BF 82 DUP3 07C0 81 DUP2 07C1 52 MSTORE 07C2 60 PUSH1 0x20 07C4 01 ADD 07C5 92 SWAP3 07C6 50 POP 07C7 50 POP 07C8 50 POP 07C9 60 PUSH1 0x40 07CB 51 MLOAD 07CC 60 PUSH1 0x20 07CE 81 DUP2 07CF 83 DUP4 07D0 03 SUB 07D1 03 SUB 07D2 81 DUP2 07D3 52 MSTORE 07D4 90 SWAP1 07D5 60 PUSH1 0x40 07D7 52 MSTORE 07D8 95 SWAP6 07D9 50 POP 07DA 50 POP 07DB 50 POP 07DC 50 POP 07DD 50 POP 07DE 50 POP 07DF 91 SWAP2 07E0 50 POP 07E1 91 SWAP2 07E2 56 *JUMP // Stack delta = -11 // Outputs[9] // { // @0781 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0786 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x19 // @07AC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x4c6f67436c6f73652875696e743235362c627974657333322900000000000000 // @07BB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-9] // @07C1 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-8] // @07D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @07D7 memory[0x40:0x60] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @07DF stack[-12] = memory[0x40:0x60] // @07E1 stack[-13] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-13] label_07E3: // Incoming jump from 0x027A // Inputs[2] // { // @07EC stack[-2] // @07ED stack[-3] // } 07E3 5B JUMPDEST 07E4 60 PUSH1 0x60 07E6 80 DUP1 07E7 60 PUSH1 0x00 07E9 61 PUSH2 0x07f2 07EC 85 DUP6 07ED 87 DUP8 07EE 61 PUSH2 0x3a55 07F1 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @07E4 stack[0] = 0x60 // @07E6 stack[1] = 0x60 // @07E7 stack[2] = 0x00 // @07E9 stack[3] = 0x07f2 // @07EC stack[4] = stack[-2] // @07ED stack[5] = stack[-3] // } // Block ends with call to 0x3a55, returns to 0x07F2 label_07F2: // Incoming return from call to 0x3A55 at 0x07F1 // Inputs[3] // { // @07F3 stack[-2] // @07F3 stack[-1] // @07FA stack[-8] // } 07F2 5B JUMPDEST 07F3 90 SWAP1 07F4 50 POP 07F5 60 PUSH1 0x00 07F7 61 PUSH2 0x07ff 07FA 88 DUP9 07FB 61 PUSH2 0x3804 07FE 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @07F3 stack[-2] = stack[-1] // @07F5 stack[-1] = 0x00 // @07F7 stack[0] = 0x07ff // @07FA stack[1] = stack[-8] // } // Block ends with call to 0x3804, returns to 0x07FF label_07FF: // Incoming return from call to 0x3804 at 0x07FE // Inputs[2] // { // @0800 stack[-1] // @0800 stack[-2] // } 07FF 5B JUMPDEST 0800 90 SWAP1 0801 50 POP 0802 60 PUSH1 0x00 0804 80 DUP1 0805 61 PUSH2 0x080d 0808 83 DUP4 0809 61 PUSH2 0x3950 080C 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0800 stack[-2] = stack[-1] // @0802 stack[-1] = 0x00 // @0804 stack[0] = 0x00 // @0805 stack[1] = 0x080d // @0808 stack[2] = stack[-1] // } // Block ends with call to 0x3950, returns to 0x080D label_080D: // Incoming return from call to 0x3950 at 0x080C // Inputs[9] // { // @080E stack[-3] // @080E stack[-1] // @0810 stack[-2] // @0810 stack[-4] // @0817 memory[0x00:0x20] // @0820 memory[0x00:0x20] // @0833 memory[0x40:0x60] // @0847 memory[0x40:0x60] // @084E address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 080D 5B JUMPDEST 080E 91 SWAP2 080F 50 POP 0810 91 SWAP2 0811 50 POP 0812 60 PUSH1 0x00 0814 60 PUSH1 0x00 0816 80 DUP1 0817 51 MLOAD 0818 60 PUSH1 0x20 081A 61 PUSH2 0x4418 081D 83 DUP4 081E 39 CODECOPY 081F 81 DUP2 0820 51 MLOAD 0821 91 SWAP2 0822 52 MSTORE 0823 60 PUSH1 0x01 0825 60 PUSH1 0x01 0827 60 PUSH1 0xa0 0829 1B SHL 082A 03 SUB 082B 16 AND 082C 63 PUSH4 0x36569e77 0831 60 PUSH1 0x40 0833 51 MLOAD 0834 81 DUP2 0835 63 PUSH4 0xffffffff 083A 16 AND 083B 60 PUSH1 0xe0 083D 1B SHL 083E 81 DUP2 083F 52 MSTORE 0840 60 PUSH1 0x04 0842 01 ADD 0843 60 PUSH1 0x20 0845 60 PUSH1 0x40 0847 51 MLOAD 0848 80 DUP1 0849 83 DUP4 084A 03 SUB 084B 81 DUP2 084C 86 DUP7 084D 80 DUP1 084E 3B EXTCODESIZE 084F 15 ISZERO 0850 80 DUP1 0851 15 ISZERO 0852 61 PUSH2 0x085a 0855 57 *JUMPI // Stack delta = +8 // Outputs[15] // { // @080E stack[-3] = stack[-1] // @0810 stack[-4] = stack[-2] // @0812 stack[-2] = 0x00 // @081E memory[0x00:0x20] = code[0x4418:0x4438] // @0822 memory[0x00:0x20] = memory[0x00:0x20] // @082B stack[-1] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @082C stack[0] = 0x36569e77 // @083F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @0842 stack[1] = 0x04 + memory[0x40:0x60] // @0843 stack[2] = 0x20 // @0847 stack[3] = memory[0x40:0x60] // @084A stack[4] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @084B stack[5] = memory[0x40:0x60] // @084C stack[6] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @084F stack[7] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x085a, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_0856: // Incoming jump from 0x0855, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @0859 memory[0x00:0x00] } 0856 60 PUSH1 0x00 0858 80 DUP1 0859 FD *REVERT // Stack delta = +0 // Outputs[1] { @0859 revert(memory[0x00:0x00]); } // Block terminates label_085A: // Incoming jump from 0x0855, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @085C msg.gas // @085D stack[-3] // @085D stack[-4] // @085D stack[-2] // @085D stack[-6] // @085D address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @085D memory[stack[-3]:stack[-3] + stack[-4]] // @085D stack[-5] // } 085A 5B JUMPDEST 085B 50 POP 085C 5A GAS 085D FA STATICCALL 085E 15 ISZERO 085F 80 DUP1 0860 15 ISZERO 0861 61 PUSH2 0x086e 0864 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @085D memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @085E stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x086e, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0865: // Incoming jump from 0x0864, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0865 returndata.length // @0869 returndata[0x00:0x00 + returndata.length] // @086A returndata.length // @086D memory[0x00:0x00 + returndata.length] // } 0865 3D RETURNDATASIZE 0866 60 PUSH1 0x00 0868 80 DUP1 0869 3E RETURNDATACOPY 086A 3D RETURNDATASIZE 086B 60 PUSH1 0x00 086D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0869 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @086D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_086E: // Incoming jump from 0x0864, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0875 memory[0x40:0x60] // @0876 returndata.length // } 086E 5B JUMPDEST 086F 50 POP 0870 50 POP 0871 50 POP 0872 50 POP 0873 60 PUSH1 0x40 0875 51 MLOAD 0876 3D RETURNDATASIZE 0877 60 PUSH1 0x20 0879 81 DUP2 087A 10 LT 087B 15 ISZERO 087C 61 PUSH2 0x0884 087F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0875 stack[-4] = memory[0x40:0x60] // @0876 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0884, if !(returndata.length < 0x20) label_0880: // Incoming jump from 0x087F, if not !(returndata.length < 0x20) // Inputs[1] { @0883 memory[0x00:0x00] } 0880 60 PUSH1 0x00 0882 80 DUP1 0883 FD *REVERT // Stack delta = +0 // Outputs[1] { @0883 revert(memory[0x00:0x00]); } // Block terminates label_0884: // Incoming jump from 0x087F, if !(returndata.length < 0x20) // Inputs[4] // { // @0886 stack[-2] // @0886 memory[stack[-2]:stack[-2] + 0x20] // @0887 stack[-3] // @088C stack[-7] // } 0884 5B JUMPDEST 0885 50 POP 0886 51 MLOAD 0887 90 SWAP1 0888 50 POP 0889 60 PUSH1 0x00 088B 19 NOT 088C 85 DUP6 088D 14 EQ 088E 15 ISZERO 088F 61 PUSH2 0x091c 0892 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0887 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x091c, if !(stack[-7] == ~0x00) label_0893: // Incoming jump from 0x0892, if not !(stack[-7] == ~0x00) // Inputs[5] // { // @0893 stack[-1] // @08A2 stack[-2] // @08A5 memory[0x40:0x60] // @08CC memory[0x40:0x60] // @08D3 address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } 0893 80 DUP1 0894 60 PUSH1 0x01 0896 60 PUSH1 0x01 0898 60 PUSH1 0xa0 089A 1B SHL 089B 03 SUB 089C 16 AND 089D 63 PUSH4 0x6c25b346 08A2 83 DUP4 08A3 60 PUSH1 0x40 08A5 51 MLOAD 08A6 82 DUP3 08A7 63 PUSH4 0xffffffff 08AC 16 AND 08AD 60 PUSH1 0xe0 08AF 1B SHL 08B0 81 DUP2 08B1 52 MSTORE 08B2 60 PUSH1 0x04 08B4 01 ADD 08B5 80 DUP1 08B6 82 DUP3 08B7 60 PUSH1 0x01 08B9 60 PUSH1 0x01 08BB 60 PUSH1 0xa0 08BD 1B SHL 08BE 03 SUB 08BF 16 AND 08C0 81 DUP2 08C1 52 MSTORE 08C2 60 PUSH1 0x20 08C4 01 ADD 08C5 91 SWAP2 08C6 50 POP 08C7 50 POP 08C8 60 PUSH1 0x20 08CA 60 PUSH1 0x40 08CC 51 MLOAD 08CD 80 DUP1 08CE 83 DUP4 08CF 03 SUB 08D0 81 DUP2 08D1 86 DUP7 08D2 80 DUP1 08D3 3B EXTCODESIZE 08D4 15 ISZERO 08D5 80 DUP1 08D6 15 ISZERO 08D7 61 PUSH2 0x08df 08DA 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @089C stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @089D stack[1] = 0x6c25b346 // @08B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x6c25b346) << 0xe0 // @08C1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @08C5 stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @08C8 stack[3] = 0x20 // @08CC stack[4] = memory[0x40:0x60] // @08CF stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @08D0 stack[6] = memory[0x40:0x60] // @08D1 stack[7] = (0x01 << 0xa0) - 0x01 & stack[-1] // @08D4 stack[8] = !address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } // Block ends with conditional jump to 0x08df, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length label_08DB: // Incoming jump from 0x08DA, if not !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[1] { @08DE memory[0x00:0x00] } 08DB 60 PUSH1 0x00 08DD 80 DUP1 08DE FD *REVERT // Stack delta = +0 // Outputs[1] { @08DE revert(memory[0x00:0x00]); } // Block terminates label_08DF: // Incoming jump from 0x08DA, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[8] // { // @08E1 msg.gas // @08E2 stack[-6] // @08E2 stack[-4] // @08E2 stack[-5] // @08E2 stack[-3] // @08E2 memory[stack[-3]:stack[-3] + stack[-4]] // @08E2 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @08E2 stack[-2] // } 08DF 5B JUMPDEST 08E0 50 POP 08E1 5A GAS 08E2 FA STATICCALL 08E3 15 ISZERO 08E4 80 DUP1 08E5 15 ISZERO 08E6 61 PUSH2 0x08f3 08E9 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @08E2 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @08E3 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x08f3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_08EA: // Incoming jump from 0x08E9, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @08EA returndata.length // @08EE returndata[0x00:0x00 + returndata.length] // @08EF returndata.length // @08F2 memory[0x00:0x00 + returndata.length] // } 08EA 3D RETURNDATASIZE 08EB 60 PUSH1 0x00 08ED 80 DUP1 08EE 3E RETURNDATACOPY 08EF 3D RETURNDATASIZE 08F0 60 PUSH1 0x00 08F2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08EE memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @08F2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_08F3: // Incoming jump from 0x08E9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @08FA memory[0x40:0x60] // @08FB returndata.length // } 08F3 5B JUMPDEST 08F4 50 POP 08F5 50 POP 08F6 50 POP 08F7 50 POP 08F8 60 PUSH1 0x40 08FA 51 MLOAD 08FB 3D RETURNDATASIZE 08FC 60 PUSH1 0x20 08FE 81 DUP2 08FF 10 LT 0900 15 ISZERO 0901 61 PUSH2 0x0909 0904 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @08FA stack[-4] = memory[0x40:0x60] // @08FB stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0909, if !(returndata.length < 0x20) label_0905: // Incoming jump from 0x0904, if not !(returndata.length < 0x20) // Inputs[1] { @0908 memory[0x00:0x00] } 0905 60 PUSH1 0x00 0907 80 DUP1 0908 FD *REVERT // Stack delta = +0 // Outputs[1] { @0908 revert(memory[0x00:0x00]); } // Block terminates label_0909: // Incoming jump from 0x0904, if !(returndata.length < 0x20) // Inputs[3] // { // @090B memory[stack[-2]:stack[-2] + 0x20] // @090B stack[-2] // @091A stack[-7] // } 0909 5B JUMPDEST 090A 50 POP 090B 51 MLOAD 090C 67 PUSH8 0x6765c793fa10079d 0915 60 PUSH1 0x1b 0917 1B SHL 0918 90 SWAP1 0919 04 DIV 091A 94 SWAP5 091B 50 POP // Stack delta = -2 // Outputs[1] { @091A stack[-7] = memory[stack[-2]:stack[-2] + 0x20] / (0x6765c793fa10079d << 0x1b) } // Block continues label_091C: // Incoming jump from 0x091B // Incoming jump from 0x0892, if !(stack[-7] == ~0x00) // Inputs[5] // { // @0920 memory[0x00:0x20] // @0929 memory[0x00:0x20] // @0931 stack[-4] // @0932 address(this) // @0936 stack[-5] // } 091C 5B JUMPDEST 091D 60 PUSH1 0x00 091F 80 DUP1 0920 51 MLOAD 0921 60 PUSH1 0x20 0923 61 PUSH2 0x4418 0926 83 DUP4 0927 39 CODECOPY 0928 81 DUP2 0929 51 MLOAD 092A 91 SWAP2 092B 52 MSTORE 092C 63 PUSH4 0xf9f30db6 0931 85 DUP6 0932 30 ADDRESS 0933 61 PUSH2 0x093b 0936 89 DUP10 0937 61 PUSH2 0x3af1 093A 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0927 memory[0x00:0x20] = code[0x4418:0x4438] // @092A stack[0] = memory[0x00:0x20] // @092B memory[0x00:0x20] = memory[0x00:0x20] // @092C stack[1] = 0xf9f30db6 // @0931 stack[2] = stack[-4] // @0932 stack[3] = address(this) // @0933 stack[4] = 0x093b // @0936 stack[5] = stack[-5] // } // Block ends with unconditional jump to 0x3af1 093B 5B JUMPDEST 093C 60 PUSH1 0x40 093E 51 MLOAD 093F 84 DUP5 0940 63 PUSH4 0xffffffff 0945 16 AND 0946 60 PUSH1 0xe0 0948 1B SHL 0949 81 DUP2 094A 52 MSTORE 094B 60 PUSH1 0x04 094D 01 ADD 094E 80 DUP1 094F 84 DUP5 0950 81 DUP2 0951 52 MSTORE 0952 60 PUSH1 0x20 0954 01 ADD 0955 83 DUP4 0956 60 PUSH1 0x01 0958 60 PUSH1 0x01 095A 60 PUSH1 0xa0 095C 1B SHL 095D 03 SUB 095E 16 AND 095F 81 DUP2 0960 52 MSTORE 0961 60 PUSH1 0x20 0963 01 ADD 0964 82 DUP3 0965 81 DUP2 0966 52 MSTORE 0967 60 PUSH1 0x20 0969 01 ADD 096A 93 SWAP4 096B 50 POP 096C 50 POP 096D 50 POP 096E 50 POP 096F 60 PUSH1 0x00 0971 60 PUSH1 0x40 0973 51 MLOAD 0974 80 DUP1 0975 83 DUP4 0976 03 SUB 0977 81 DUP2 0978 60 PUSH1 0x00 097A 87 DUP8 097B 80 DUP1 097C 3B EXTCODESIZE 097D 15 ISZERO 097E 80 DUP1 097F 15 ISZERO 0980 61 PUSH2 0x0988 0983 57 *JUMPI 0984 60 PUSH1 0x00 0986 80 DUP1 0987 FD *REVERT 0988 5B JUMPDEST 0989 50 POP 098A 5A GAS 098B F1 CALL 098C 15 ISZERO 098D 80 DUP1 098E 15 ISZERO 098F 61 PUSH2 0x099c 0992 57 *JUMPI 0993 3D RETURNDATASIZE 0994 60 PUSH1 0x00 0996 80 DUP1 0997 3E RETURNDATACOPY 0998 3D RETURNDATASIZE 0999 60 PUSH1 0x00 099B FD *REVERT 099C 5B JUMPDEST 099D 50 POP 099E 50 POP 099F 60 PUSH1 0x40 09A1 80 DUP1 09A2 51 MLOAD 09A3 63 PUSH4 0x4538c4eb 09A8 60 PUSH1 0xe0 09AA 1B SHL 09AB 81 DUP2 09AC 52 MSTORE 09AD 30 ADDRESS 09AE 60 PUSH1 0x04 09B0 82 DUP3 09B1 01 ADD 09B2 52 MSTORE 09B3 60 PUSH1 0x00 09B5 80 DUP1 09B6 51 MLOAD 09B7 60 PUSH1 0x20 09B9 61 PUSH2 0x4293 09BC 83 DUP4 09BD 39 CODECOPY 09BE 81 DUP2 09BF 51 MLOAD 09C0 91 SWAP2 09C1 52 MSTORE 09C2 60 PUSH1 0x24 09C4 82 DUP3 09C5 01 ADD 09C6 52 MSTORE 09C7 90 SWAP1 09C8 51 MLOAD 09C9 60 PUSH1 0x01 09CB 60 PUSH1 0x01 09CD 60 PUSH1 0xa0 09CF 1B SHL 09D0 03 SUB 09D1 85 DUP6 09D2 16 AND 09D3 93 SWAP4 09D4 50 POP 09D5 63 PUSH4 0x4538c4eb 09DA 92 SWAP3 09DB 50 POP 09DC 60 PUSH1 0x44 09DE 80 DUP1 09DF 83 DUP4 09E0 01 ADD 09E1 92 SWAP3 09E2 60 PUSH1 0x20 09E4 92 SWAP3 09E5 91 SWAP2 09E6 90 SWAP1 09E7 82 DUP3 09E8 90 SWAP1 09E9 03 SUB 09EA 01 ADD 09EB 81 DUP2 09EC 86 DUP7 09ED 80 DUP1 09EE 3B EXTCODESIZE 09EF 15 ISZERO 09F0 80 DUP1 09F1 15 ISZERO 09F2 61 PUSH2 0x09fa 09F5 57 *JUMPI 09F6 60 PUSH1 0x00 09F8 80 DUP1 09F9 FD *REVERT 09FA 5B JUMPDEST 09FB 50 POP 09FC 5A GAS 09FD FA STATICCALL 09FE 15 ISZERO 09FF 80 DUP1 0A00 15 ISZERO 0A01 61 PUSH2 0x0a0e 0A04 57 *JUMPI 0A05 3D RETURNDATASIZE 0A06 60 PUSH1 0x00 0A08 80 DUP1 0A09 3E RETURNDATACOPY 0A0A 3D RETURNDATASIZE 0A0B 60 PUSH1 0x00 0A0D FD *REVERT 0A0E 5B JUMPDEST 0A0F 50 POP 0A10 50 POP 0A11 50 POP 0A12 50 POP 0A13 60 PUSH1 0x40 0A15 51 MLOAD 0A16 3D RETURNDATASIZE 0A17 60 PUSH1 0x20 0A19 81 DUP2 0A1A 10 LT 0A1B 15 ISZERO 0A1C 61 PUSH2 0x0a24 0A1F 57 *JUMPI 0A20 60 PUSH1 0x00 0A22 80 DUP1 0A23 FD *REVERT 0A24 5B JUMPDEST 0A25 50 POP 0A26 51 MLOAD 0A27 61 PUSH2 0x0a98 0A2A 57 *JUMPI 0A2B 60 PUSH1 0x40 0A2D 80 DUP1 0A2E 51 MLOAD 0A2F 63 PUSH4 0x28ec8bf1 0A34 60 PUSH1 0xe2 0A36 1B SHL 0A37 81 DUP2 0A38 52 MSTORE 0A39 60 PUSH1 0x00 0A3B 80 DUP1 0A3C 51 MLOAD 0A3D 60 PUSH1 0x20 0A3F 61 PUSH2 0x4293 0A42 83 DUP4 0A43 39 CODECOPY 0A44 81 DUP2 0A45 51 MLOAD 0A46 91 SWAP2 0A47 52 MSTORE 0A48 60 PUSH1 0x04 0A4A 82 DUP3 0A4B 01 ADD 0A4C 52 MSTORE 0A4D 90 SWAP1 0A4E 51 MLOAD 0A4F 60 PUSH1 0x01 0A51 60 PUSH1 0x01 0A53 60 PUSH1 0xa0 0A55 1B SHL 0A56 03 SUB 0A57 83 DUP4 0A58 16 AND 0A59 91 SWAP2 0A5A 63 PUSH4 0xa3b22fc4 0A5F 91 SWAP2 0A60 60 PUSH1 0x24 0A62 80 DUP1 0A63 83 DUP4 0A64 01 ADD 0A65 92 SWAP3 0A66 60 PUSH1 0x00 0A68 92 SWAP3 0A69 91 SWAP2 0A6A 90 SWAP1 0A6B 82 DUP3 0A6C 90 SWAP1 0A6D 03 SUB 0A6E 01 ADD 0A6F 81 DUP2 0A70 83 DUP4 0A71 87 DUP8 0A72 80 DUP1 0A73 3B EXTCODESIZE 0A74 15 ISZERO 0A75 80 DUP1 0A76 15 ISZERO 0A77 61 PUSH2 0x0a7f 0A7A 57 *JUMPI 0A7B 60 PUSH1 0x00 0A7D 80 DUP1 0A7E FD *REVERT 0A7F 5B JUMPDEST 0A80 50 POP 0A81 5A GAS 0A82 F1 CALL 0A83 15 ISZERO 0A84 80 DUP1 0A85 15 ISZERO 0A86 61 PUSH2 0x0a93 0A89 57 *JUMPI 0A8A 3D RETURNDATASIZE 0A8B 60 PUSH1 0x00 0A8D 80 DUP1 0A8E 3E RETURNDATACOPY 0A8F 3D RETURNDATASIZE 0A90 60 PUSH1 0x00 0A92 FD *REVERT 0A93 5B JUMPDEST 0A94 50 POP 0A95 50 POP 0A96 50 POP 0A97 50 POP 0A98 5B JUMPDEST 0A99 60 PUSH1 0x40 0A9B 80 DUP1 0A9C 51 MLOAD 0A9D 63 PUSH4 0xef693bed 0AA2 60 PUSH1 0xe0 0AA4 1B SHL 0AA5 81 DUP2 0AA6 52 MSTORE 0AA7 30 ADDRESS 0AA8 60 PUSH1 0x04 0AAA 82 DUP3 0AAB 01 ADD 0AAC 52 MSTORE 0AAD 60 PUSH1 0x24 0AAF 81 DUP2 0AB0 01 ADD 0AB1 87 DUP8 0AB2 90 SWAP1 0AB3 52 MSTORE 0AB4 90 SWAP1 0AB5 51 MLOAD 0AB6 60 PUSH1 0x00 0AB8 80 DUP1 0AB9 51 MLOAD 0ABA 60 PUSH1 0x20 0ABC 61 PUSH2 0x4293 0ABF 83 DUP4 0AC0 39 CODECOPY 0AC1 81 DUP2 0AC2 51 MLOAD 0AC3 91 SWAP2 0AC4 52 MSTORE 0AC5 91 SWAP2 0AC6 63 PUSH4 0xef693bed 0ACB 91 SWAP2 0ACC 60 PUSH1 0x44 0ACE 80 DUP1 0ACF 83 DUP4 0AD0 01 ADD 0AD1 92 SWAP3 0AD2 60 PUSH1 0x00 0AD4 92 SWAP3 0AD5 91 SWAP2 0AD6 90 SWAP1 0AD7 82 DUP3 0AD8 90 SWAP1 0AD9 03 SUB 0ADA 01 ADD 0ADB 81 DUP2 0ADC 83 DUP4 0ADD 87 DUP8 0ADE 80 DUP1 0ADF 3B EXTCODESIZE 0AE0 15 ISZERO 0AE1 80 DUP1 0AE2 15 ISZERO 0AE3 61 PUSH2 0x0aeb 0AE6 57 *JUMPI 0AE7 60 PUSH1 0x00 0AE9 80 DUP1 0AEA FD *REVERT 0AEB 5B JUMPDEST 0AEC 50 POP 0AED 5A GAS 0AEE F1 CALL 0AEF 15 ISZERO 0AF0 80 DUP1 0AF1 15 ISZERO 0AF2 61 PUSH2 0x0aff 0AF5 57 *JUMPI 0AF6 3D RETURNDATASIZE 0AF7 60 PUSH1 0x00 0AF9 80 DUP1 0AFA 3E RETURNDATACOPY 0AFB 3D RETURNDATASIZE 0AFC 60 PUSH1 0x00 0AFE FD *REVERT 0AFF 5B JUMPDEST 0B00 50 POP 0B01 50 POP 0B02 50 POP 0B03 50 POP 0B04 61 PUSH2 0x0b0d 0B07 88 DUP9 0B08 86 DUP7 0B09 61 PUSH2 0x3b0e 0B0C 56 *JUMP 0B0D 5B JUMPDEST 0B0E 60 PUSH1 0x40 0B10 51 MLOAD 0B11 80 DUP1 0B12 60 PUSH1 0x60 0B14 01 ADD 0B15 60 PUSH1 0x40 0B17 52 MSTORE 0B18 80 DUP1 0B19 60 PUSH1 0x33 0B1B 81 DUP2 0B1C 52 MSTORE 0B1D 60 PUSH1 0x20 0B1F 01 ADD 0B20 61 PUSH2 0x422c 0B23 60 PUSH1 0x33 0B25 91 SWAP2 0B26 39 CODECOPY 0B27 60 PUSH1 0x40 0B29 80 DUP1 0B2A 51 MLOAD 0B2B 60 PUSH1 0x20 0B2D 81 DUP2 0B2E 01 ADD 0B2F 96 SWAP7 0B30 90 SWAP1 0B31 96 SWAP7 0B32 52 MSTORE 0B33 85 DUP6 0B34 81 DUP2 0B35 01 ADD 0B36 94 SWAP5 0B37 90 SWAP1 0B38 94 SWAP5 0B39 52 MSTORE 0B3A 60 PUSH1 0x60 0B3C 85 DUP6 0B3D 01 ADD 0B3E 95 SWAP6 0B3F 90 SWAP1 0B40 95 SWAP6 0B41 52 MSTORE 0B42 50 POP 0B43 50 POP 0B44 60 PUSH1 0x80 0B46 82 DUP3 0B47 01 ADD 0B48 96 SWAP7 0B49 90 SWAP1 0B4A 96 SWAP7 0B4B 52 MSTORE 0B4C 60 PUSH1 0xa0 0B4E 80 DUP1 0B4F 82 DUP3 0B50 01 ADD 0B51 95 SWAP6 0B52 90 SWAP1 0B53 95 SWAP6 0B54 52 MSTORE 0B55 85 DUP6 0B56 51 MLOAD 0B57 80 DUP1 0B58 82 DUP3 0B59 03 SUB 0B5A 90 SWAP1 0B5B 95 SWAP6 0B5C 01 ADD 0B5D 85 DUP6 0B5E 52 MSTORE 0B5F 60 PUSH1 0xc0 0B61 01 ADD 0B62 90 SWAP1 0B63 94 SWAP5 0B64 52 MSTORE 0B65 50 POP 0B66 91 SWAP2 0B67 94 SWAP5 0B68 90 SWAP1 0B69 93 SWAP4 0B6A 50 POP 0B6B 91 SWAP2 0B6C 50 POP 0B6D 50 POP 0B6E 56 *JUMP label_0B6F: // Incoming jump from 0x02A9 // Inputs[2] // { // @0B78 stack[-2] // @0B79 stack[-3] // } 0B6F 5B JUMPDEST 0B70 60 PUSH1 0x60 0B72 80 DUP1 0B73 60 PUSH1 0x00 0B75 61 PUSH2 0x0b7e 0B78 85 DUP6 0B79 87 DUP8 0B7A 61 PUSH2 0x3a55 0B7D 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0B70 stack[0] = 0x60 // @0B72 stack[1] = 0x60 // @0B73 stack[2] = 0x00 // @0B75 stack[3] = 0x0b7e // @0B78 stack[4] = stack[-2] // @0B79 stack[5] = stack[-3] // } // Block ends with call to 0x3a55, returns to 0x0B7E label_0B7E: // Incoming return from call to 0x3A55 at 0x0B7D // Inputs[3] // { // @0B7F stack[-1] // @0B7F stack[-2] // @0B86 stack[-8] // } 0B7E 5B JUMPDEST 0B7F 90 SWAP1 0B80 50 POP 0B81 60 PUSH1 0x00 0B83 61 PUSH2 0x0b8b 0B86 88 DUP9 0B87 61 PUSH2 0x3804 0B8A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0B7F stack[-2] = stack[-1] // @0B81 stack[-1] = 0x00 // @0B83 stack[0] = 0x0b8b // @0B86 stack[1] = stack[-8] // } // Block ends with call to 0x3804, returns to 0x0B8B label_0B8B: // Incoming return from call to 0x3804 at 0x0B8A // Inputs[2] // { // @0B8C stack[-2] // @0B8C stack[-1] // } 0B8B 5B JUMPDEST 0B8C 90 SWAP1 0B8D 50 POP 0B8E 60 PUSH1 0x00 0B90 80 DUP1 0B91 61 PUSH2 0x0b99 0B94 83 DUP4 0B95 61 PUSH2 0x3950 0B98 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0B8C stack[-2] = stack[-1] // @0B8E stack[-1] = 0x00 // @0B90 stack[0] = 0x00 // @0B91 stack[1] = 0x0b99 // @0B94 stack[2] = stack[-1] // } // Block ends with call to 0x3950, returns to 0x0B99 label_0B99: // Incoming return from call to 0x3950 at 0x0B98 // Inputs[9] // { // @0B9A stack[-1] // @0B9A stack[-3] // @0B9C stack[-2] // @0B9C stack[-4] // @0BA3 memory[0x00:0x20] // @0BAC memory[0x00:0x20] // @0BBF memory[0x40:0x60] // @0BD3 memory[0x40:0x60] // @0BDA address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 0B99 5B JUMPDEST 0B9A 91 SWAP2 0B9B 50 POP 0B9C 91 SWAP2 0B9D 50 POP 0B9E 60 PUSH1 0x00 0BA0 60 PUSH1 0x00 0BA2 80 DUP1 0BA3 51 MLOAD 0BA4 60 PUSH1 0x20 0BA6 61 PUSH2 0x4418 0BA9 83 DUP4 0BAA 39 CODECOPY 0BAB 81 DUP2 0BAC 51 MLOAD 0BAD 91 SWAP2 0BAE 52 MSTORE 0BAF 60 PUSH1 0x01 0BB1 60 PUSH1 0x01 0BB3 60 PUSH1 0xa0 0BB5 1B SHL 0BB6 03 SUB 0BB7 16 AND 0BB8 63 PUSH4 0x36569e77 0BBD 60 PUSH1 0x40 0BBF 51 MLOAD 0BC0 81 DUP2 0BC1 63 PUSH4 0xffffffff 0BC6 16 AND 0BC7 60 PUSH1 0xe0 0BC9 1B SHL 0BCA 81 DUP2 0BCB 52 MSTORE 0BCC 60 PUSH1 0x04 0BCE 01 ADD 0BCF 60 PUSH1 0x20 0BD1 60 PUSH1 0x40 0BD3 51 MLOAD 0BD4 80 DUP1 0BD5 83 DUP4 0BD6 03 SUB 0BD7 81 DUP2 0BD8 86 DUP7 0BD9 80 DUP1 0BDA 3B EXTCODESIZE 0BDB 15 ISZERO 0BDC 80 DUP1 0BDD 15 ISZERO 0BDE 61 PUSH2 0x0be6 0BE1 57 *JUMPI // Stack delta = +8 // Outputs[15] // { // @0B9A stack[-3] = stack[-1] // @0B9C stack[-4] = stack[-2] // @0B9E stack[-2] = 0x00 // @0BAA memory[0x00:0x20] = code[0x4418:0x4438] // @0BAE memory[0x00:0x20] = memory[0x00:0x20] // @0BB7 stack[-1] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @0BB8 stack[0] = 0x36569e77 // @0BCB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @0BCE stack[1] = 0x04 + memory[0x40:0x60] // @0BCF stack[2] = 0x20 // @0BD3 stack[3] = memory[0x40:0x60] // @0BD6 stack[4] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0BD7 stack[5] = memory[0x40:0x60] // @0BD8 stack[6] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @0BDB stack[7] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x0be6, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_0BE2: // Incoming jump from 0x0BE1, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @0BE5 memory[0x00:0x00] } 0BE2 60 PUSH1 0x00 0BE4 80 DUP1 0BE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BE5 revert(memory[0x00:0x00]); } // Block terminates label_0BE6: // Incoming jump from 0x0BE1, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @0BE8 msg.gas // @0BE9 stack[-2] // @0BE9 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0BE9 memory[stack[-3]:stack[-3] + stack[-4]] // @0BE9 stack[-6] // @0BE9 stack[-5] // @0BE9 stack[-3] // @0BE9 stack[-4] // } 0BE6 5B JUMPDEST 0BE7 50 POP 0BE8 5A GAS 0BE9 FA STATICCALL 0BEA 15 ISZERO 0BEB 80 DUP1 0BEC 15 ISZERO 0BED 61 PUSH2 0x0bfa 0BF0 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0BE9 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0BEA stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0bfa, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0BF1: // Incoming jump from 0x0BF0, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0BF1 returndata.length // @0BF5 returndata[0x00:0x00 + returndata.length] // @0BF6 returndata.length // @0BF9 memory[0x00:0x00 + returndata.length] // } 0BF1 3D RETURNDATASIZE 0BF2 60 PUSH1 0x00 0BF4 80 DUP1 0BF5 3E RETURNDATACOPY 0BF6 3D RETURNDATASIZE 0BF7 60 PUSH1 0x00 0BF9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BF5 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0BF9 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0BFA: // Incoming jump from 0x0BF0, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0C01 memory[0x40:0x60] // @0C02 returndata.length // } 0BFA 5B JUMPDEST 0BFB 50 POP 0BFC 50 POP 0BFD 50 POP 0BFE 50 POP 0BFF 60 PUSH1 0x40 0C01 51 MLOAD 0C02 3D RETURNDATASIZE 0C03 60 PUSH1 0x20 0C05 81 DUP2 0C06 10 LT 0C07 15 ISZERO 0C08 61 PUSH2 0x0c10 0C0B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0C01 stack[-4] = memory[0x40:0x60] // @0C02 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0c10, if !(returndata.length < 0x20) label_0C0C: // Incoming jump from 0x0C0B, if not !(returndata.length < 0x20) // 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 !(returndata.length < 0x20) // Inputs[9] // { // @0C12 stack[-2] // @0C12 memory[stack[-2]:stack[-2] + 0x20] // @0C13 stack[-3] // @0C18 memory[0x00:0x20] // @0C21 memory[0x00:0x20] // @0C29 stack[-6] // @0C30 stack[-4] // @0C31 stack[-5] // @0C32 stack[-7] // } 0C10 5B JUMPDEST 0C11 50 POP 0C12 51 MLOAD 0C13 90 SWAP1 0C14 50 POP 0C15 60 PUSH1 0x00 0C17 80 DUP1 0C18 51 MLOAD 0C19 60 PUSH1 0x20 0C1B 61 PUSH2 0x4418 0C1E 83 DUP4 0C1F 39 CODECOPY 0C20 81 DUP2 0C21 51 MLOAD 0C22 91 SWAP2 0C23 52 MSTORE 0C24 63 PUSH4 0x45e6bdcd 0C29 85 DUP6 0C2A 60 PUSH1 0x00 0C2C 61 PUSH2 0x0c37 0C2F 85 DUP6 0C30 87 DUP8 0C31 89 DUP10 0C32 8C DUP13 0C33 61 PUSH2 0x3b8b 0C36 56 *JUMP // Stack delta = +7 // Outputs[12] // { // @0C13 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @0C1F memory[0x00:0x20] = code[0x4418:0x4438] // @0C22 stack[-2] = memory[0x00:0x20] // @0C23 memory[0x00:0x20] = memory[0x00:0x20] // @0C24 stack[-1] = 0x45e6bdcd // @0C29 stack[0] = stack[-6] // @0C2A stack[1] = 0x00 // @0C2C stack[2] = 0x0c37 // @0C2F stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0C30 stack[4] = stack[-4] // @0C31 stack[5] = stack[-5] // @0C32 stack[6] = stack[-7] // } // Block ends with unconditional jump to 0x3b8b 0C37 5B JUMPDEST 0C38 60 PUSH1 0x40 0C3A 51 MLOAD 0C3B 84 DUP5 0C3C 63 PUSH4 0xffffffff 0C41 16 AND 0C42 60 PUSH1 0xe0 0C44 1B SHL 0C45 81 DUP2 0C46 52 MSTORE 0C47 60 PUSH1 0x04 0C49 01 ADD 0C4A 80 DUP1 0C4B 84 DUP5 0C4C 81 DUP2 0C4D 52 MSTORE 0C4E 60 PUSH1 0x20 0C50 01 ADD 0C51 83 DUP4 0C52 81 DUP2 0C53 52 MSTORE 0C54 60 PUSH1 0x20 0C56 01 ADD 0C57 82 DUP3 0C58 81 DUP2 0C59 52 MSTORE 0C5A 60 PUSH1 0x20 0C5C 01 ADD 0C5D 93 SWAP4 0C5E 50 POP 0C5F 50 POP 0C60 50 POP 0C61 50 POP 0C62 60 PUSH1 0x00 0C64 60 PUSH1 0x40 0C66 51 MLOAD 0C67 80 DUP1 0C68 83 DUP4 0C69 03 SUB 0C6A 81 DUP2 0C6B 60 PUSH1 0x00 0C6D 87 DUP8 0C6E 80 DUP1 0C6F 3B EXTCODESIZE 0C70 15 ISZERO 0C71 80 DUP1 0C72 15 ISZERO 0C73 61 PUSH2 0x0c7b 0C76 57 *JUMPI 0C77 60 PUSH1 0x00 0C79 80 DUP1 0C7A FD *REVERT 0C7B 5B JUMPDEST 0C7C 50 POP 0C7D 5A GAS 0C7E F1 CALL 0C7F 15 ISZERO 0C80 80 DUP1 0C81 15 ISZERO 0C82 61 PUSH2 0x0c8f 0C85 57 *JUMPI 0C86 3D RETURNDATASIZE 0C87 60 PUSH1 0x00 0C89 80 DUP1 0C8A 3E RETURNDATACOPY 0C8B 3D RETURNDATASIZE 0C8C 60 PUSH1 0x00 0C8E FD *REVERT 0C8F 5B JUMPDEST 0C90 50 POP 0C91 50 POP 0C92 50 POP 0C93 50 POP 0C94 60 PUSH1 0x00 0C96 80 DUP1 0C97 51 MLOAD 0C98 60 PUSH1 0x20 0C9A 61 PUSH2 0x4418 0C9D 83 DUP4 0C9E 39 CODECOPY 0C9F 81 DUP2 0CA0 51 MLOAD 0CA1 91 SWAP2 0CA2 52 MSTORE 0CA3 60 PUSH1 0x01 0CA5 60 PUSH1 0x01 0CA7 60 PUSH1 0xa0 0CA9 1B SHL 0CAA 03 SUB 0CAB 16 AND 0CAC 63 PUSH4 0xf9f30db6 0CB1 85 DUP6 0CB2 30 ADDRESS 0CB3 61 PUSH2 0x0cbb 0CB6 89 DUP10 0CB7 61 PUSH2 0x3af1 0CBA 56 *JUMP 0CBB 5B JUMPDEST 0CBC 60 PUSH1 0x40 0CBE 51 MLOAD 0CBF 84 DUP5 0CC0 63 PUSH4 0xffffffff 0CC5 16 AND 0CC6 60 PUSH1 0xe0 0CC8 1B SHL 0CC9 81 DUP2 0CCA 52 MSTORE 0CCB 60 PUSH1 0x04 0CCD 01 ADD 0CCE 80 DUP1 0CCF 84 DUP5 0CD0 81 DUP2 0CD1 52 MSTORE 0CD2 60 PUSH1 0x20 0CD4 01 ADD 0CD5 83 DUP4 0CD6 60 PUSH1 0x01 0CD8 60 PUSH1 0x01 0CDA 60 PUSH1 0xa0 0CDC 1B SHL 0CDD 03 SUB 0CDE 16 AND 0CDF 81 DUP2 0CE0 52 MSTORE 0CE1 60 PUSH1 0x20 0CE3 01 ADD 0CE4 82 DUP3 0CE5 81 DUP2 0CE6 52 MSTORE 0CE7 60 PUSH1 0x20 0CE9 01 ADD 0CEA 93 SWAP4 0CEB 50 POP 0CEC 50 POP 0CED 50 POP 0CEE 50 POP 0CEF 60 PUSH1 0x00 0CF1 60 PUSH1 0x40 0CF3 51 MLOAD 0CF4 80 DUP1 0CF5 83 DUP4 0CF6 03 SUB 0CF7 81 DUP2 0CF8 60 PUSH1 0x00 0CFA 87 DUP8 0CFB 80 DUP1 0CFC 3B EXTCODESIZE 0CFD 15 ISZERO 0CFE 80 DUP1 0CFF 15 ISZERO 0D00 61 PUSH2 0x0d08 0D03 57 *JUMPI 0D04 60 PUSH1 0x00 0D06 80 DUP1 0D07 FD *REVERT 0D08 5B JUMPDEST 0D09 50 POP 0D0A 5A GAS 0D0B F1 CALL 0D0C 15 ISZERO 0D0D 80 DUP1 0D0E 15 ISZERO 0D0F 61 PUSH2 0x0d1c 0D12 57 *JUMPI 0D13 3D RETURNDATASIZE 0D14 60 PUSH1 0x00 0D16 80 DUP1 0D17 3E RETURNDATACOPY 0D18 3D RETURNDATASIZE 0D19 60 PUSH1 0x00 0D1B FD *REVERT 0D1C 5B JUMPDEST 0D1D 50 POP 0D1E 50 POP 0D1F 60 PUSH1 0x40 0D21 80 DUP1 0D22 51 MLOAD 0D23 63 PUSH4 0x4538c4eb 0D28 60 PUSH1 0xe0 0D2A 1B SHL 0D2B 81 DUP2 0D2C 52 MSTORE 0D2D 30 ADDRESS 0D2E 60 PUSH1 0x04 0D30 82 DUP3 0D31 01 ADD 0D32 52 MSTORE 0D33 60 PUSH1 0x00 0D35 80 DUP1 0D36 51 MLOAD 0D37 60 PUSH1 0x20 0D39 61 PUSH2 0x4293 0D3C 83 DUP4 0D3D 39 CODECOPY 0D3E 81 DUP2 0D3F 51 MLOAD 0D40 91 SWAP2 0D41 52 MSTORE 0D42 60 PUSH1 0x24 0D44 82 DUP3 0D45 01 ADD 0D46 52 MSTORE 0D47 90 SWAP1 0D48 51 MLOAD 0D49 60 PUSH1 0x01 0D4B 60 PUSH1 0x01 0D4D 60 PUSH1 0xa0 0D4F 1B SHL 0D50 03 SUB 0D51 85 DUP6 0D52 16 AND 0D53 93 SWAP4 0D54 50 POP 0D55 63 PUSH4 0x4538c4eb 0D5A 92 SWAP3 0D5B 50 POP 0D5C 60 PUSH1 0x44 0D5E 80 DUP1 0D5F 83 DUP4 0D60 01 ADD 0D61 92 SWAP3 0D62 60 PUSH1 0x20 0D64 92 SWAP3 0D65 91 SWAP2 0D66 90 SWAP1 0D67 82 DUP3 0D68 90 SWAP1 0D69 03 SUB 0D6A 01 ADD 0D6B 81 DUP2 0D6C 86 DUP7 0D6D 80 DUP1 0D6E 3B EXTCODESIZE 0D6F 15 ISZERO 0D70 80 DUP1 0D71 15 ISZERO 0D72 61 PUSH2 0x0d7a 0D75 57 *JUMPI 0D76 60 PUSH1 0x00 0D78 80 DUP1 0D79 FD *REVERT 0D7A 5B JUMPDEST 0D7B 50 POP 0D7C 5A GAS 0D7D FA STATICCALL 0D7E 15 ISZERO 0D7F 80 DUP1 0D80 15 ISZERO 0D81 61 PUSH2 0x0d8e 0D84 57 *JUMPI 0D85 3D RETURNDATASIZE 0D86 60 PUSH1 0x00 0D88 80 DUP1 0D89 3E RETURNDATACOPY 0D8A 3D RETURNDATASIZE 0D8B 60 PUSH1 0x00 0D8D FD *REVERT 0D8E 5B JUMPDEST 0D8F 50 POP 0D90 50 POP 0D91 50 POP 0D92 50 POP 0D93 60 PUSH1 0x40 0D95 51 MLOAD 0D96 3D RETURNDATASIZE 0D97 60 PUSH1 0x20 0D99 81 DUP2 0D9A 10 LT 0D9B 15 ISZERO 0D9C 61 PUSH2 0x0da4 0D9F 57 *JUMPI 0DA0 60 PUSH1 0x00 0DA2 80 DUP1 0DA3 FD *REVERT 0DA4 5B JUMPDEST 0DA5 50 POP 0DA6 51 MLOAD 0DA7 61 PUSH2 0x0e18 0DAA 57 *JUMPI 0DAB 60 PUSH1 0x40 0DAD 80 DUP1 0DAE 51 MLOAD 0DAF 63 PUSH4 0x28ec8bf1 0DB4 60 PUSH1 0xe2 0DB6 1B SHL 0DB7 81 DUP2 0DB8 52 MSTORE 0DB9 60 PUSH1 0x00 0DBB 80 DUP1 0DBC 51 MLOAD 0DBD 60 PUSH1 0x20 0DBF 61 PUSH2 0x4293 0DC2 83 DUP4 0DC3 39 CODECOPY 0DC4 81 DUP2 0DC5 51 MLOAD 0DC6 91 SWAP2 0DC7 52 MSTORE 0DC8 60 PUSH1 0x04 0DCA 82 DUP3 0DCB 01 ADD 0DCC 52 MSTORE 0DCD 90 SWAP1 0DCE 51 MLOAD 0DCF 60 PUSH1 0x01 0DD1 60 PUSH1 0x01 0DD3 60 PUSH1 0xa0 0DD5 1B SHL 0DD6 03 SUB 0DD7 83 DUP4 0DD8 16 AND 0DD9 91 SWAP2 0DDA 63 PUSH4 0xa3b22fc4 0DDF 91 SWAP2 0DE0 60 PUSH1 0x24 0DE2 80 DUP1 0DE3 83 DUP4 0DE4 01 ADD 0DE5 92 SWAP3 0DE6 60 PUSH1 0x00 0DE8 92 SWAP3 0DE9 91 SWAP2 0DEA 90 SWAP1 0DEB 82 DUP3 0DEC 90 SWAP1 0DED 03 SUB 0DEE 01 ADD 0DEF 81 DUP2 0DF0 83 DUP4 0DF1 87 DUP8 0DF2 80 DUP1 0DF3 3B EXTCODESIZE 0DF4 15 ISZERO 0DF5 80 DUP1 0DF6 15 ISZERO 0DF7 61 PUSH2 0x0dff 0DFA 57 *JUMPI 0DFB 60 PUSH1 0x00 0DFD 80 DUP1 0DFE FD *REVERT 0DFF 5B JUMPDEST 0E00 50 POP 0E01 5A GAS 0E02 F1 CALL 0E03 15 ISZERO 0E04 80 DUP1 0E05 15 ISZERO 0E06 61 PUSH2 0x0e13 0E09 57 *JUMPI 0E0A 3D RETURNDATASIZE 0E0B 60 PUSH1 0x00 0E0D 80 DUP1 0E0E 3E RETURNDATACOPY 0E0F 3D RETURNDATASIZE 0E10 60 PUSH1 0x00 0E12 FD *REVERT 0E13 5B JUMPDEST 0E14 50 POP 0E15 50 POP 0E16 50 POP 0E17 50 POP 0E18 5B JUMPDEST 0E19 60 PUSH1 0x40 0E1B 80 DUP1 0E1C 51 MLOAD 0E1D 63 PUSH4 0xef693bed 0E22 60 PUSH1 0xe0 0E24 1B SHL 0E25 81 DUP2 0E26 52 MSTORE 0E27 30 ADDRESS 0E28 60 PUSH1 0x04 0E2A 82 DUP3 0E2B 01 ADD 0E2C 52 MSTORE 0E2D 60 PUSH1 0x24 0E2F 81 DUP2 0E30 01 ADD 0E31 87 DUP8 0E32 90 SWAP1 0E33 52 MSTORE 0E34 90 SWAP1 0E35 51 MLOAD 0E36 60 PUSH1 0x00 0E38 80 DUP1 0E39 51 MLOAD 0E3A 60 PUSH1 0x20 0E3C 61 PUSH2 0x4293 0E3F 83 DUP4 0E40 39 CODECOPY 0E41 81 DUP2 0E42 51 MLOAD 0E43 91 SWAP2 0E44 52 MSTORE 0E45 91 SWAP2 0E46 63 PUSH4 0xef693bed 0E4B 91 SWAP2 0E4C 60 PUSH1 0x44 0E4E 80 DUP1 0E4F 83 DUP4 0E50 01 ADD 0E51 92 SWAP3 0E52 60 PUSH1 0x00 0E54 92 SWAP3 0E55 91 SWAP2 0E56 90 SWAP1 0E57 82 DUP3 0E58 90 SWAP1 0E59 03 SUB 0E5A 01 ADD 0E5B 81 DUP2 0E5C 83 DUP4 0E5D 87 DUP8 0E5E 80 DUP1 0E5F 3B EXTCODESIZE 0E60 15 ISZERO 0E61 80 DUP1 0E62 15 ISZERO 0E63 61 PUSH2 0x0e6b 0E66 57 *JUMPI 0E67 60 PUSH1 0x00 0E69 80 DUP1 0E6A FD *REVERT 0E6B 5B JUMPDEST 0E6C 50 POP 0E6D 5A GAS 0E6E F1 CALL 0E6F 15 ISZERO 0E70 80 DUP1 0E71 15 ISZERO 0E72 61 PUSH2 0x0e7f 0E75 57 *JUMPI 0E76 3D RETURNDATASIZE 0E77 60 PUSH1 0x00 0E79 80 DUP1 0E7A 3E RETURNDATACOPY 0E7B 3D RETURNDATASIZE 0E7C 60 PUSH1 0x00 0E7E FD *REVERT 0E7F 5B JUMPDEST 0E80 50 POP 0E81 50 POP 0E82 50 POP 0E83 50 POP 0E84 61 PUSH2 0x0e8d 0E87 88 DUP9 0E88 86 DUP7 0E89 61 PUSH2 0x3b0e 0E8C 56 *JUMP 0E8D 5B JUMPDEST 0E8E 60 PUSH1 0x40 0E90 51 MLOAD 0E91 80 DUP1 0E92 60 PUSH1 0x60 0E94 01 ADD 0E95 60 PUSH1 0x40 0E97 52 MSTORE 0E98 80 DUP1 0E99 60 PUSH1 0x32 0E9B 81 DUP2 0E9C 52 MSTORE 0E9D 60 PUSH1 0x20 0E9F 01 ADD 0EA0 61 PUSH2 0x435f 0EA3 60 PUSH1 0x32 0EA5 91 SWAP2 0EA6 39 CODECOPY 0EA7 60 PUSH1 0x40 0EA9 80 DUP1 0EAA 51 MLOAD 0EAB 60 PUSH1 0x20 0EAD 81 DUP2 0EAE 01 ADD 0EAF 96 SWAP7 0EB0 90 SWAP1 0EB1 96 SWAP7 0EB2 52 MSTORE 0EB3 85 DUP6 0EB4 81 DUP2 0EB5 01 ADD 0EB6 94 SWAP5 0EB7 90 SWAP1 0EB8 94 SWAP5 0EB9 52 MSTORE 0EBA 60 PUSH1 0x60 0EBC 85 DUP6 0EBD 01 ADD 0EBE 95 SWAP6 0EBF 90 SWAP1 0EC0 95 SWAP6 0EC1 52 MSTORE 0EC2 50 POP 0EC3 50 POP 0EC4 60 PUSH1 0x80 0EC6 82 DUP3 0EC7 01 ADD 0EC8 96 SWAP7 0EC9 90 SWAP1 0ECA 96 SWAP7 0ECB 52 MSTORE 0ECC 60 PUSH1 0xa0 0ECE 80 DUP1 0ECF 82 DUP3 0ED0 01 ADD 0ED1 95 SWAP6 0ED2 90 SWAP1 0ED3 95 SWAP6 0ED4 52 MSTORE 0ED5 85 DUP6 0ED6 51 MLOAD 0ED7 80 DUP1 0ED8 82 DUP3 0ED9 03 SUB 0EDA 90 SWAP1 0EDB 95 SWAP6 0EDC 01 ADD 0EDD 85 DUP6 0EDE 52 MSTORE 0EDF 60 PUSH1 0xc0 0EE1 01 ADD 0EE2 90 SWAP1 0EE3 94 SWAP5 0EE4 52 MSTORE 0EE5 50 POP 0EE6 91 SWAP2 0EE7 94 SWAP5 0EE8 90 SWAP1 0EE9 93 SWAP4 0EEA 50 POP 0EEB 91 SWAP2 0EEC 50 POP 0EED 50 POP 0EEE 56 *JUMP label_0EEF: // Incoming jump from 0x02D8 // Inputs[2] // { // @0EF8 stack[-2] // @0EF9 stack[-3] // } 0EEF 5B JUMPDEST 0EF0 60 PUSH1 0x60 0EF2 80 DUP1 0EF3 60 PUSH1 0x00 0EF5 61 PUSH2 0x0efe 0EF8 85 DUP6 0EF9 87 DUP8 0EFA 61 PUSH2 0x3a55 0EFD 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0EF0 stack[0] = 0x60 // @0EF2 stack[1] = 0x60 // @0EF3 stack[2] = 0x00 // @0EF5 stack[3] = 0x0efe // @0EF8 stack[4] = stack[-2] // @0EF9 stack[5] = stack[-3] // } // Block ends with call to 0x3a55, returns to 0x0EFE label_0EFE: // Incoming return from call to 0x3A55 at 0x0EFD // Inputs[3] // { // @0EFF stack[-2] // @0EFF stack[-1] // @0F06 stack[-8] // } 0EFE 5B JUMPDEST 0EFF 90 SWAP1 0F00 50 POP 0F01 60 PUSH1 0x00 0F03 61 PUSH2 0x0f0b 0F06 88 DUP9 0F07 61 PUSH2 0x3804 0F0A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0EFF stack[-2] = stack[-1] // @0F01 stack[-1] = 0x00 // @0F03 stack[0] = 0x0f0b // @0F06 stack[1] = stack[-8] // } // Block ends with call to 0x3804, returns to 0x0F0B label_0F0B: // Incoming return from call to 0x3804 at 0x0F0A // Inputs[2] // { // @0F0C stack[-1] // @0F0C stack[-2] // } 0F0B 5B JUMPDEST 0F0C 90 SWAP1 0F0D 50 POP 0F0E 60 PUSH1 0x00 0F10 80 DUP1 0F11 61 PUSH2 0x0f19 0F14 83 DUP4 0F15 61 PUSH2 0x3950 0F18 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0F0C stack[-2] = stack[-1] // @0F0E stack[-1] = 0x00 // @0F10 stack[0] = 0x00 // @0F11 stack[1] = 0x0f19 // @0F14 stack[2] = stack[-1] // } // Block ends with call to 0x3950, returns to 0x0F19 label_0F19: // Incoming return from call to 0x3950 at 0x0F18 // Inputs[7] // { // @0F1A stack[-3] // @0F1A stack[-1] // @0F1C stack[-4] // @0F1C stack[-2] // @0F46 memory[0x40:0x60] // @0F64 memory[0x40:0x60] // @0F6B address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } 0F19 5B JUMPDEST 0F1A 91 SWAP2 0F1B 50 POP 0F1C 91 SWAP2 0F1D 50 POP 0F1E 60 PUSH1 0x00 0F20 73 PUSH20 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 0F35 60 PUSH1 0x01 0F37 60 PUSH1 0x01 0F39 60 PUSH1 0xa0 0F3B 1B SHL 0F3C 03 SUB 0F3D 16 AND 0F3E 63 PUSH4 0x4445d799 0F43 84 DUP5 0F44 60 PUSH1 0x40 0F46 51 MLOAD 0F47 82 DUP3 0F48 63 PUSH4 0xffffffff 0F4D 16 AND 0F4E 60 PUSH1 0xe0 0F50 1B SHL 0F51 81 DUP2 0F52 52 MSTORE 0F53 60 PUSH1 0x04 0F55 01 ADD 0F56 80 DUP1 0F57 82 DUP3 0F58 81 DUP2 0F59 52 MSTORE 0F5A 60 PUSH1 0x20 0F5C 01 ADD 0F5D 91 SWAP2 0F5E 50 POP 0F5F 50 POP 0F60 60 PUSH1 0x20 0F62 60 PUSH1 0x40 0F64 51 MLOAD 0F65 80 DUP1 0F66 83 DUP4 0F67 03 SUB 0F68 81 DUP2 0F69 86 DUP7 0F6A 80 DUP1 0F6B 3B EXTCODESIZE 0F6C 15 ISZERO 0F6D 80 DUP1 0F6E 15 ISZERO 0F6F 61 PUSH2 0x0f77 0F72 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @0F1A stack[-3] = stack[-1] // @0F1C stack[-4] = stack[-2] // @0F1E stack[-2] = 0x00 // @0F3D stack[-1] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @0F3E stack[0] = 0x4445d799 // @0F52 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x4445d799) << 0xe0 // @0F59 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @0F5D stack[1] = 0x20 + 0x04 + memory[0x40:0x60] // @0F60 stack[2] = 0x20 // @0F64 stack[3] = memory[0x40:0x60] // @0F67 stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0F68 stack[5] = memory[0x40:0x60] // @0F69 stack[6] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @0F6C stack[7] = !address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } // Block ends with conditional jump to 0x0f77, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length label_0F73: // Incoming jump from 0x0F72, if not !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[1] { @0F76 memory[0x00:0x00] } 0F73 60 PUSH1 0x00 0F75 80 DUP1 0F76 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F76 revert(memory[0x00:0x00]); } // Block terminates label_0F77: // Incoming jump from 0x0F72, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[8] // { // @0F79 msg.gas // @0F7A stack[-2] // @0F7A stack[-3] // @0F7A stack[-6] // @0F7A memory[stack[-3]:stack[-3] + stack[-4]] // @0F7A address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0F7A stack[-5] // @0F7A stack[-4] // } 0F77 5B JUMPDEST 0F78 50 POP 0F79 5A GAS 0F7A FA STATICCALL 0F7B 15 ISZERO 0F7C 80 DUP1 0F7D 15 ISZERO 0F7E 61 PUSH2 0x0f8b 0F81 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0F7A memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0F7B stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0f8b, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0F82: // Incoming jump from 0x0F81, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0F82 returndata.length // @0F86 returndata[0x00:0x00 + returndata.length] // @0F87 returndata.length // @0F8A memory[0x00:0x00 + returndata.length] // } 0F82 3D RETURNDATASIZE 0F83 60 PUSH1 0x00 0F85 80 DUP1 0F86 3E RETURNDATACOPY 0F87 3D RETURNDATASIZE 0F88 60 PUSH1 0x00 0F8A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F86 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0F8A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0F8B: // Incoming jump from 0x0F81, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0F92 memory[0x40:0x60] // @0F93 returndata.length // } 0F8B 5B JUMPDEST 0F8C 50 POP 0F8D 50 POP 0F8E 50 POP 0F8F 50 POP 0F90 60 PUSH1 0x40 0F92 51 MLOAD 0F93 3D RETURNDATASIZE 0F94 60 PUSH1 0x20 0F96 81 DUP2 0F97 10 LT 0F98 15 ISZERO 0F99 61 PUSH2 0x0fa1 0F9C 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0F92 stack[-4] = memory[0x40:0x60] // @0F93 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0fa1, if !(returndata.length < 0x20) label_0F9D: // Incoming jump from 0x0F9C, if not !(returndata.length < 0x20) // Inputs[1] { @0FA0 memory[0x00:0x00] } 0F9D 60 PUSH1 0x00 0F9F 80 DUP1 0FA0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FA0 revert(memory[0x00:0x00]); } // Block terminates label_0FA1: // Incoming jump from 0x0F9C, if !(returndata.length < 0x20) // Inputs[6] // { // @0FA3 stack[-2] // @0FA3 memory[stack[-2]:stack[-2] + 0x20] // @0FA7 memory[0x40:0x60] // @0FB3 memory[0x40:0x60] // @0FB5 stack[-3] // @0FE1 address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } 0FA1 5B JUMPDEST 0FA2 50 POP 0FA3 51 MLOAD 0FA4 60 PUSH1 0x40 0FA6 80 DUP1 0FA7 51 MLOAD 0FA8 63 PUSH4 0x7bd2bea7 0FAD 60 PUSH1 0xe0 0FAF 1B SHL 0FB0 81 DUP2 0FB1 52 MSTORE 0FB2 90 SWAP1 0FB3 51 MLOAD 0FB4 91 SWAP2 0FB5 92 SWAP3 0FB6 50 POP 0FB7 82 DUP3 0FB8 91 SWAP2 0FB9 60 PUSH1 0x00 0FBB 91 SWAP2 0FBC 60 PUSH1 0x01 0FBE 60 PUSH1 0x01 0FC0 60 PUSH1 0xa0 0FC2 1B SHL 0FC3 03 SUB 0FC4 84 DUP5 0FC5 16 AND 0FC6 91 SWAP2 0FC7 63 PUSH4 0x7bd2bea7 0FCC 91 SWAP2 0FCD 60 PUSH1 0x04 0FCF 80 DUP1 0FD0 82 DUP3 0FD1 01 ADD 0FD2 92 SWAP3 0FD3 60 PUSH1 0x20 0FD5 92 SWAP3 0FD6 90 SWAP1 0FD7 91 SWAP2 0FD8 90 SWAP1 0FD9 82 DUP3 0FDA 90 SWAP1 0FDB 03 SUB 0FDC 01 ADD 0FDD 81 DUP2 0FDE 87 DUP8 0FDF 87 DUP8 0FE0 80 DUP1 0FE1 3B EXTCODESIZE 0FE2 15 ISZERO 0FE3 80 DUP1 0FE4 15 ISZERO 0FE5 61 PUSH2 0x0fed 0FE8 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @0FB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7bd2bea7 << 0xe0 // @0FB5 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @0FB8 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @0FBB stack[-1] = 0x00 // @0FC6 stack[0] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0FCC stack[1] = 0x7bd2bea7 // @0FD2 stack[2] = memory[0x40:0x60] + 0x04 // @0FD5 stack[3] = 0x20 // @0FD7 stack[4] = memory[0x40:0x60] // @0FDC stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @0FDD stack[6] = memory[0x40:0x60] // @0FDE stack[7] = 0x00 // @0FDF stack[8] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0FE2 stack[9] = !address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0fed, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length label_0FE9: // Incoming jump from 0x0FE8, if not !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // 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 !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @0FEF msg.gas // @0FF0 stack[-2] // @0FF0 stack[-3] // @0FF0 stack[-5] // @0FF0 memory[stack[-4]:stack[-4] + stack[-5]] // @0FF0 stack[-4] // @0FF0 stack[-6] // @0FF0 stack[-7] // @0FF0 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0FED 5B JUMPDEST 0FEE 50 POP 0FEF 5A GAS 0FF0 F1 CALL 0FF1 15 ISZERO 0FF2 80 DUP1 0FF3 15 ISZERO 0FF4 61 PUSH2 0x1001 0FF7 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0FF0 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0FF1 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1001, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0FF8: // Incoming jump from 0x0FF7, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0FF8 returndata.length // @0FFC returndata[0x00:0x00 + returndata.length] // @0FFD returndata.length // @1000 memory[0x00:0x00 + returndata.length] // } 0FF8 3D RETURNDATASIZE 0FF9 60 PUSH1 0x00 0FFB 80 DUP1 0FFC 3E RETURNDATACOPY 0FFD 3D RETURNDATASIZE 0FFE 60 PUSH1 0x00 1000 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FFC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1000 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1001: // Incoming jump from 0x0FF7, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1008 memory[0x40:0x60] // @1009 returndata.length // } 1001 5B JUMPDEST 1002 50 POP 1003 50 POP 1004 50 POP 1005 50 POP 1006 60 PUSH1 0x40 1008 51 MLOAD 1009 3D RETURNDATASIZE 100A 60 PUSH1 0x20 100C 81 DUP2 100D 10 LT 100E 15 ISZERO 100F 61 PUSH2 0x1017 1012 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1008 stack[-4] = memory[0x40:0x60] // @1009 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1017, if !(returndata.length < 0x20) label_1013: // Incoming jump from 0x1012, if not !(returndata.length < 0x20) // Inputs[1] { @1016 memory[0x00:0x00] } 1013 60 PUSH1 0x00 1015 80 DUP1 1016 FD *REVERT // Stack delta = +0 // Outputs[1] { @1016 revert(memory[0x00:0x00]); } // Block terminates label_1017: // Incoming jump from 0x1012, if !(returndata.length < 0x20) // Inputs[3] // { // @1019 memory[stack[-2]:stack[-2] + 0x20] // @1019 stack[-2] // @101A stack[-3] // } 1017 5B JUMPDEST 1018 50 POP 1019 51 MLOAD 101A 90 SWAP1 101B 50 POP 101C 61 PUSH2 0x1024 101F 81 DUP2 1020 61 PUSH2 0x3d1b 1023 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @101A stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @101C stack[-2] = 0x1024 // @101F stack[-1] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3d1b, returns to 0x1024 label_1024: // Incoming return from call to 0x3D1B at 0x1023 // Inputs[1] { @1025 stack[-1] } 1024 5B JUMPDEST 1025 15 ISZERO 1026 61 PUSH2 0x1095 1029 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1095, if !stack[-1] label_102A: // Incoming jump from 0x1029, if not !stack[-1] // Inputs[1] { @102D stack[-7] } 102A 60 PUSH1 0x00 102C 19 NOT 102D 87 DUP8 102E 14 EQ 102F 61 PUSH2 0x1038 1032 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1038, if stack[-7] == ~0x00 label_1033: // Incoming jump from 0x1032, if not stack[-7] == ~0x00 // Inputs[1] { @1033 stack[-7] } 1033 86 DUP7 1034 61 PUSH2 0x103a 1037 56 *JUMP // Stack delta = +1 // Outputs[1] { @1033 stack[0] = stack[-7] } // Block ends with unconditional jump to 0x103a label_1038: // Incoming jump from 0x1032, if stack[-7] == ~0x00 // Inputs[7] // { // @1039 address(this).balance // @1039 address(this) // @103B stack[-7] // @103D stack[-1] // @104F memory[0x40:0x60] // @1063 memory[0x40:0x60] // @106B address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } 1038 5B JUMPDEST 1039 47 SELFBALANCE 103A 5B JUMPDEST 103B 96 SWAP7 103C 50 POP 103D 80 DUP1 103E 60 PUSH1 0x01 1040 60 PUSH1 0x01 1042 60 PUSH1 0xa0 1044 1B SHL 1045 03 SUB 1046 16 AND 1047 63 PUSH4 0xd0e30db0 104C 88 DUP9 104D 60 PUSH1 0x40 104F 51 MLOAD 1050 82 DUP3 1051 63 PUSH4 0xffffffff 1056 16 AND 1057 60 PUSH1 0xe0 1059 1B SHL 105A 81 DUP2 105B 52 MSTORE 105C 60 PUSH1 0x04 105E 01 ADD 105F 60 PUSH1 0x00 1061 60 PUSH1 0x40 1063 51 MLOAD 1064 80 DUP1 1065 83 DUP4 1066 03 SUB 1067 81 DUP2 1068 85 DUP6 1069 88 DUP9 106A 80 DUP1 106B 3B EXTCODESIZE 106C 15 ISZERO 106D 80 DUP1 106E 15 ISZERO 106F 61 PUSH2 0x1077 1072 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @103B stack[-7] = address(this).balance // @1046 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1047 stack[1] = 0xd0e30db0 // @104C stack[2] = address(this).balance // @105B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd0e30db0) << 0xe0 // @105E stack[3] = 0x04 + memory[0x40:0x60] // @105F stack[4] = 0x00 // @1063 stack[5] = memory[0x40:0x60] // @1066 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1067 stack[7] = memory[0x40:0x60] // @1068 stack[8] = address(this).balance // @1069 stack[9] = (0x01 << 0xa0) - 0x01 & stack[-1] // @106C stack[10] = !address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } // Block ends with conditional jump to 0x1077, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length label_1073: // Incoming jump from 0x1072, if not !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Incoming jump from 0x1072, if not !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // Inputs[1] { @1076 memory[0x00:0x00] } 1073 60 PUSH1 0x00 1075 80 DUP1 1076 FD *REVERT // Stack delta = +0 // Outputs[1] { @1076 revert(memory[0x00:0x00]); } // Block terminates label_1077: // Incoming jump from 0x1072, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Incoming jump from 0x1072, if !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // Inputs[9] // { // @1079 msg.gas // @107A stack[-3] // @107A stack[-6] // @107A stack[-7] // @107A memory[stack[-4]:stack[-4] + stack[-5]] // @107A stack[-2] // @107A stack[-5] // @107A stack[-4] // @107A address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 1077 5B JUMPDEST 1078 50 POP 1079 5A GAS 107A F1 CALL 107B 15 ISZERO 107C 80 DUP1 107D 15 ISZERO 107E 61 PUSH2 0x108b 1081 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @107A memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @107B stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x108b, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1082: // Incoming jump from 0x1081, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1082 returndata.length // @1086 returndata[0x00:0x00 + returndata.length] // @1087 returndata.length // @108A memory[0x00:0x00 + returndata.length] // } 1082 3D RETURNDATASIZE 1083 60 PUSH1 0x00 1085 80 DUP1 1086 3E RETURNDATACOPY 1087 3D RETURNDATASIZE 1088 60 PUSH1 0x00 108A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1086 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @108A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_108B: // Incoming jump from 0x1081, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 108B 5B JUMPDEST 108C 50 POP 108D 50 POP 108E 50 POP 108F 50 POP 1090 50 POP 1091 61 PUSH2 0x111a 1094 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to 0x111a label_1095: // Incoming jump from 0x1029, if !stack[-1] // Inputs[1] { @1099 stack[-7] } 1095 5B JUMPDEST 1096 60 PUSH1 0x00 1098 19 NOT 1099 87 DUP8 109A 14 EQ 109B 61 PUSH2 0x10a4 109E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10a4, if stack[-7] == ~0x00 label_109F: // Incoming jump from 0x109E, if not stack[-7] == ~0x00 // Inputs[1] { @109F stack[-7] } 109F 86 DUP7 10A0 61 PUSH2 0x1117 10A3 56 *JUMP // Stack delta = +1 // Outputs[1] { @109F stack[0] = stack[-7] } // Block ends with unconditional jump to 0x1117 label_10A4: // Incoming jump from 0x109E, if stack[-7] == ~0x00 // Inputs[5] // { // @10A8 memory[0x40:0x60] // @10B3 address(this) // @10BA memory[0x40:0x60] // @10C3 stack[-1] // @10DE address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length // } 10A4 5B JUMPDEST 10A5 60 PUSH1 0x40 10A7 80 DUP1 10A8 51 MLOAD 10A9 63 PUSH4 0x70a08231 10AE 60 PUSH1 0xe0 10B0 1B SHL 10B1 81 DUP2 10B2 52 MSTORE 10B3 30 ADDRESS 10B4 60 PUSH1 0x04 10B6 82 DUP3 10B7 01 ADD 10B8 52 MSTORE 10B9 90 SWAP1 10BA 51 MLOAD 10BB 60 PUSH1 0x01 10BD 60 PUSH1 0x01 10BF 60 PUSH1 0xa0 10C1 1B SHL 10C2 03 SUB 10C3 83 DUP4 10C4 16 AND 10C5 91 SWAP2 10C6 63 PUSH4 0x70a08231 10CB 91 SWAP2 10CC 60 PUSH1 0x24 10CE 80 DUP1 10CF 83 DUP4 10D0 01 ADD 10D1 92 SWAP3 10D2 60 PUSH1 0x20 10D4 92 SWAP3 10D5 91 SWAP2 10D6 90 SWAP1 10D7 82 DUP3 10D8 90 SWAP1 10D9 03 SUB 10DA 01 ADD 10DB 81 DUP2 10DC 86 DUP7 10DD 80 DUP1 10DE 3B EXTCODESIZE 10DF 15 ISZERO 10E0 80 DUP1 10E1 15 ISZERO 10E2 61 PUSH2 0x10ea 10E5 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @10B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @10B8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @10C5 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 // @10CB stack[1] = 0x70a08231 // @10D1 stack[2] = memory[0x40:0x60] + 0x24 // @10D4 stack[3] = 0x20 // @10D5 stack[4] = memory[0x40:0x60] // @10DA stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @10DB stack[6] = memory[0x40:0x60] // @10DC stack[7] = stack[-1] & (0x01 << 0xa0) - 0x01 // @10DF stack[8] = !address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x10ea, if !!address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length label_10E6: // Incoming jump from 0x10E5, if not !!address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @10E9 memory[0x00:0x00] } 10E6 60 PUSH1 0x00 10E8 80 DUP1 10E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @10E9 revert(memory[0x00:0x00]); } // Block terminates label_10EA: // Incoming jump from 0x10E5, if !!address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @10EC msg.gas // @10ED memory[stack[-3]:stack[-3] + stack[-4]] // @10ED address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @10ED stack[-6] // @10ED stack[-3] // @10ED stack[-2] // @10ED stack[-4] // @10ED stack[-5] // } 10EA 5B JUMPDEST 10EB 50 POP 10EC 5A GAS 10ED FA STATICCALL 10EE 15 ISZERO 10EF 80 DUP1 10F0 15 ISZERO 10F1 61 PUSH2 0x10fe 10F4 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @10ED memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @10EE stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x10fe, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_10F5: // Incoming jump from 0x10F4, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @10F5 returndata.length // @10F9 returndata[0x00:0x00 + returndata.length] // @10FA returndata.length // @10FD memory[0x00:0x00 + returndata.length] // } 10F5 3D RETURNDATASIZE 10F6 60 PUSH1 0x00 10F8 80 DUP1 10F9 3E RETURNDATACOPY 10FA 3D RETURNDATASIZE 10FB 60 PUSH1 0x00 10FD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10F9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @10FD revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_10FE: // Incoming jump from 0x10F4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1105 memory[0x40:0x60] // @1106 returndata.length // } 10FE 5B JUMPDEST 10FF 50 POP 1100 50 POP 1101 50 POP 1102 50 POP 1103 60 PUSH1 0x40 1105 51 MLOAD 1106 3D RETURNDATASIZE 1107 60 PUSH1 0x20 1109 81 DUP2 110A 10 LT 110B 15 ISZERO 110C 61 PUSH2 0x1114 110F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1105 stack[-4] = memory[0x40:0x60] // @1106 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1114, if !(returndata.length < 0x20) label_1110: // Incoming jump from 0x110F, if not !(returndata.length < 0x20) // Inputs[1] { @1113 memory[0x00:0x00] } 1110 60 PUSH1 0x00 1112 80 DUP1 1113 FD *REVERT // Stack delta = +0 // Outputs[1] { @1113 revert(memory[0x00:0x00]); } // Block terminates label_1114: // Incoming jump from 0x110F, if !(returndata.length < 0x20) // Inputs[2] // { // @1116 memory[stack[-2]:stack[-2] + 0x20] // @1116 stack[-2] // } 1114 5B JUMPDEST 1115 50 POP 1116 51 MLOAD // Stack delta = -1 // Outputs[1] { @1116 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_1117: // Incoming jump from 0x10A3 // Incoming jump from 0x1116 // Inputs[2] // { // @1118 stack[-8] // @1118 stack[-1] // } 1117 5B JUMPDEST 1118 96 SWAP7 1119 50 POP // Stack delta = -1 // Outputs[1] { @1118 stack[-8] = stack[-1] } // Block continues label_111A: // Incoming jump from 0x1094 // Incoming jump from 0x1119 // Inputs[6] // { // @111B stack[-1] // @112A stack[-3] // @112B stack[-7] // @112E memory[0x40:0x60] // @115C memory[0x40:0x60] // @1165 address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } 111A 5B JUMPDEST 111B 80 DUP1 111C 60 PUSH1 0x01 111E 60 PUSH1 0x01 1120 60 PUSH1 0xa0 1122 1B SHL 1123 03 SUB 1124 16 AND 1125 63 PUSH4 0x095ea7b3 112A 84 DUP5 112B 89 DUP10 112C 60 PUSH1 0x40 112E 51 MLOAD 112F 83 DUP4 1130 63 PUSH4 0xffffffff 1135 16 AND 1136 60 PUSH1 0xe0 1138 1B SHL 1139 81 DUP2 113A 52 MSTORE 113B 60 PUSH1 0x04 113D 01 ADD 113E 80 DUP1 113F 83 DUP4 1140 60 PUSH1 0x01 1142 60 PUSH1 0x01 1144 60 PUSH1 0xa0 1146 1B SHL 1147 03 SUB 1148 16 AND 1149 81 DUP2 114A 52 MSTORE 114B 60 PUSH1 0x20 114D 01 ADD 114E 82 DUP3 114F 81 DUP2 1150 52 MSTORE 1151 60 PUSH1 0x20 1153 01 ADD 1154 92 SWAP3 1155 50 POP 1156 50 POP 1157 50 POP 1158 60 PUSH1 0x00 115A 60 PUSH1 0x40 115C 51 MLOAD 115D 80 DUP1 115E 83 DUP4 115F 03 SUB 1160 81 DUP2 1161 60 PUSH1 0x00 1163 87 DUP8 1164 80 DUP1 1165 3B EXTCODESIZE 1166 15 ISZERO 1167 80 DUP1 1168 15 ISZERO 1169 61 PUSH2 0x1171 116C 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @1124 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1125 stack[1] = 0x095ea7b3 // @113A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x095ea7b3) << 0xe0 // @114A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1150 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-7] // @1154 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1158 stack[3] = 0x00 // @115C stack[4] = memory[0x40:0x60] // @115F stack[5] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1160 stack[6] = memory[0x40:0x60] // @1161 stack[7] = 0x00 // @1163 stack[8] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1166 stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } // Block ends with conditional jump to 0x1171, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length label_116D: // Incoming jump from 0x116C, if not !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[1] { @1170 memory[0x00:0x00] } 116D 60 PUSH1 0x00 116F 80 DUP1 1170 FD *REVERT // Stack delta = +0 // Outputs[1] { @1170 revert(memory[0x00:0x00]); } // Block terminates label_1171: // Incoming jump from 0x116C, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[9] // { // @1173 msg.gas // @1174 stack[-3] // @1174 stack[-6] // @1174 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1174 memory[stack[-4]:stack[-4] + stack[-5]] // @1174 stack[-2] // @1174 stack[-5] // @1174 stack[-4] // @1174 stack[-7] // } 1171 5B JUMPDEST 1172 50 POP 1173 5A GAS 1174 F1 CALL 1175 15 ISZERO 1176 80 DUP1 1177 15 ISZERO 1178 61 PUSH2 0x1185 117B 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1174 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1175 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1185, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_117C: // Incoming jump from 0x117B, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @117C returndata.length // @1180 returndata[0x00:0x00 + returndata.length] // @1181 returndata.length // @1184 memory[0x00:0x00 + returndata.length] // } 117C 3D RETURNDATASIZE 117D 60 PUSH1 0x00 117F 80 DUP1 1180 3E RETURNDATACOPY 1181 3D RETURNDATASIZE 1182 60 PUSH1 0x00 1184 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1180 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1184 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1185: // Incoming jump from 0x117B, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[8] // { // @118B memory[0x40:0x60] // @1196 address(this) // @11A0 stack[-11] // @11A4 memory[0x40:0x60] // @11AD stack[-6] // @11AF stack[-4] // @11B6 stack[-3] // @11CB address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length // } 1185 5B JUMPDEST 1186 50 POP 1187 50 POP 1188 60 PUSH1 0x40 118A 80 DUP1 118B 51 MLOAD 118C 63 PUSH4 0x3b4da69f 1191 60 PUSH1 0xe0 1193 1B SHL 1194 81 DUP2 1195 52 MSTORE 1196 30 ADDRESS 1197 60 PUSH1 0x04 1199 82 DUP3 119A 01 ADD 119B 52 MSTORE 119C 60 PUSH1 0x24 119E 81 DUP2 119F 01 ADD 11A0 8B DUP12 11A1 90 SWAP1 11A2 52 MSTORE 11A3 90 SWAP1 11A4 51 MLOAD 11A5 60 PUSH1 0x01 11A7 60 PUSH1 0x01 11A9 60 PUSH1 0xa0 11AB 1B SHL 11AC 03 SUB 11AD 86 DUP7 11AE 16 AND 11AF 93 SWAP4 11B0 50 POP 11B1 63 PUSH4 0x3b4da69f 11B6 92 SWAP3 11B7 50 POP 11B8 60 PUSH1 0x44 11BA 80 DUP1 11BB 83 DUP4 11BC 01 ADD 11BD 92 SWAP3 11BE 60 PUSH1 0x00 11C0 92 SWAP3 11C1 91 SWAP2 11C2 90 SWAP1 11C3 82 DUP3 11C4 90 SWAP1 11C5 03 SUB 11C6 01 ADD 11C7 81 DUP2 11C8 83 DUP4 11C9 87 DUP8 11CA 80 DUP1 11CB 3B EXTCODESIZE 11CC 15 ISZERO 11CD 80 DUP1 11CE 15 ISZERO 11CF 61 PUSH2 0x11d7 11D2 57 *JUMPI // Stack delta = +6 // Outputs[13] // { // @1195 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b4da69f << 0xe0 // @119B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @11A2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-11] // @11AF stack[-4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @11B6 stack[-3] = 0x3b4da69f // @11BD stack[-2] = memory[0x40:0x60] + 0x44 // @11C0 stack[-1] = 0x00 // @11C1 stack[0] = memory[0x40:0x60] // @11C6 stack[1] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @11C7 stack[2] = memory[0x40:0x60] // @11C8 stack[3] = 0x00 // @11C9 stack[4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @11CC stack[5] = !address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x11d7, if !!address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length label_11D3: // Incoming jump from 0x11D2, if not !!address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @11D6 memory[0x00:0x00] } 11D3 60 PUSH1 0x00 11D5 80 DUP1 11D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @11D6 revert(memory[0x00:0x00]); } // Block terminates label_11D7: // Incoming jump from 0x11D2, if !!address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @11D9 msg.gas // @11DA stack[-4] // @11DA stack[-3] // @11DA stack[-5] // @11DA stack[-2] // @11DA address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @11DA stack[-6] // @11DA stack[-7] // @11DA memory[stack[-4]:stack[-4] + stack[-5]] // } 11D7 5B JUMPDEST 11D8 50 POP 11D9 5A GAS 11DA F1 CALL 11DB 15 ISZERO 11DC 80 DUP1 11DD 15 ISZERO 11DE 61 PUSH2 0x11eb 11E1 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @11DA memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @11DB stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x11eb, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_11E2: // Incoming jump from 0x11E1, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @11E2 returndata.length // @11E6 returndata[0x00:0x00 + returndata.length] // @11E7 returndata.length // @11EA memory[0x00:0x00 + returndata.length] // } 11E2 3D RETURNDATASIZE 11E3 60 PUSH1 0x00 11E5 80 DUP1 11E6 3E RETURNDATACOPY 11E7 3D RETURNDATASIZE 11E8 60 PUSH1 0x00 11EA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @11E6 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @11EA revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_11EB: // Incoming jump from 0x11E1, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[5] // { // @11F3 memory[0x00:0x20] // @11FC memory[0x00:0x20] // @120F memory[0x40:0x60] // @1223 memory[0x40:0x60] // @122A address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 11EB 5B JUMPDEST 11EC 50 POP 11ED 50 POP 11EE 50 POP 11EF 50 POP 11F0 60 PUSH1 0x00 11F2 80 DUP1 11F3 51 MLOAD 11F4 60 PUSH1 0x20 11F6 61 PUSH2 0x4418 11F9 83 DUP4 11FA 39 CODECOPY 11FB 81 DUP2 11FC 51 MLOAD 11FD 91 SWAP2 11FE 52 MSTORE 11FF 60 PUSH1 0x01 1201 60 PUSH1 0x01 1203 60 PUSH1 0xa0 1205 1B SHL 1206 03 SUB 1207 16 AND 1208 63 PUSH4 0x36569e77 120D 60 PUSH1 0x40 120F 51 MLOAD 1210 81 DUP2 1211 63 PUSH4 0xffffffff 1216 16 AND 1217 60 PUSH1 0xe0 1219 1B SHL 121A 81 DUP2 121B 52 MSTORE 121C 60 PUSH1 0x04 121E 01 ADD 121F 60 PUSH1 0x20 1221 60 PUSH1 0x40 1223 51 MLOAD 1224 80 DUP1 1225 83 DUP4 1226 03 SUB 1227 81 DUP2 1228 86 DUP7 1229 80 DUP1 122A 3B EXTCODESIZE 122B 15 ISZERO 122C 80 DUP1 122D 15 ISZERO 122E 61 PUSH2 0x1236 1231 57 *JUMPI // Stack delta = +5 // Outputs[12] // { // @11FA memory[0x00:0x20] = code[0x4418:0x4438] // @11FE memory[0x00:0x20] = memory[0x00:0x20] // @1207 stack[-4] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @1208 stack[-3] = 0x36569e77 // @121B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @121E stack[-2] = 0x04 + memory[0x40:0x60] // @121F stack[-1] = 0x20 // @1223 stack[0] = memory[0x40:0x60] // @1226 stack[1] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1227 stack[2] = memory[0x40:0x60] // @1228 stack[3] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @122B stack[4] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x1236, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_1232: // Incoming jump from 0x1231, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @1235 memory[0x00:0x00] } 1232 60 PUSH1 0x00 1234 80 DUP1 1235 FD *REVERT // Stack delta = +0 // Outputs[1] { @1235 revert(memory[0x00:0x00]); } // Block terminates label_1236: // Incoming jump from 0x1231, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @1238 msg.gas // @1239 stack[-5] // @1239 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1239 memory[stack[-3]:stack[-3] + stack[-4]] // @1239 stack[-3] // @1239 stack[-4] // @1239 stack[-6] // @1239 stack[-2] // } 1236 5B JUMPDEST 1237 50 POP 1238 5A GAS 1239 FA STATICCALL 123A 15 ISZERO 123B 80 DUP1 123C 15 ISZERO 123D 61 PUSH2 0x124a 1240 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1239 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @123A stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x124a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1241: // Incoming jump from 0x1240, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1241 returndata.length // @1245 returndata[0x00:0x00 + returndata.length] // @1246 returndata.length // @1249 memory[0x00:0x00 + returndata.length] // } 1241 3D RETURNDATASIZE 1242 60 PUSH1 0x00 1244 80 DUP1 1245 3E RETURNDATACOPY 1246 3D RETURNDATASIZE 1247 60 PUSH1 0x00 1249 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1245 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1249 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_124A: // Incoming jump from 0x1240, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1251 memory[0x40:0x60] // @1252 returndata.length // } 124A 5B JUMPDEST 124B 50 POP 124C 50 POP 124D 50 POP 124E 50 POP 124F 60 PUSH1 0x40 1251 51 MLOAD 1252 3D RETURNDATASIZE 1253 60 PUSH1 0x20 1255 81 DUP2 1256 10 LT 1257 15 ISZERO 1258 61 PUSH2 0x1260 125B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1251 stack[-4] = memory[0x40:0x60] // @1252 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1260, if !(returndata.length < 0x20) label_125C: // Incoming jump from 0x125B, if not !(returndata.length < 0x20) // Inputs[1] { @125F memory[0x00:0x00] } 125C 60 PUSH1 0x00 125E 80 DUP1 125F FD *REVERT // Stack delta = +0 // Outputs[1] { @125F revert(memory[0x00:0x00]); } // Block terminates label_1260: // Incoming jump from 0x125B, if !(returndata.length < 0x20) // Inputs[11] // { // @1261 stack[-2] // @1262 stack[-1] // @1266 memory[stack[-2]:stack[-2] + 0x20] // @1280 stack[-7] // @1281 stack[-6] // @1282 address(this) // @1283 address(this) // @128A stack[-4] // @129B memory[0x40:0x60] // @12AF memory[0x40:0x60] // @12B8 address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length // } 1260 5B JUMPDEST 1261 81 DUP2 1262 01 ADD 1263 90 SWAP1 1264 80 DUP1 1265 80 DUP1 1266 51 MLOAD 1267 90 SWAP1 1268 60 PUSH1 0x20 126A 01 ADD 126B 90 SWAP1 126C 92 SWAP3 126D 91 SWAP2 126E 90 SWAP1 126F 50 POP 1270 50 POP 1271 50 POP 1272 60 PUSH1 0x01 1274 60 PUSH1 0x01 1276 60 PUSH1 0xa0 1278 1B SHL 1279 03 SUB 127A 16 AND 127B 63 PUSH4 0x76088703 1280 86 DUP7 1281 86 DUP7 1282 30 ADDRESS 1283 30 ADDRESS 1284 61 PUSH2 0x12fb 1287 61 PUSH2 0x12f6 128A 89 DUP10 128B 60 PUSH1 0x01 128D 60 PUSH1 0x01 128F 60 PUSH1 0xa0 1291 1B SHL 1292 03 SUB 1293 16 AND 1294 63 PUSH4 0xb3bcfa82 1299 60 PUSH1 0x40 129B 51 MLOAD 129C 81 DUP2 129D 63 PUSH4 0xffffffff 12A2 16 AND 12A3 60 PUSH1 0xe0 12A5 1B SHL 12A6 81 DUP2 12A7 52 MSTORE 12A8 60 PUSH1 0x04 12AA 01 ADD 12AB 60 PUSH1 0x20 12AD 60 PUSH1 0x40 12AF 51 MLOAD 12B0 80 DUP1 12B1 83 DUP4 12B2 03 SUB 12B3 81 DUP2 12B4 60 PUSH1 0x00 12B6 87 DUP8 12B7 80 DUP1 12B8 3B EXTCODESIZE 12B9 15 ISZERO 12BA 80 DUP1 12BB 15 ISZERO 12BC 61 PUSH2 0x12c4 12BF 57 *JUMPI // Stack delta = +16 // Outputs[19] // { // @127A stack[-2] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @127B stack[-1] = 0x76088703 // @1280 stack[0] = stack[-7] // @1281 stack[1] = stack[-6] // @1282 stack[2] = address(this) // @1283 stack[3] = address(this) // @1284 stack[4] = 0x12fb // @1287 stack[5] = 0x12f6 // @1293 stack[6] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1294 stack[7] = 0xb3bcfa82 // @12A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xb3bcfa82) << 0xe0 // @12AA stack[8] = 0x04 + memory[0x40:0x60] // @12AB stack[9] = 0x20 // @12AF stack[10] = memory[0x40:0x60] // @12B2 stack[11] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @12B3 stack[12] = memory[0x40:0x60] // @12B4 stack[13] = 0x00 // @12B6 stack[14] = (0x01 << 0xa0) - 0x01 & stack[-4] // @12B9 stack[15] = !address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length // } // Block ends with conditional jump to 0x12c4, if !!address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length label_12C0: // Incoming jump from 0x12BF, if not !!address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length // Inputs[1] { @12C3 memory[0x00:0x00] } 12C0 60 PUSH1 0x00 12C2 80 DUP1 12C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @12C3 revert(memory[0x00:0x00]); } // Block terminates label_12C4: // Incoming jump from 0x12BF, if !!address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length // Inputs[9] // { // @12C6 msg.gas // @12C7 stack[-3] // @12C7 stack[-6] // @12C7 stack[-7] // @12C7 memory[stack[-4]:stack[-4] + stack[-5]] // @12C7 stack[-4] // @12C7 stack[-2] // @12C7 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @12C7 stack[-5] // } 12C4 5B JUMPDEST 12C5 50 POP 12C6 5A GAS 12C7 F1 CALL 12C8 15 ISZERO 12C9 80 DUP1 12CA 15 ISZERO 12CB 61 PUSH2 0x12d8 12CE 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @12C7 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @12C8 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x12d8, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_12CF: // Incoming jump from 0x12CE, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @12CF returndata.length // @12D3 returndata[0x00:0x00 + returndata.length] // @12D4 returndata.length // @12D7 memory[0x00:0x00 + returndata.length] // } 12CF 3D RETURNDATASIZE 12D0 60 PUSH1 0x00 12D2 80 DUP1 12D3 3E RETURNDATACOPY 12D4 3D RETURNDATASIZE 12D5 60 PUSH1 0x00 12D7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @12D3 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @12D7 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_12D8: // Incoming jump from 0x12CE, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @12DF memory[0x40:0x60] // @12E0 returndata.length // } 12D8 5B JUMPDEST 12D9 50 POP 12DA 50 POP 12DB 50 POP 12DC 50 POP 12DD 60 PUSH1 0x40 12DF 51 MLOAD 12E0 3D RETURNDATASIZE 12E1 60 PUSH1 0x20 12E3 81 DUP2 12E4 10 LT 12E5 15 ISZERO 12E6 61 PUSH2 0x12ee 12E9 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @12DF stack[-4] = memory[0x40:0x60] // @12E0 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x12ee, if !(returndata.length < 0x20) label_12EA: // Incoming jump from 0x12E9, if not !(returndata.length < 0x20) // Inputs[1] { @12ED memory[0x00:0x00] } 12EA 60 PUSH1 0x00 12EC 80 DUP1 12ED FD *REVERT // Stack delta = +0 // Outputs[1] { @12ED revert(memory[0x00:0x00]); } // Block terminates label_12EE: // Incoming jump from 0x12E9, if !(returndata.length < 0x20) // Inputs[3] // { // @12F0 stack[-2] // @12F0 memory[stack[-2]:stack[-2] + 0x20] // @12F1 stack[-17] // } 12EE 5B JUMPDEST 12EF 50 POP 12F0 51 MLOAD 12F1 8F DUP16 12F2 61 PUSH2 0x3d50 12F5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @12F0 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @12F1 stack[-1] = stack[-17] // } // Block ends with unconditional jump to 0x3d50 12F6 5B JUMPDEST 12F7 61 PUSH2 0x3d62 12FA 56 *JUMP 12FB 5B JUMPDEST 12FC 60 PUSH1 0x00 12FE 60 PUSH1 0x40 1300 51 MLOAD 1301 87 DUP8 1302 63 PUSH4 0xffffffff 1307 16 AND 1308 60 PUSH1 0xe0 130A 1B SHL 130B 81 DUP2 130C 52 MSTORE 130D 60 PUSH1 0x04 130F 01 ADD 1310 80 DUP1 1311 87 DUP8 1312 81 DUP2 1313 52 MSTORE 1314 60 PUSH1 0x20 1316 01 ADD 1317 86 DUP7 1318 60 PUSH1 0x01 131A 60 PUSH1 0x01 131C 60 PUSH1 0xa0 131E 1B SHL 131F 03 SUB 1320 16 AND 1321 81 DUP2 1322 52 MSTORE 1323 60 PUSH1 0x20 1325 01 ADD 1326 85 DUP6 1327 60 PUSH1 0x01 1329 60 PUSH1 0x01 132B 60 PUSH1 0xa0 132D 1B SHL 132E 03 SUB 132F 16 AND 1330 81 DUP2 1331 52 MSTORE 1332 60 PUSH1 0x20 1334 01 ADD 1335 84 DUP5 1336 60 PUSH1 0x01 1338 60 PUSH1 0x01 133A 60 PUSH1 0xa0 133C 1B SHL 133D 03 SUB 133E 16 AND 133F 81 DUP2 1340 52 MSTORE 1341 60 PUSH1 0x20 1343 01 ADD 1344 83 DUP4 1345 81 DUP2 1346 52 MSTORE 1347 60 PUSH1 0x20 1349 01 ADD 134A 82 DUP3 134B 81 DUP2 134C 52 MSTORE 134D 60 PUSH1 0x20 134F 01 ADD 1350 96 SWAP7 1351 50 POP 1352 50 POP 1353 50 POP 1354 50 POP 1355 50 POP 1356 50 POP 1357 50 POP 1358 60 PUSH1 0x00 135A 60 PUSH1 0x40 135C 51 MLOAD 135D 80 DUP1 135E 83 DUP4 135F 03 SUB 1360 81 DUP2 1361 60 PUSH1 0x00 1363 87 DUP8 1364 80 DUP1 1365 3B EXTCODESIZE 1366 15 ISZERO 1367 80 DUP1 1368 15 ISZERO 1369 61 PUSH2 0x1371 136C 57 *JUMPI 136D 60 PUSH1 0x00 136F 80 DUP1 1370 FD *REVERT 1371 5B JUMPDEST 1372 50 POP 1373 5A GAS 1374 F1 CALL 1375 15 ISZERO 1376 80 DUP1 1377 15 ISZERO 1378 61 PUSH2 0x1385 137B 57 *JUMPI 137C 3D RETURNDATASIZE 137D 60 PUSH1 0x00 137F 80 DUP1 1380 3E RETURNDATACOPY 1381 3D RETURNDATASIZE 1382 60 PUSH1 0x00 1384 FD *REVERT 1385 5B JUMPDEST 1386 50 POP 1387 50 POP 1388 50 POP 1389 50 POP 138A 61 PUSH2 0x1393 138D 8A DUP11 138E 88 DUP9 138F 61 PUSH2 0x3b0e 1392 56 *JUMP 1393 5B JUMPDEST 1394 60 PUSH1 0x40 1396 51 MLOAD 1397 80 DUP1 1398 60 PUSH1 0x60 139A 01 ADD 139B 60 PUSH1 0x40 139D 52 MSTORE 139E 80 DUP1 139F 60 PUSH1 0x33 13A1 81 DUP2 13A2 52 MSTORE 13A3 60 PUSH1 0x20 13A5 01 ADD 13A6 61 PUSH2 0x4438 13A9 60 PUSH1 0x33 13AB 91 SWAP2 13AC 39 CODECOPY 13AD 60 PUSH1 0x40 13AF 80 DUP1 13B0 51 MLOAD 13B1 60 PUSH1 0x20 13B3 81 DUP2 13B4 01 ADD 13B5 98 SWAP9 13B6 90 SWAP1 13B7 98 SWAP9 13B8 52 MSTORE 13B9 87 DUP8 13BA 81 DUP2 13BB 01 ADD 13BC 96 SWAP7 13BD 90 SWAP1 13BE 96 SWAP7 13BF 52 MSTORE 13C0 60 PUSH1 0x60 13C2 87 DUP8 13C3 01 ADD 13C4 97 SWAP8 13C5 90 SWAP1 13C6 97 SWAP8 13C7 52 MSTORE 13C8 50 POP 13C9 50 POP 13CA 50 POP 13CB 50 POP 13CC 60 PUSH1 0x80 13CE 82 DUP3 13CF 01 ADD 13D0 96 SWAP7 13D1 90 SWAP1 13D2 96 SWAP7 13D3 52 MSTORE 13D4 60 PUSH1 0xa0 13D6 80 DUP1 13D7 82 DUP3 13D8 01 ADD 13D9 95 SWAP6 13DA 90 SWAP1 13DB 95 SWAP6 13DC 52 MSTORE 13DD 85 DUP6 13DE 51 MLOAD 13DF 80 DUP1 13E0 82 DUP3 13E1 03 SUB 13E2 90 SWAP1 13E3 95 SWAP6 13E4 01 ADD 13E5 85 DUP6 13E6 52 MSTORE 13E7 60 PUSH1 0xc0 13E9 01 ADD 13EA 90 SWAP1 13EB 94 SWAP5 13EC 52 MSTORE 13ED 50 POP 13EE 91 SWAP2 13EF 94 SWAP5 13F0 90 SWAP1 13F1 93 SWAP4 13F2 50 POP 13F3 91 SWAP2 13F4 50 POP 13F5 50 POP 13F6 56 *JUMP label_13F7: // Incoming jump from 0x0301 // Inputs[2] // { // @1400 stack[-2] // @1401 stack[-3] // } 13F7 5B JUMPDEST 13F8 60 PUSH1 0x60 13FA 80 DUP1 13FB 60 PUSH1 0x00 13FD 61 PUSH2 0x1406 1400 85 DUP6 1401 87 DUP8 1402 61 PUSH2 0x3a55 1405 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @13F8 stack[0] = 0x60 // @13FA stack[1] = 0x60 // @13FB stack[2] = 0x00 // @13FD stack[3] = 0x1406 // @1400 stack[4] = stack[-2] // @1401 stack[5] = stack[-3] // } // Block ends with call to 0x3a55, returns to 0x1406 label_1406: // Incoming return from call to 0x3A55 at 0x1405 // Inputs[2] // { // @1407 stack[-1] // @1407 stack[-2] // } 1406 5B JUMPDEST 1407 90 SWAP1 1408 50 POP 1409 60 PUSH1 0x00 140B 19 NOT 140C 81 DUP2 140D 14 EQ 140E 61 PUSH2 0x1417 1411 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1407 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1417, if stack[-1] == ~0x00 label_1412: // Incoming jump from 0x1411, if not stack[-1] == ~0x00 // Inputs[1] { @1412 stack[-1] } 1412 80 DUP1 1413 61 PUSH2 0x1501 1416 56 *JUMP // Stack delta = +1 // Outputs[1] { @1412 stack[0] = stack[-1] } // Block ends with unconditional jump to 0x1501 label_1417: // Incoming jump from 0x1411, if stack[-1] == ~0x00 // Inputs[5] // { // @141B memory[0x00:0x20] // @1424 memory[0x00:0x20] // @1437 memory[0x40:0x60] // @144B memory[0x40:0x60] // @1454 address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 1417 5B JUMPDEST 1418 60 PUSH1 0x00 141A 80 DUP1 141B 51 MLOAD 141C 60 PUSH1 0x20 141E 61 PUSH2 0x4293 1421 83 DUP4 1422 39 CODECOPY 1423 81 DUP2 1424 51 MLOAD 1425 91 SWAP2 1426 52 MSTORE 1427 60 PUSH1 0x01 1429 60 PUSH1 0x01 142B 60 PUSH1 0xa0 142D 1B SHL 142E 03 SUB 142F 16 AND 1430 63 PUSH4 0xf4b9fa75 1435 60 PUSH1 0x40 1437 51 MLOAD 1438 81 DUP2 1439 63 PUSH4 0xffffffff 143E 16 AND 143F 60 PUSH1 0xe0 1441 1B SHL 1442 81 DUP2 1443 52 MSTORE 1444 60 PUSH1 0x04 1446 01 ADD 1447 60 PUSH1 0x20 1449 60 PUSH1 0x40 144B 51 MLOAD 144C 80 DUP1 144D 83 DUP4 144E 03 SUB 144F 81 DUP2 1450 60 PUSH1 0x00 1452 87 DUP8 1453 80 DUP1 1454 3B EXTCODESIZE 1455 15 ISZERO 1456 80 DUP1 1457 15 ISZERO 1458 61 PUSH2 0x1460 145B 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @1422 memory[0x00:0x20] = code[0x4293:0x42b3] // @1426 memory[0x00:0x20] = memory[0x00:0x20] // @142F stack[0] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @1430 stack[1] = 0xf4b9fa75 // @1443 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xf4b9fa75) << 0xe0 // @1446 stack[2] = 0x04 + memory[0x40:0x60] // @1447 stack[3] = 0x20 // @144B stack[4] = memory[0x40:0x60] // @144E stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @144F stack[6] = memory[0x40:0x60] // @1450 stack[7] = 0x00 // @1452 stack[8] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @1455 stack[9] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x1460, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_145C: // Incoming jump from 0x145B, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @145F memory[0x00:0x00] } 145C 60 PUSH1 0x00 145E 80 DUP1 145F FD *REVERT // Stack delta = +0 // Outputs[1] { @145F revert(memory[0x00:0x00]); } // Block terminates label_1460: // Incoming jump from 0x145B, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[9] // { // @1462 msg.gas // @1463 stack[-3] // @1463 stack[-6] // @1463 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1463 stack[-4] // @1463 stack[-2] // @1463 memory[stack[-4]:stack[-4] + stack[-5]] // @1463 stack[-7] // @1463 stack[-5] // } 1460 5B JUMPDEST 1461 50 POP 1462 5A GAS 1463 F1 CALL 1464 15 ISZERO 1465 80 DUP1 1466 15 ISZERO 1467 61 PUSH2 0x1474 146A 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1463 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1464 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1474, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_146B: // Incoming jump from 0x146A, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @146B returndata.length // @146F returndata[0x00:0x00 + returndata.length] // @1470 returndata.length // @1473 memory[0x00:0x00 + returndata.length] // } 146B 3D RETURNDATASIZE 146C 60 PUSH1 0x00 146E 80 DUP1 146F 3E RETURNDATACOPY 1470 3D RETURNDATASIZE 1471 60 PUSH1 0x00 1473 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @146F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1473 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1474: // Incoming jump from 0x146A, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @147B memory[0x40:0x60] // @147C returndata.length // } 1474 5B JUMPDEST 1475 50 POP 1476 50 POP 1477 50 POP 1478 50 POP 1479 60 PUSH1 0x40 147B 51 MLOAD 147C 3D RETURNDATASIZE 147D 60 PUSH1 0x20 147F 81 DUP2 1480 10 LT 1481 15 ISZERO 1482 61 PUSH2 0x148a 1485 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @147B stack[-4] = memory[0x40:0x60] // @147C stack[-3] = returndata.length // } // Block ends with conditional jump to 0x148a, if !(returndata.length < 0x20) label_1486: // Incoming jump from 0x1485, if not !(returndata.length < 0x20) // Inputs[1] { @1489 memory[0x00:0x00] } 1486 60 PUSH1 0x00 1488 80 DUP1 1489 FD *REVERT // Stack delta = +0 // Outputs[1] { @1489 revert(memory[0x00:0x00]); } // Block terminates label_148A: // Incoming jump from 0x1485, if !(returndata.length < 0x20) // Inputs[6] // { // @148C stack[-2] // @148C memory[stack[-2]:stack[-2] + 0x20] // @1490 memory[0x40:0x60] // @149B address(this) // @14A2 memory[0x40:0x60] // @14C8 address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } 148A 5B JUMPDEST 148B 50 POP 148C 51 MLOAD 148D 60 PUSH1 0x40 148F 80 DUP1 1490 51 MLOAD 1491 63 PUSH4 0x70a08231 1496 60 PUSH1 0xe0 1498 1B SHL 1499 81 DUP2 149A 52 MSTORE 149B 30 ADDRESS 149C 60 PUSH1 0x04 149E 82 DUP3 149F 01 ADD 14A0 52 MSTORE 14A1 90 SWAP1 14A2 51 MLOAD 14A3 60 PUSH1 0x01 14A5 60 PUSH1 0x01 14A7 60 PUSH1 0xa0 14A9 1B SHL 14AA 03 SUB 14AB 90 SWAP1 14AC 92 SWAP3 14AD 16 AND 14AE 91 SWAP2 14AF 63 PUSH4 0x70a08231 14B4 91 SWAP2 14B5 60 PUSH1 0x24 14B7 80 DUP1 14B8 82 DUP3 14B9 01 ADD 14BA 92 SWAP3 14BB 60 PUSH1 0x20 14BD 92 SWAP3 14BE 90 SWAP1 14BF 91 SWAP2 14C0 90 SWAP1 14C1 82 DUP3 14C2 90 SWAP1 14C3 03 SUB 14C4 01 ADD 14C5 81 DUP2 14C6 86 DUP7 14C7 80 DUP1 14C8 3B EXTCODESIZE 14C9 15 ISZERO 14CA 80 DUP1 14CB 15 ISZERO 14CC 61 PUSH2 0x14d4 14CF 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @149A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @14A0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @14AE stack[-2] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @14B4 stack[-1] = 0x70a08231 // @14BA stack[0] = memory[0x40:0x60] + 0x24 // @14BD stack[1] = 0x20 // @14BF stack[2] = memory[0x40:0x60] // @14C4 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @14C5 stack[4] = memory[0x40:0x60] // @14C6 stack[5] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @14C9 stack[6] = !address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x14d4, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length label_14D0: // Incoming jump from 0x14CF, if not !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @14D3 memory[0x00:0x00] } 14D0 60 PUSH1 0x00 14D2 80 DUP1 14D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @14D3 revert(memory[0x00:0x00]); } // Block terminates label_14D4: // Incoming jump from 0x14CF, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @14D6 msg.gas // @14D7 stack[-3] // @14D7 stack[-4] // @14D7 memory[stack[-3]:stack[-3] + stack[-4]] // @14D7 stack[-2] // @14D7 stack[-5] // @14D7 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14D7 stack[-6] // } 14D4 5B JUMPDEST 14D5 50 POP 14D6 5A GAS 14D7 FA STATICCALL 14D8 15 ISZERO 14D9 80 DUP1 14DA 15 ISZERO 14DB 61 PUSH2 0x14e8 14DE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @14D7 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14D8 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x14e8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_14DF: // Incoming jump from 0x14DE, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @14DF returndata.length // @14E3 returndata[0x00:0x00 + returndata.length] // @14E4 returndata.length // @14E7 memory[0x00:0x00 + returndata.length] // } 14DF 3D RETURNDATASIZE 14E0 60 PUSH1 0x00 14E2 80 DUP1 14E3 3E RETURNDATACOPY 14E4 3D RETURNDATASIZE 14E5 60 PUSH1 0x00 14E7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @14E3 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @14E7 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_14E8: // Incoming jump from 0x14DE, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @14EF memory[0x40:0x60] // @14F0 returndata.length // } 14E8 5B JUMPDEST 14E9 50 POP 14EA 50 POP 14EB 50 POP 14EC 50 POP 14ED 60 PUSH1 0x40 14EF 51 MLOAD 14F0 3D RETURNDATASIZE 14F1 60 PUSH1 0x20 14F3 81 DUP2 14F4 10 LT 14F5 15 ISZERO 14F6 61 PUSH2 0x14fe 14F9 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @14EF stack[-4] = memory[0x40:0x60] // @14F0 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x14fe, if !(returndata.length < 0x20) label_14FA: // Incoming jump from 0x14F9, if not !(returndata.length < 0x20) // Inputs[1] { @14FD memory[0x00:0x00] } 14FA 60 PUSH1 0x00 14FC 80 DUP1 14FD FD *REVERT // Stack delta = +0 // Outputs[1] { @14FD revert(memory[0x00:0x00]); } // Block terminates label_14FE: // Incoming jump from 0x14F9, if !(returndata.length < 0x20) // Inputs[2] // { // @1500 stack[-2] // @1500 memory[stack[-2]:stack[-2] + 0x20] // } 14FE 5B JUMPDEST 14FF 50 POP 1500 51 MLOAD // Stack delta = -1 // Outputs[1] { @1500 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_1501: // Incoming jump from 0x1416 // Incoming jump from 0x1500 // Inputs[7] // { // @1502 stack[-1] // @1502 stack[-2] // @1509 memory[0x00:0x20] // @1512 memory[0x00:0x20] // @1525 memory[0x40:0x60] // @1539 memory[0x40:0x60] // @1542 address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 1501 5B JUMPDEST 1502 90 SWAP1 1503 50 POP 1504 60 PUSH1 0x00 1506 60 PUSH1 0x00 1508 80 DUP1 1509 51 MLOAD 150A 60 PUSH1 0x20 150C 61 PUSH2 0x4293 150F 83 DUP4 1510 39 CODECOPY 1511 81 DUP2 1512 51 MLOAD 1513 91 SWAP2 1514 52 MSTORE 1515 60 PUSH1 0x01 1517 60 PUSH1 0x01 1519 60 PUSH1 0xa0 151B 1B SHL 151C 03 SUB 151D 16 AND 151E 63 PUSH4 0x36569e77 1523 60 PUSH1 0x40 1525 51 MLOAD 1526 81 DUP2 1527 63 PUSH4 0xffffffff 152C 16 AND 152D 60 PUSH1 0xe0 152F 1B SHL 1530 81 DUP2 1531 52 MSTORE 1532 60 PUSH1 0x04 1534 01 ADD 1535 60 PUSH1 0x20 1537 60 PUSH1 0x40 1539 51 MLOAD 153A 80 DUP1 153B 83 DUP4 153C 03 SUB 153D 81 DUP2 153E 60 PUSH1 0x00 1540 87 DUP8 1541 80 DUP1 1542 3B EXTCODESIZE 1543 15 ISZERO 1544 80 DUP1 1545 15 ISZERO 1546 61 PUSH2 0x154e 1549 57 *JUMPI // Stack delta = +10 // Outputs[15] // { // @1502 stack[-2] = stack[-1] // @1504 stack[-1] = 0x00 // @1510 memory[0x00:0x20] = code[0x4293:0x42b3] // @1514 memory[0x00:0x20] = memory[0x00:0x20] // @151D stack[0] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @151E stack[1] = 0x36569e77 // @1531 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @1534 stack[2] = 0x04 + memory[0x40:0x60] // @1535 stack[3] = 0x20 // @1539 stack[4] = memory[0x40:0x60] // @153C stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @153D stack[6] = memory[0x40:0x60] // @153E stack[7] = 0x00 // @1540 stack[8] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @1543 stack[9] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x154e, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_154A: // Incoming jump from 0x1549, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @154D memory[0x00:0x00] } 154A 60 PUSH1 0x00 154C 80 DUP1 154D FD *REVERT // Stack delta = +0 // Outputs[1] { @154D revert(memory[0x00:0x00]); } // Block terminates label_154E: // Incoming jump from 0x1549, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[9] // { // @1550 msg.gas // @1551 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1551 stack[-5] // @1551 stack[-4] // @1551 memory[stack[-4]:stack[-4] + stack[-5]] // @1551 stack[-7] // @1551 stack[-3] // @1551 stack[-2] // @1551 stack[-6] // } 154E 5B JUMPDEST 154F 50 POP 1550 5A GAS 1551 F1 CALL 1552 15 ISZERO 1553 80 DUP1 1554 15 ISZERO 1555 61 PUSH2 0x1562 1558 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1551 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1552 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1562, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1559: // Incoming jump from 0x1558, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1559 returndata.length // @155D returndata[0x00:0x00 + returndata.length] // @155E returndata.length // @1561 memory[0x00:0x00 + returndata.length] // } 1559 3D RETURNDATASIZE 155A 60 PUSH1 0x00 155C 80 DUP1 155D 3E RETURNDATACOPY 155E 3D RETURNDATASIZE 155F 60 PUSH1 0x00 1561 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @155D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1561 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1562: // Incoming jump from 0x1558, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1569 memory[0x40:0x60] // @156A returndata.length // } 1562 5B JUMPDEST 1563 50 POP 1564 50 POP 1565 50 POP 1566 50 POP 1567 60 PUSH1 0x40 1569 51 MLOAD 156A 3D RETURNDATASIZE 156B 60 PUSH1 0x20 156D 81 DUP2 156E 10 LT 156F 15 ISZERO 1570 61 PUSH2 0x1578 1573 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1569 stack[-4] = memory[0x40:0x60] // @156A stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1578, if !(returndata.length < 0x20) label_1574: // Incoming jump from 0x1573, if not !(returndata.length < 0x20) // Inputs[1] { @1577 memory[0x00:0x00] } 1574 60 PUSH1 0x00 1576 80 DUP1 1577 FD *REVERT // Stack delta = +0 // Outputs[1] { @1577 revert(memory[0x00:0x00]); } // Block terminates label_1578: // Incoming jump from 0x1573, if !(returndata.length < 0x20) // Inputs[6] // { // @157A memory[stack[-2]:stack[-2] + 0x20] // @157A stack[-2] // @157E memory[0x40:0x60] // @158A memory[0x40:0x60] // @158C stack[-3] // @15C0 address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // } 1578 5B JUMPDEST 1579 50 POP 157A 51 MLOAD 157B 60 PUSH1 0x40 157D 80 DUP1 157E 51 MLOAD 157F 63 PUSH4 0x4fb3c665 1584 60 PUSH1 0xe1 1586 1B SHL 1587 81 DUP2 1588 52 MSTORE 1589 90 SWAP1 158A 51 MLOAD 158B 91 SWAP2 158C 92 SWAP3 158D 50 POP 158E 60 PUSH1 0x00 1590 91 SWAP2 1591 73 PUSH20 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 15A6 91 SWAP2 15A7 63 PUSH4 0x9f678cca 15AC 91 SWAP2 15AD 60 PUSH1 0x04 15AF 80 DUP1 15B0 83 DUP4 15B1 01 ADD 15B2 92 SWAP3 15B3 60 PUSH1 0x20 15B5 92 SWAP3 15B6 91 SWAP2 15B7 90 SWAP1 15B8 82 DUP3 15B9 90 SWAP1 15BA 03 SUB 15BB 01 ADD 15BC 81 DUP2 15BD 87 DUP8 15BE 87 DUP8 15BF 80 DUP1 15C0 3B EXTCODESIZE 15C1 15 ISZERO 15C2 80 DUP1 15C3 15 ISZERO 15C4 61 PUSH2 0x15cc 15C7 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @1588 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4fb3c665 << 0xe1 // @158C stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @1590 stack[-2] = 0x00 // @15A6 stack[-1] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @15AC stack[0] = 0x9f678cca // @15B2 stack[1] = memory[0x40:0x60] + 0x04 // @15B5 stack[2] = 0x20 // @15B6 stack[3] = memory[0x40:0x60] // @15BB stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @15BC stack[5] = memory[0x40:0x60] // @15BD stack[6] = 0x00 // @15BE stack[7] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @15C1 stack[8] = !address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // } // Block ends with conditional jump to 0x15cc, if !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length label_15C8: // Incoming jump from 0x15C7, if not !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // Inputs[1] { @15CB memory[0x00:0x00] } 15C8 60 PUSH1 0x00 15CA 80 DUP1 15CB FD *REVERT // Stack delta = +0 // Outputs[1] { @15CB revert(memory[0x00:0x00]); } // Block terminates label_15CC: // Incoming jump from 0x15C7, if !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // Inputs[9] // { // @15CE msg.gas // @15CF stack[-2] // @15CF stack[-3] // @15CF stack[-5] // @15CF address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @15CF memory[stack[-4]:stack[-4] + stack[-5]] // @15CF stack[-4] // @15CF stack[-6] // @15CF stack[-7] // } 15CC 5B JUMPDEST 15CD 50 POP 15CE 5A GAS 15CF F1 CALL 15D0 15 ISZERO 15D1 80 DUP1 15D2 15 ISZERO 15D3 61 PUSH2 0x15e0 15D6 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @15CF memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @15D0 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x15e0, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_15D7: // Incoming jump from 0x15D6, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @15D7 returndata.length // @15DB returndata[0x00:0x00 + returndata.length] // @15DC returndata.length // @15DF memory[0x00:0x00 + returndata.length] // } 15D7 3D RETURNDATASIZE 15D8 60 PUSH1 0x00 15DA 80 DUP1 15DB 3E RETURNDATACOPY 15DC 3D RETURNDATASIZE 15DD 60 PUSH1 0x00 15DF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @15DB memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @15DF revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_15E0: // Incoming jump from 0x15D6, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @15E7 memory[0x40:0x60] // @15E8 returndata.length // } 15E0 5B JUMPDEST 15E1 50 POP 15E2 50 POP 15E3 50 POP 15E4 50 POP 15E5 60 PUSH1 0x40 15E7 51 MLOAD 15E8 3D RETURNDATASIZE 15E9 60 PUSH1 0x20 15EB 81 DUP2 15EC 10 LT 15ED 15 ISZERO 15EE 61 PUSH2 0x15f6 15F1 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @15E7 stack[-4] = memory[0x40:0x60] // @15E8 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x15f6, if !(returndata.length < 0x20) label_15F2: // Incoming jump from 0x15F1, if not !(returndata.length < 0x20) // Inputs[1] { @15F5 memory[0x00:0x00] } 15F2 60 PUSH1 0x00 15F4 80 DUP1 15F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @15F5 revert(memory[0x00:0x00]); } // Block terminates label_15F6: // Incoming jump from 0x15F1, if !(returndata.length < 0x20) // Inputs[8] // { // @15F8 stack[-2] // @15F8 memory[stack[-2]:stack[-2] + 0x20] // @15FC memory[0x40:0x60] // @1608 memory[0x40:0x60] // @160A stack[-3] // @160F memory[0x00:0x20] // @1618 memory[0x00:0x20] // @1637 address(memory[0x00:0x20]).code.length // } 15F6 5B JUMPDEST 15F7 50 POP 15F8 51 MLOAD 15F9 60 PUSH1 0x40 15FB 80 DUP1 15FC 51 MLOAD 15FD 63 PUSH4 0xf4b9fa75 1602 60 PUSH1 0xe0 1604 1B SHL 1605 81 DUP2 1606 52 MSTORE 1607 90 SWAP1 1608 51 MLOAD 1609 91 SWAP2 160A 92 SWAP3 160B 50 POP 160C 60 PUSH1 0x00 160E 80 DUP1 160F 51 MLOAD 1610 60 PUSH1 0x20 1612 61 PUSH2 0x4293 1615 83 DUP4 1616 39 CODECOPY 1617 81 DUP2 1618 51 MLOAD 1619 91 SWAP2 161A 52 MSTORE 161B 91 SWAP2 161C 63 PUSH4 0xf4b9fa75 1621 91 SWAP2 1622 60 PUSH1 0x04 1624 80 DUP1 1625 82 DUP3 1626 01 ADD 1627 92 SWAP3 1628 60 PUSH1 0x20 162A 92 SWAP3 162B 90 SWAP1 162C 91 SWAP2 162D 90 SWAP1 162E 82 DUP3 162F 90 SWAP1 1630 03 SUB 1631 01 ADD 1632 81 DUP2 1633 60 PUSH1 0x00 1635 87 DUP8 1636 80 DUP1 1637 3B EXTCODESIZE 1638 15 ISZERO 1639 80 DUP1 163A 15 ISZERO 163B 61 PUSH2 0x1643 163E 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @1606 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf4b9fa75 << 0xe0 // @160A stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @1616 memory[0x00:0x20] = code[0x4293:0x42b3] // @161A memory[0x00:0x20] = memory[0x00:0x20] // @161B stack[-2] = memory[0x00:0x20] // @1621 stack[-1] = 0xf4b9fa75 // @1627 stack[0] = memory[0x40:0x60] + 0x04 // @162A stack[1] = 0x20 // @162C stack[2] = memory[0x40:0x60] // @1631 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @1632 stack[4] = memory[0x40:0x60] // @1633 stack[5] = 0x00 // @1635 stack[6] = memory[0x00:0x20] // @1638 stack[7] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x1643, if !!address(memory[0x00:0x20]).code.length label_163F: // Incoming jump from 0x163E, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @1642 memory[0x00:0x00] } 163F 60 PUSH1 0x00 1641 80 DUP1 1642 FD *REVERT // Stack delta = +0 // Outputs[1] { @1642 revert(memory[0x00:0x00]); } // Block terminates label_1643: // Incoming jump from 0x163E, if !!address(memory[0x00:0x20]).code.length // Inputs[9] // { // @1645 msg.gas // @1646 stack[-3] // @1646 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1646 stack[-2] // @1646 stack[-5] // @1646 stack[-4] // @1646 stack[-6] // @1646 memory[stack[-4]:stack[-4] + stack[-5]] // @1646 stack[-7] // } 1643 5B JUMPDEST 1644 50 POP 1645 5A GAS 1646 F1 CALL 1647 15 ISZERO 1648 80 DUP1 1649 15 ISZERO 164A 61 PUSH2 0x1657 164D 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1646 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1647 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1657, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_164E: // Incoming jump from 0x164D, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @164E returndata.length // @1652 returndata[0x00:0x00 + returndata.length] // @1653 returndata.length // @1656 memory[0x00:0x00 + returndata.length] // } 164E 3D RETURNDATASIZE 164F 60 PUSH1 0x00 1651 80 DUP1 1652 3E RETURNDATACOPY 1653 3D RETURNDATASIZE 1654 60 PUSH1 0x00 1656 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1652 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1656 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1657: // Incoming jump from 0x164D, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @165E memory[0x40:0x60] // @165F returndata.length // } 1657 5B JUMPDEST 1658 50 POP 1659 50 POP 165A 50 POP 165B 50 POP 165C 60 PUSH1 0x40 165E 51 MLOAD 165F 3D RETURNDATASIZE 1660 60 PUSH1 0x20 1662 81 DUP2 1663 10 LT 1664 15 ISZERO 1665 61 PUSH2 0x166d 1668 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @165E stack[-4] = memory[0x40:0x60] // @165F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x166d, if !(returndata.length < 0x20) label_1669: // Incoming jump from 0x1668, if not !(returndata.length < 0x20) // Inputs[1] { @166C memory[0x00:0x00] } 1669 60 PUSH1 0x00 166B 80 DUP1 166C FD *REVERT // Stack delta = +0 // Outputs[1] { @166C revert(memory[0x00:0x00]); } // Block terminates label_166D: // Incoming jump from 0x1668, if !(returndata.length < 0x20) // Inputs[8] // { // @166F memory[stack[-2]:stack[-2] + 0x20] // @166F stack[-2] // @1673 memory[0x40:0x60] // @1681 memory[0x00:0x20] // @168A memory[0x00:0x20] // @1696 stack[-5] // @169A memory[0x40:0x60] // @16C1 address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } 166D 5B JUMPDEST 166E 50 POP 166F 51 MLOAD 1670 60 PUSH1 0x40 1672 80 DUP1 1673 51 MLOAD 1674 63 PUSH4 0x095ea7b3 1679 60 PUSH1 0xe0 167B 1B SHL 167C 81 DUP2 167D 52 MSTORE 167E 60 PUSH1 0x00 1680 80 DUP1 1681 51 MLOAD 1682 60 PUSH1 0x20 1684 61 PUSH2 0x4293 1687 83 DUP4 1688 39 CODECOPY 1689 81 DUP2 168A 51 MLOAD 168B 91 SWAP2 168C 52 MSTORE 168D 60 PUSH1 0x04 168F 82 DUP3 1690 01 ADD 1691 52 MSTORE 1692 60 PUSH1 0x24 1694 81 DUP2 1695 01 ADD 1696 86 DUP7 1697 90 SWAP1 1698 52 MSTORE 1699 90 SWAP1 169A 51 MLOAD 169B 60 PUSH1 0x01 169D 60 PUSH1 0x01 169F 60 PUSH1 0xa0 16A1 1B SHL 16A2 03 SUB 16A3 90 SWAP1 16A4 92 SWAP3 16A5 16 AND 16A6 91 SWAP2 16A7 63 PUSH4 0x095ea7b3 16AC 91 SWAP2 16AD 60 PUSH1 0x44 16AF 80 DUP1 16B0 82 DUP3 16B1 01 ADD 16B2 92 SWAP3 16B3 60 PUSH1 0x00 16B5 92 SWAP3 16B6 90 SWAP1 16B7 91 SWAP2 16B8 90 SWAP1 16B9 82 DUP3 16BA 90 SWAP1 16BB 03 SUB 16BC 01 ADD 16BD 81 DUP2 16BE 83 DUP4 16BF 87 DUP8 16C0 80 DUP1 16C1 3B EXTCODESIZE 16C2 15 ISZERO 16C3 80 DUP1 16C4 15 ISZERO 16C5 61 PUSH2 0x16cd 16C8 57 *JUMPI // Stack delta = +8 // Outputs[15] // { // @167D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x095ea7b3 << 0xe0 // @1688 memory[0x00:0x20] = code[0x4293:0x42b3] // @168C memory[0x00:0x20] = memory[0x00:0x20] // @1691 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = memory[0x00:0x20] // @1698 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-5] // @16A6 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @16AC stack[-1] = 0x095ea7b3 // @16B2 stack[0] = memory[0x40:0x60] + 0x44 // @16B5 stack[1] = 0x00 // @16B7 stack[2] = memory[0x40:0x60] // @16BC stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @16BD stack[4] = memory[0x40:0x60] // @16BE stack[5] = 0x00 // @16BF stack[6] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @16C2 stack[7] = !address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x16cd, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length label_16C9: // Incoming jump from 0x16C8, if not !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @16CC memory[0x00:0x00] } 16C9 60 PUSH1 0x00 16CB 80 DUP1 16CC FD *REVERT // Stack delta = +0 // Outputs[1] { @16CC revert(memory[0x00:0x00]); } // Block terminates label_16CD: // Incoming jump from 0x16C8, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @16CF msg.gas // @16D0 memory[stack[-4]:stack[-4] + stack[-5]] // @16D0 stack[-6] // @16D0 stack[-3] // @16D0 stack[-2] // @16D0 stack[-4] // @16D0 stack[-5] // @16D0 stack[-7] // @16D0 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 16CD 5B JUMPDEST 16CE 50 POP 16CF 5A GAS 16D0 F1 CALL 16D1 15 ISZERO 16D2 80 DUP1 16D3 15 ISZERO 16D4 61 PUSH2 0x16e1 16D7 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @16D0 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @16D1 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x16e1, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_16D8: // Incoming jump from 0x16D7, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @16D8 returndata.length // @16DC returndata[0x00:0x00 + returndata.length] // @16DD returndata.length // @16E0 memory[0x00:0x00 + returndata.length] // } 16D8 3D RETURNDATASIZE 16D9 60 PUSH1 0x00 16DB 80 DUP1 16DC 3E RETURNDATACOPY 16DD 3D RETURNDATASIZE 16DE 60 PUSH1 0x00 16E0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16DC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @16E0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_16E1: // Incoming jump from 0x16D7, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[9] // { // @16E7 memory[0x40:0x60] // @16F2 address(this) // @16FC stack[-7] // @1700 memory[0x40:0x60] // @1704 memory[0x00:0x20] // @170D memory[0x00:0x20] // @1710 stack[-4] // @1717 stack[-3] // @172C address(memory[0x00:0x20]).code.length // } 16E1 5B JUMPDEST 16E2 50 POP 16E3 50 POP 16E4 60 PUSH1 0x40 16E6 80 DUP1 16E7 51 MLOAD 16E8 63 PUSH4 0x3b4da69f 16ED 60 PUSH1 0xe0 16EF 1B SHL 16F0 81 DUP2 16F1 52 MSTORE 16F2 30 ADDRESS 16F3 60 PUSH1 0x04 16F5 82 DUP3 16F6 01 ADD 16F7 52 MSTORE 16F8 60 PUSH1 0x24 16FA 81 DUP2 16FB 01 ADD 16FC 87 DUP8 16FD 90 SWAP1 16FE 52 MSTORE 16FF 90 SWAP1 1700 51 MLOAD 1701 60 PUSH1 0x00 1703 80 DUP1 1704 51 MLOAD 1705 60 PUSH1 0x20 1707 61 PUSH2 0x4293 170A 83 DUP4 170B 39 CODECOPY 170C 81 DUP2 170D 51 MLOAD 170E 91 SWAP2 170F 52 MSTORE 1710 93 SWAP4 1711 50 POP 1712 63 PUSH4 0x3b4da69f 1717 92 SWAP3 1718 50 POP 1719 60 PUSH1 0x44 171B 80 DUP1 171C 83 DUP4 171D 01 ADD 171E 92 SWAP3 171F 60 PUSH1 0x00 1721 92 SWAP3 1722 91 SWAP2 1723 90 SWAP1 1724 82 DUP3 1725 90 SWAP1 1726 03 SUB 1727 01 ADD 1728 81 DUP2 1729 83 DUP4 172A 87 DUP8 172B 80 DUP1 172C 3B EXTCODESIZE 172D 15 ISZERO 172E 80 DUP1 172F 15 ISZERO 1730 61 PUSH2 0x1738 1733 57 *JUMPI // Stack delta = +6 // Outputs[15] // { // @16F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b4da69f << 0xe0 // @16F7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @16FE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-7] // @170B memory[0x00:0x20] = code[0x4293:0x42b3] // @170F memory[0x00:0x20] = memory[0x00:0x20] // @1710 stack[-4] = memory[0x00:0x20] // @1717 stack[-3] = 0x3b4da69f // @171E stack[-2] = memory[0x40:0x60] + 0x44 // @1721 stack[-1] = 0x00 // @1722 stack[0] = memory[0x40:0x60] // @1727 stack[1] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @1728 stack[2] = memory[0x40:0x60] // @1729 stack[3] = 0x00 // @172A stack[4] = memory[0x00:0x20] // @172D stack[5] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x1738, if !!address(memory[0x00:0x20]).code.length label_1734: // Incoming jump from 0x1733, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @1737 memory[0x00:0x00] } 1734 60 PUSH1 0x00 1736 80 DUP1 1737 FD *REVERT // Stack delta = +0 // Outputs[1] { @1737 revert(memory[0x00:0x00]); } // Block terminates label_1738: // Incoming jump from 0x1733, if !!address(memory[0x00:0x20]).code.length // Inputs[9] // { // @173A msg.gas // @173B stack[-4] // @173B stack[-7] // @173B memory[stack[-4]:stack[-4] + stack[-5]] // @173B stack[-3] // @173B address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @173B stack[-2] // @173B stack[-6] // @173B stack[-5] // } 1738 5B JUMPDEST 1739 50 POP 173A 5A GAS 173B F1 CALL 173C 15 ISZERO 173D 80 DUP1 173E 15 ISZERO 173F 61 PUSH2 0x174c 1742 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @173B memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @173C stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x174c, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1743: // Incoming jump from 0x1742, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1743 returndata.length // @1747 returndata[0x00:0x00 + returndata.length] // @1748 returndata.length // @174B memory[0x00:0x00 + returndata.length] // } 1743 3D RETURNDATASIZE 1744 60 PUSH1 0x00 1746 80 DUP1 1747 3E RETURNDATACOPY 1748 3D RETURNDATASIZE 1749 60 PUSH1 0x00 174B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1747 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @174B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_174C: // Incoming jump from 0x1742, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[7] // { // @1752 memory[0x40:0x60] // @175D address(this) // @177E memory[0x40:0x60] // @1787 stack[-6] // @1789 stack[-4] // @1790 stack[-3] // @17A4 address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length // } 174C 5B JUMPDEST 174D 50 POP 174E 50 POP 174F 60 PUSH1 0x40 1751 80 DUP1 1752 51 MLOAD 1753 63 PUSH4 0x4538c4eb 1758 60 PUSH1 0xe0 175A 1B SHL 175B 81 DUP2 175C 52 MSTORE 175D 30 ADDRESS 175E 60 PUSH1 0x04 1760 82 DUP3 1761 01 ADD 1762 52 MSTORE 1763 73 PUSH20 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 1778 60 PUSH1 0x24 177A 82 DUP3 177B 01 ADD 177C 52 MSTORE 177D 90 SWAP1 177E 51 MLOAD 177F 60 PUSH1 0x01 1781 60 PUSH1 0x01 1783 60 PUSH1 0xa0 1785 1B SHL 1786 03 SUB 1787 86 DUP7 1788 16 AND 1789 93 SWAP4 178A 50 POP 178B 63 PUSH4 0x4538c4eb 1790 92 SWAP3 1791 50 POP 1792 60 PUSH1 0x44 1794 80 DUP1 1795 83 DUP4 1796 01 ADD 1797 92 SWAP3 1798 60 PUSH1 0x20 179A 92 SWAP3 179B 91 SWAP2 179C 90 SWAP1 179D 82 DUP3 179E 90 SWAP1 179F 03 SUB 17A0 01 ADD 17A1 81 DUP2 17A2 86 DUP7 17A3 80 DUP1 17A4 3B EXTCODESIZE 17A5 15 ISZERO 17A6 80 DUP1 17A7 15 ISZERO 17A8 61 PUSH2 0x17b0 17AB 57 *JUMPI // Stack delta = +5 // Outputs[12] // { // @175C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4538c4eb << 0xe0 // @1762 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @177C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @1789 stack[-4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1790 stack[-3] = 0x4538c4eb // @1797 stack[-2] = memory[0x40:0x60] + 0x44 // @179A stack[-1] = 0x20 // @179B stack[0] = memory[0x40:0x60] // @17A0 stack[1] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @17A1 stack[2] = memory[0x40:0x60] // @17A2 stack[3] = stack[-6] & (0x01 << 0xa0) - 0x01 // @17A5 stack[4] = !address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x17b0, if !!address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length label_17AC: // Incoming jump from 0x17AB, if not !!address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @17AF memory[0x00:0x00] } 17AC 60 PUSH1 0x00 17AE 80 DUP1 17AF FD *REVERT // Stack delta = +0 // Outputs[1] { @17AF revert(memory[0x00:0x00]); } // Block terminates label_17B0: // Incoming jump from 0x17AB, if !!address(stack[-6] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @17B2 msg.gas // @17B3 stack[-4] // @17B3 stack[-6] // @17B3 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @17B3 memory[stack[-3]:stack[-3] + stack[-4]] // @17B3 stack[-2] // @17B3 stack[-3] // @17B3 stack[-5] // } 17B0 5B JUMPDEST 17B1 50 POP 17B2 5A GAS 17B3 FA STATICCALL 17B4 15 ISZERO 17B5 80 DUP1 17B6 15 ISZERO 17B7 61 PUSH2 0x17c4 17BA 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @17B3 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @17B4 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x17c4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_17BB: // Incoming jump from 0x17BA, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @17BB returndata.length // @17BF returndata[0x00:0x00 + returndata.length] // @17C0 returndata.length // @17C3 memory[0x00:0x00 + returndata.length] // } 17BB 3D RETURNDATASIZE 17BC 60 PUSH1 0x00 17BE 80 DUP1 17BF 3E RETURNDATACOPY 17C0 3D RETURNDATASIZE 17C1 60 PUSH1 0x00 17C3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @17BF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @17C3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_17C4: // Incoming jump from 0x17BA, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @17CB memory[0x40:0x60] // @17CC returndata.length // } 17C4 5B JUMPDEST 17C5 50 POP 17C6 50 POP 17C7 50 POP 17C8 50 POP 17C9 60 PUSH1 0x40 17CB 51 MLOAD 17CC 3D RETURNDATASIZE 17CD 60 PUSH1 0x20 17CF 81 DUP2 17D0 10 LT 17D1 15 ISZERO 17D2 61 PUSH2 0x17da 17D5 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @17CB stack[-4] = memory[0x40:0x60] // @17CC stack[-3] = returndata.length // } // Block ends with conditional jump to 0x17da, if !(returndata.length < 0x20) label_17D6: // Incoming jump from 0x17D5, if not !(returndata.length < 0x20) // Inputs[1] { @17D9 memory[0x00:0x00] } 17D6 60 PUSH1 0x00 17D8 80 DUP1 17D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @17D9 revert(memory[0x00:0x00]); } // Block terminates label_17DA: // Incoming jump from 0x17D5, if !(returndata.length < 0x20) // Inputs[2] // { // @17DC memory[stack[-2]:stack[-2] + 0x20] // @17DC stack[-2] // } 17DA 5B JUMPDEST 17DB 50 POP 17DC 51 MLOAD 17DD 61 PUSH2 0x1854 17E0 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1854, if memory[stack[-2]:stack[-2] + 0x20] label_17E1: // Incoming jump from 0x17E0, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @17E4 memory[0x40:0x60] // @180A memory[0x40:0x60] // @1813 stack[-2] // @182F address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length // } 17E1 60 PUSH1 0x40 17E3 80 DUP1 17E4 51 MLOAD 17E5 63 PUSH4 0x28ec8bf1 17EA 60 PUSH1 0xe2 17EC 1B SHL 17ED 81 DUP2 17EE 52 MSTORE 17EF 73 PUSH20 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 1804 60 PUSH1 0x04 1806 82 DUP3 1807 01 ADD 1808 52 MSTORE 1809 90 SWAP1 180A 51 MLOAD 180B 60 PUSH1 0x01 180D 60 PUSH1 0x01 180F 60 PUSH1 0xa0 1811 1B SHL 1812 03 SUB 1813 84 DUP5 1814 16 AND 1815 91 SWAP2 1816 63 PUSH4 0xa3b22fc4 181B 91 SWAP2 181C 60 PUSH1 0x24 181E 80 DUP1 181F 83 DUP4 1820 01 ADD 1821 92 SWAP3 1822 60 PUSH1 0x00 1824 92 SWAP3 1825 91 SWAP2 1826 90 SWAP1 1827 82 DUP3 1828 90 SWAP1 1829 03 SUB 182A 01 ADD 182B 81 DUP2 182C 83 DUP4 182D 87 DUP8 182E 80 DUP1 182F 3B EXTCODESIZE 1830 15 ISZERO 1831 80 DUP1 1832 15 ISZERO 1833 61 PUSH2 0x183b 1836 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @17EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x28ec8bf1 << 0xe2 // @1808 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @1815 stack[0] = stack[-2] & (0x01 << 0xa0) - 0x01 // @181B stack[1] = 0xa3b22fc4 // @1821 stack[2] = memory[0x40:0x60] + 0x24 // @1824 stack[3] = 0x00 // @1825 stack[4] = memory[0x40:0x60] // @182A stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @182B stack[6] = memory[0x40:0x60] // @182C stack[7] = 0x00 // @182D stack[8] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1830 stack[9] = !address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x183b, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length label_1837: // Incoming jump from 0x1836, if not !!address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @183A memory[0x00:0x00] } 1837 60 PUSH1 0x00 1839 80 DUP1 183A FD *REVERT // Stack delta = +0 // Outputs[1] { @183A revert(memory[0x00:0x00]); } // Block terminates label_183B: // Incoming jump from 0x1836, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @183D msg.gas // @183E stack[-4] // @183E stack[-3] // @183E stack[-5] // @183E stack[-2] // @183E memory[stack[-4]:stack[-4] + stack[-5]] // @183E address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @183E stack[-7] // @183E stack[-6] // } 183B 5B JUMPDEST 183C 50 POP 183D 5A GAS 183E F1 CALL 183F 15 ISZERO 1840 80 DUP1 1841 15 ISZERO 1842 61 PUSH2 0x184f 1845 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @183E memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @183F stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x184f, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1846: // Incoming jump from 0x1845, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1846 returndata.length // @184A returndata[0x00:0x00 + returndata.length] // @184B returndata.length // @184E memory[0x00:0x00 + returndata.length] // } 1846 3D RETURNDATASIZE 1847 60 PUSH1 0x00 1849 80 DUP1 184A 3E RETURNDATACOPY 184B 3D RETURNDATASIZE 184C 60 PUSH1 0x00 184E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @184A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @184E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_184F: // Incoming jump from 0x1845, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 184F 5B JUMPDEST 1850 50 POP 1851 50 POP 1852 50 POP 1853 50 POP // Stack delta = -4 // Block continues label_1854: // Incoming jump from 0x1853 // Incoming jump from 0x17E0, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @186F stack[-1] // @1873 stack[-3] // } 1854 5B JUMPDEST 1855 73 PUSH20 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 186A 63 PUSH4 0x049878f3 186F 82 DUP3 1870 61 PUSH2 0x1884 1873 86 DUP7 1874 67 PUSH8 0x6765c793fa10079d 187D 60 PUSH1 0x1b 187F 1B SHL 1880 61 PUSH2 0x3da8 1883 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1855 stack[0] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @186A stack[1] = 0x049878f3 // @186F stack[2] = stack[-1] // @1870 stack[3] = 0x1884 // @1873 stack[4] = stack[-3] // @187F stack[5] = 0x6765c793fa10079d << 0x1b // } // Block ends with unconditional jump to 0x3da8 1884 5B JUMPDEST 1885 81 DUP2 1886 61 PUSH2 0x188b 1889 57 *JUMPI 188A FE *ASSERT 188B 5B JUMPDEST 188C 04 DIV 188D 60 PUSH1 0x40 188F 51 MLOAD 1890 82 DUP3 1891 63 PUSH4 0xffffffff 1896 16 AND 1897 60 PUSH1 0xe0 1899 1B SHL 189A 81 DUP2 189B 52 MSTORE 189C 60 PUSH1 0x04 189E 01 ADD 189F 80 DUP1 18A0 82 DUP3 18A1 81 DUP2 18A2 52 MSTORE 18A3 60 PUSH1 0x20 18A5 01 ADD 18A6 91 SWAP2 18A7 50 POP 18A8 50 POP 18A9 60 PUSH1 0x00 18AB 60 PUSH1 0x40 18AD 51 MLOAD 18AE 80 DUP1 18AF 83 DUP4 18B0 03 SUB 18B1 81 DUP2 18B2 60 PUSH1 0x00 18B4 87 DUP8 18B5 80 DUP1 18B6 3B EXTCODESIZE 18B7 15 ISZERO 18B8 80 DUP1 18B9 15 ISZERO 18BA 61 PUSH2 0x18c2 18BD 57 *JUMPI 18BE 60 PUSH1 0x00 18C0 80 DUP1 18C1 FD *REVERT 18C2 5B JUMPDEST 18C3 50 POP 18C4 5A GAS 18C5 F1 CALL 18C6 15 ISZERO 18C7 80 DUP1 18C8 15 ISZERO 18C9 61 PUSH2 0x18d6 18CC 57 *JUMPI 18CD 3D RETURNDATASIZE 18CE 60 PUSH1 0x00 18D0 80 DUP1 18D1 3E RETURNDATACOPY 18D2 3D RETURNDATASIZE 18D3 60 PUSH1 0x00 18D5 FD *REVERT 18D6 5B JUMPDEST 18D7 50 POP 18D8 50 POP 18D9 50 POP 18DA 50 POP 18DB 61 PUSH2 0x18e4 18DE 86 DUP7 18DF 84 DUP5 18E0 61 PUSH2 0x3b0e 18E3 56 *JUMP 18E4 5B JUMPDEST 18E5 60 PUSH1 0x40 18E7 51 MLOAD 18E8 80 DUP1 18E9 60 PUSH1 0x60 18EB 01 ADD 18EC 60 PUSH1 0x40 18EE 52 MSTORE 18EF 80 DUP1 18F0 60 PUSH1 0x26 18F2 81 DUP2 18F3 52 MSTORE 18F4 60 PUSH1 0x20 18F6 01 ADD 18F7 61 PUSH2 0x42da 18FA 60 PUSH1 0x26 18FC 91 SWAP2 18FD 39 CODECOPY 18FE 60 PUSH1 0x40 1900 80 DUP1 1901 51 MLOAD 1902 60 PUSH1 0x20 1904 81 DUP2 1905 01 ADD 1906 95 SWAP6 1907 90 SWAP1 1908 95 SWAP6 1909 52 MSTORE 190A 84 DUP5 190B 81 DUP2 190C 01 ADD 190D 98 SWAP9 190E 90 SWAP1 190F 98 SWAP9 1910 52 MSTORE 1911 60 PUSH1 0x60 1913 80 DUP1 1914 85 DUP6 1915 01 ADD 1916 97 SWAP8 1917 90 SWAP1 1918 97 SWAP8 1919 52 MSTORE 191A 87 DUP8 191B 51 MLOAD 191C 80 DUP1 191D 85 DUP6 191E 03 SUB 191F 90 SWAP1 1920 97 SWAP8 1921 01 ADD 1922 87 DUP8 1923 52 MSTORE 1924 60 PUSH1 0x80 1926 90 SWAP1 1927 93 SWAP4 1928 01 ADD 1929 90 SWAP1 192A 96 SWAP7 192B 52 MSTORE 192C 50 POP 192D 95 SWAP6 192E 92 SWAP3 192F 94 SWAP5 1930 50 POP 1931 91 SWAP2 1932 92 SWAP3 1933 50 POP 1934 50 POP 1935 50 POP 1936 56 *JUMP label_1937: // Incoming jump from 0x0330 // Inputs[2] // { // @1940 stack[-2] // @1941 stack[-3] // } 1937 5B JUMPDEST 1938 60 PUSH1 0x60 193A 80 DUP1 193B 60 PUSH1 0x00 193D 61 PUSH2 0x1946 1940 85 DUP6 1941 87 DUP8 1942 61 PUSH2 0x3a55 1945 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1938 stack[0] = 0x60 // @193A stack[1] = 0x60 // @193B stack[2] = 0x00 // @193D stack[3] = 0x1946 // @1940 stack[4] = stack[-2] // @1941 stack[5] = stack[-3] // } // Block ends with call to 0x3a55, returns to 0x1946 label_1946: // Incoming return from call to 0x3A55 at 0x1945 // Inputs[3] // { // @1947 stack[-2] // @1947 stack[-1] // @194E stack[-8] // } 1946 5B JUMPDEST 1947 90 SWAP1 1948 50 POP 1949 60 PUSH1 0x00 194B 61 PUSH2 0x1953 194E 88 DUP9 194F 61 PUSH2 0x3804 1952 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1947 stack[-2] = stack[-1] // @1949 stack[-1] = 0x00 // @194B stack[0] = 0x1953 // @194E stack[1] = stack[-8] // } // Block ends with call to 0x3804, returns to 0x1953 label_1953: // Incoming return from call to 0x3804 at 0x1952 // Inputs[2] // { // @1954 stack[-2] // @1954 stack[-1] // } 1953 5B JUMPDEST 1954 90 SWAP1 1955 50 POP 1956 60 PUSH1 0x00 1958 80 DUP1 1959 61 PUSH2 0x1961 195C 83 DUP4 195D 61 PUSH2 0x3950 1960 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1954 stack[-2] = stack[-1] // @1956 stack[-1] = 0x00 // @1958 stack[0] = 0x00 // @1959 stack[1] = 0x1961 // @195C stack[2] = stack[-1] // } // Block ends with call to 0x3950, returns to 0x1961 label_1961: // Incoming return from call to 0x3950 at 0x1960 // Inputs[7] // { // @1962 stack[-1] // @1962 stack[-3] // @1964 stack[-2] // @1964 stack[-4] // @198E memory[0x40:0x60] // @19AC memory[0x40:0x60] // @19B3 address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } 1961 5B JUMPDEST 1962 91 SWAP2 1963 50 POP 1964 91 SWAP2 1965 50 POP 1966 60 PUSH1 0x00 1968 73 PUSH20 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 197D 60 PUSH1 0x01 197F 60 PUSH1 0x01 1981 60 PUSH1 0xa0 1983 1B SHL 1984 03 SUB 1985 16 AND 1986 63 PUSH4 0x4445d799 198B 84 DUP5 198C 60 PUSH1 0x40 198E 51 MLOAD 198F 82 DUP3 1990 63 PUSH4 0xffffffff 1995 16 AND 1996 60 PUSH1 0xe0 1998 1B SHL 1999 81 DUP2 199A 52 MSTORE 199B 60 PUSH1 0x04 199D 01 ADD 199E 80 DUP1 199F 82 DUP3 19A0 81 DUP2 19A1 52 MSTORE 19A2 60 PUSH1 0x20 19A4 01 ADD 19A5 91 SWAP2 19A6 50 POP 19A7 50 POP 19A8 60 PUSH1 0x20 19AA 60 PUSH1 0x40 19AC 51 MLOAD 19AD 80 DUP1 19AE 83 DUP4 19AF 03 SUB 19B0 81 DUP2 19B1 86 DUP7 19B2 80 DUP1 19B3 3B EXTCODESIZE 19B4 15 ISZERO 19B5 80 DUP1 19B6 15 ISZERO 19B7 61 PUSH2 0x19bf 19BA 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @1962 stack[-3] = stack[-1] // @1964 stack[-4] = stack[-2] // @1966 stack[-2] = 0x00 // @1985 stack[-1] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @1986 stack[0] = 0x4445d799 // @199A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x4445d799) << 0xe0 // @19A1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @19A5 stack[1] = 0x20 + 0x04 + memory[0x40:0x60] // @19A8 stack[2] = 0x20 // @19AC stack[3] = memory[0x40:0x60] // @19AF stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @19B0 stack[5] = memory[0x40:0x60] // @19B1 stack[6] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @19B4 stack[7] = !address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } // Block ends with conditional jump to 0x19bf, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length label_19BB: // Incoming jump from 0x19BA, if not !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[1] { @19BE memory[0x00:0x00] } 19BB 60 PUSH1 0x00 19BD 80 DUP1 19BE FD *REVERT // Stack delta = +0 // Outputs[1] { @19BE revert(memory[0x00:0x00]); } // Block terminates label_19BF: // Incoming jump from 0x19BA, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[8] // { // @19C1 msg.gas // @19C2 stack[-6] // @19C2 stack[-3] // @19C2 stack[-4] // @19C2 memory[stack[-3]:stack[-3] + stack[-4]] // @19C2 stack[-5] // @19C2 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @19C2 stack[-2] // } 19BF 5B JUMPDEST 19C0 50 POP 19C1 5A GAS 19C2 FA STATICCALL 19C3 15 ISZERO 19C4 80 DUP1 19C5 15 ISZERO 19C6 61 PUSH2 0x19d3 19C9 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @19C2 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @19C3 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x19d3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_19CA: // Incoming jump from 0x19C9, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @19CA returndata.length // @19CE returndata[0x00:0x00 + returndata.length] // @19CF returndata.length // @19D2 memory[0x00:0x00 + returndata.length] // } 19CA 3D RETURNDATASIZE 19CB 60 PUSH1 0x00 19CD 80 DUP1 19CE 3E RETURNDATACOPY 19CF 3D RETURNDATASIZE 19D0 60 PUSH1 0x00 19D2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19CE memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @19D2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_19D3: // Incoming jump from 0x19C9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @19DA memory[0x40:0x60] // @19DB returndata.length // } 19D3 5B JUMPDEST 19D4 50 POP 19D5 50 POP 19D6 50 POP 19D7 50 POP 19D8 60 PUSH1 0x40 19DA 51 MLOAD 19DB 3D RETURNDATASIZE 19DC 60 PUSH1 0x20 19DE 81 DUP2 19DF 10 LT 19E0 15 ISZERO 19E1 61 PUSH2 0x19e9 19E4 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @19DA stack[-4] = memory[0x40:0x60] // @19DB stack[-3] = returndata.length // } // Block ends with conditional jump to 0x19e9, if !(returndata.length < 0x20) label_19E5: // Incoming jump from 0x19E4, if not !(returndata.length < 0x20) // Inputs[1] { @19E8 memory[0x00:0x00] } 19E5 60 PUSH1 0x00 19E7 80 DUP1 19E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @19E8 revert(memory[0x00:0x00]); } // Block terminates label_19E9: // Incoming jump from 0x19E4, if !(returndata.length < 0x20) // Inputs[4] // { // @19EB memory[stack[-2]:stack[-2] + 0x20] // @19EB stack[-2] // @19EC stack[-3] // @19F4 stack[-7] // } 19E9 5B JUMPDEST 19EA 50 POP 19EB 51 MLOAD 19EC 90 SWAP1 19ED 50 POP 19EE 80 DUP1 19EF 60 PUSH1 0x00 19F1 60 PUSH1 0x00 19F3 19 NOT 19F4 87 DUP8 19F5 14 EQ 19F6 15 ISZERO 19F7 61 PUSH2 0x1b68 19FA 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @19EC stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @19EE stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @19EF stack[-1] = 0x00 // } // Block ends with conditional jump to 0x1b68, if !(stack[-7] == ~0x00) label_19FB: // Incoming jump from 0x19FA, if not !(stack[-7] == ~0x00) // Inputs[5] // { // @19FE memory[0x00:0x20] // @1A07 memory[0x00:0x20] // @1A1A memory[0x40:0x60] // @1A2E memory[0x40:0x60] // @1A35 address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 19FB 60 PUSH1 0x00 19FD 80 DUP1 19FE 51 MLOAD 19FF 60 PUSH1 0x20 1A01 61 PUSH2 0x4418 1A04 83 DUP4 1A05 39 CODECOPY 1A06 81 DUP2 1A07 51 MLOAD 1A08 91 SWAP2 1A09 52 MSTORE 1A0A 60 PUSH1 0x01 1A0C 60 PUSH1 0x01 1A0E 60 PUSH1 0xa0 1A10 1B SHL 1A11 03 SUB 1A12 16 AND 1A13 63 PUSH4 0x36569e77 1A18 60 PUSH1 0x40 1A1A 51 MLOAD 1A1B 81 DUP2 1A1C 63 PUSH4 0xffffffff 1A21 16 AND 1A22 60 PUSH1 0xe0 1A24 1B SHL 1A25 81 DUP2 1A26 52 MSTORE 1A27 60 PUSH1 0x04 1A29 01 ADD 1A2A 60 PUSH1 0x20 1A2C 60 PUSH1 0x40 1A2E 51 MLOAD 1A2F 80 DUP1 1A30 83 DUP4 1A31 03 SUB 1A32 81 DUP2 1A33 86 DUP7 1A34 80 DUP1 1A35 3B EXTCODESIZE 1A36 15 ISZERO 1A37 80 DUP1 1A38 15 ISZERO 1A39 61 PUSH2 0x1a41 1A3C 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @1A05 memory[0x00:0x20] = code[0x4418:0x4438] // @1A09 memory[0x00:0x20] = memory[0x00:0x20] // @1A12 stack[0] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @1A13 stack[1] = 0x36569e77 // @1A26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @1A29 stack[2] = 0x04 + memory[0x40:0x60] // @1A2A stack[3] = 0x20 // @1A2E stack[4] = memory[0x40:0x60] // @1A31 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1A32 stack[6] = memory[0x40:0x60] // @1A33 stack[7] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @1A36 stack[8] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x1a41, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_1A3D: // Incoming jump from 0x1A3C, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @1A40 memory[0x00:0x00] } 1A3D 60 PUSH1 0x00 1A3F 80 DUP1 1A40 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A40 revert(memory[0x00:0x00]); } // Block terminates label_1A41: // Incoming jump from 0x1A3C, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @1A43 msg.gas // @1A44 stack[-6] // @1A44 memory[stack[-3]:stack[-3] + stack[-4]] // @1A44 stack[-4] // @1A44 stack[-5] // @1A44 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1A44 stack[-2] // @1A44 stack[-3] // } 1A41 5B JUMPDEST 1A42 50 POP 1A43 5A GAS 1A44 FA STATICCALL 1A45 15 ISZERO 1A46 80 DUP1 1A47 15 ISZERO 1A48 61 PUSH2 0x1a55 1A4B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1A44 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1A45 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1a55, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1A4C: // Incoming jump from 0x1A4B, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1A4C returndata.length // @1A50 returndata[0x00:0x00 + returndata.length] // @1A51 returndata.length // @1A54 memory[0x00:0x00 + returndata.length] // } 1A4C 3D RETURNDATASIZE 1A4D 60 PUSH1 0x00 1A4F 80 DUP1 1A50 3E RETURNDATACOPY 1A51 3D RETURNDATASIZE 1A52 60 PUSH1 0x00 1A54 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A50 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1A54 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1A55: // Incoming jump from 0x1A4B, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1A5C memory[0x40:0x60] // @1A5D returndata.length // } 1A55 5B JUMPDEST 1A56 50 POP 1A57 50 POP 1A58 50 POP 1A59 50 POP 1A5A 60 PUSH1 0x40 1A5C 51 MLOAD 1A5D 3D RETURNDATASIZE 1A5E 60 PUSH1 0x20 1A60 81 DUP2 1A61 10 LT 1A62 15 ISZERO 1A63 61 PUSH2 0x1a6b 1A66 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1A5C stack[-4] = memory[0x40:0x60] // @1A5D stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1a6b, if !(returndata.length < 0x20) label_1A67: // Incoming jump from 0x1A66, if not !(returndata.length < 0x20) // Inputs[1] { @1A6A memory[0x00:0x00] } 1A67 60 PUSH1 0x00 1A69 80 DUP1 1A6A FD *REVERT // Stack delta = +0 // Outputs[1] { @1A6A revert(memory[0x00:0x00]); } // Block terminates label_1A6B: // Incoming jump from 0x1A66, if !(returndata.length < 0x20) // Inputs[7] // { // @1A6D memory[stack[-2]:stack[-2] + 0x20] // @1A6D stack[-2] // @1A71 memory[0x40:0x60] // @1A80 stack[-7] // @1A8B stack[-6] // @1A94 memory[0x40:0x60] // @1AAE address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } 1A6B 5B JUMPDEST 1A6C 50 POP 1A6D 51 MLOAD 1A6E 60 PUSH1 0x40 1A70 80 DUP1 1A71 51 MLOAD 1A72 63 PUSH4 0x09092f97 1A77 60 PUSH1 0xe2 1A79 1B SHL 1A7A 81 DUP2 1A7B 52 MSTORE 1A7C 60 PUSH1 0x04 1A7E 81 DUP2 1A7F 01 ADD 1A80 88 DUP9 1A81 90 SWAP1 1A82 52 MSTORE 1A83 60 PUSH1 0x01 1A85 60 PUSH1 0x01 1A87 60 PUSH1 0xa0 1A89 1B SHL 1A8A 03 SUB 1A8B 87 DUP8 1A8C 81 DUP2 1A8D 16 AND 1A8E 60 PUSH1 0x24 1A90 83 DUP4 1A91 01 ADD 1A92 52 MSTORE 1A93 82 DUP3 1A94 51 MLOAD 1A95 93 SWAP4 1A96 16 AND 1A97 92 SWAP3 1A98 63 PUSH4 0x2424be5c 1A9D 92 SWAP3 1A9E 60 PUSH1 0x44 1AA0 80 DUP1 1AA1 84 DUP5 1AA2 01 ADD 1AA3 93 SWAP4 1AA4 91 SWAP2 1AA5 92 SWAP3 1AA6 91 SWAP2 1AA7 82 DUP3 1AA8 90 SWAP1 1AA9 03 SUB 1AAA 01 ADD 1AAB 81 DUP2 1AAC 86 DUP7 1AAD 80 DUP1 1AAE 3B EXTCODESIZE 1AAF 15 ISZERO 1AB0 80 DUP1 1AB1 15 ISZERO 1AB2 61 PUSH2 0x1aba 1AB5 57 *JUMPI // Stack delta = +7 // Outputs[12] // { // @1A7B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x09092f97 << 0xe2 // @1A82 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-7] // @1A92 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1A97 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @1A9D stack[-1] = 0x2424be5c // @1AA3 stack[0] = memory[0x40:0x60] + 0x44 // @1AA5 stack[1] = 0x40 // @1AA6 stack[2] = memory[0x40:0x60] // @1AAA stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @1AAB stack[4] = memory[0x40:0x60] // @1AAC stack[5] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @1AAF stack[6] = !address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1aba, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length label_1AB6: // Incoming jump from 0x1AB5, if not !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1AB9 memory[0x00:0x00] } 1AB6 60 PUSH1 0x00 1AB8 80 DUP1 1AB9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AB9 revert(memory[0x00:0x00]); } // Block terminates label_1ABA: // Incoming jump from 0x1AB5, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @1ABC msg.gas // @1ABD stack[-3] // @1ABD stack[-6] // @1ABD stack[-4] // @1ABD stack[-2] // @1ABD stack[-5] // @1ABD memory[stack[-3]:stack[-3] + stack[-4]] // @1ABD address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 1ABA 5B JUMPDEST 1ABB 50 POP 1ABC 5A GAS 1ABD FA STATICCALL 1ABE 15 ISZERO 1ABF 80 DUP1 1AC0 15 ISZERO 1AC1 61 PUSH2 0x1ace 1AC4 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1ABD memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1ABE stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1ace, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1AC5: // Incoming jump from 0x1AC4, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1AC5 returndata.length // @1AC9 returndata[0x00:0x00 + returndata.length] // @1ACA returndata.length // @1ACD memory[0x00:0x00 + returndata.length] // } 1AC5 3D RETURNDATASIZE 1AC6 60 PUSH1 0x00 1AC8 80 DUP1 1AC9 3E RETURNDATACOPY 1ACA 3D RETURNDATASIZE 1ACB 60 PUSH1 0x00 1ACD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AC9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1ACD revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1ACE: // Incoming jump from 0x1AC4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1AD5 memory[0x40:0x60] // @1AD6 returndata.length // } 1ACE 5B JUMPDEST 1ACF 50 POP 1AD0 50 POP 1AD1 50 POP 1AD2 50 POP 1AD3 60 PUSH1 0x40 1AD5 51 MLOAD 1AD6 3D RETURNDATASIZE 1AD7 60 PUSH1 0x40 1AD9 81 DUP2 1ADA 10 LT 1ADB 15 ISZERO 1ADC 61 PUSH2 0x1ae4 1ADF 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1AD5 stack[-4] = memory[0x40:0x60] // @1AD6 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1ae4, if !(returndata.length < 0x40) label_1AE0: // Incoming jump from 0x1ADF, if not !(returndata.length < 0x40) // Inputs[1] { @1AE3 memory[0x00:0x00] } 1AE0 60 PUSH1 0x00 1AE2 80 DUP1 1AE3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AE3 revert(memory[0x00:0x00]); } // Block terminates label_1AE4: // Incoming jump from 0x1ADF, if !(returndata.length < 0x40) // Inputs[7] // { // @1AE6 stack[-2] // @1AE6 memory[stack[-2]:stack[-2] + 0x20] // @1AEA memory[0x40:0x60] // @1AF6 memory[0x40:0x60] // @1AF8 stack[-3] // @1B06 stack[-4] // @1B23 address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 1AE4 5B JUMPDEST 1AE5 50 POP 1AE6 51 MLOAD 1AE7 60 PUSH1 0x40 1AE9 80 DUP1 1AEA 51 MLOAD 1AEB 63 PUSH4 0x59de7d41 1AF0 60 PUSH1 0xe1 1AF2 1B SHL 1AF3 81 DUP2 1AF4 52 MSTORE 1AF5 90 SWAP1 1AF6 51 MLOAD 1AF7 91 SWAP2 1AF8 92 SWAP3 1AF9 50 POP 1AFA 61 PUSH2 0x1b61 1AFD 91 SWAP2 1AFE 60 PUSH1 0x01 1B00 60 PUSH1 0x01 1B02 60 PUSH1 0xa0 1B04 1B SHL 1B05 03 SUB 1B06 85 DUP6 1B07 16 AND 1B08 91 SWAP2 1B09 63 PUSH4 0xb3bcfa82 1B0E 91 SWAP2 1B0F 60 PUSH1 0x04 1B11 80 DUP1 1B12 83 DUP4 1B13 01 ADD 1B14 92 SWAP3 1B15 60 PUSH1 0x20 1B17 92 SWAP3 1B18 91 SWAP2 1B19 90 SWAP1 1B1A 82 DUP3 1B1B 90 SWAP1 1B1C 03 SUB 1B1D 01 ADD 1B1E 81 DUP2 1B1F 60 PUSH1 0x00 1B21 87 DUP8 1B22 80 DUP1 1B23 3B EXTCODESIZE 1B24 15 ISZERO 1B25 80 DUP1 1B26 15 ISZERO 1B27 61 PUSH2 0x1b2f 1B2A 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @1AF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x59de7d41 << 0xe1 // @1AF8 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @1AFD stack[-2] = 0x1b61 // @1B08 stack[-1] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1B0E stack[0] = 0xb3bcfa82 // @1B14 stack[1] = memory[0x40:0x60] + 0x04 // @1B17 stack[2] = 0x20 // @1B18 stack[3] = memory[0x40:0x60] // @1B1D stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @1B1E stack[5] = memory[0x40:0x60] // @1B1F stack[6] = 0x00 // @1B21 stack[7] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1B24 stack[8] = !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional call to 0x1b2f, returns to 0x1B61, if !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_1B2B: // Incoming jump from 0x1B2A, if not !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1B2E memory[0x00:0x00] } 1B2B 60 PUSH1 0x00 1B2D 80 DUP1 1B2E FD *REVERT // Stack delta = +0 // Outputs[1] { @1B2E revert(memory[0x00:0x00]); } // Block terminates label_1B2F: // Incoming call from 0x2AB3, returns to 0x2AB8, if !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Incoming call from 0x1B2A, returns to 0x1B61, if !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @1B31 msg.gas // @1B32 stack[-4] // @1B32 stack[-7] // @1B32 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B32 stack[-6] // @1B32 memory[stack[-4]:stack[-4] + stack[-5]] // @1B32 stack[-3] // @1B32 stack[-2] // @1B32 stack[-5] // } 1B2F 5B JUMPDEST 1B30 50 POP 1B31 5A GAS 1B32 F1 CALL 1B33 15 ISZERO 1B34 80 DUP1 1B35 15 ISZERO 1B36 61 PUSH2 0x1b43 1B39 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1B32 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B33 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1b43, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1B3A: // Incoming jump from 0x1B39, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1B3A returndata.length // @1B3E returndata[0x00:0x00 + returndata.length] // @1B3F returndata.length // @1B42 memory[0x00:0x00 + returndata.length] // } 1B3A 3D RETURNDATASIZE 1B3B 60 PUSH1 0x00 1B3D 80 DUP1 1B3E 3E RETURNDATACOPY 1B3F 3D RETURNDATASIZE 1B40 60 PUSH1 0x00 1B42 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B3E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1B42 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1B43: // Incoming jump from 0x1B39, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1B4A memory[0x40:0x60] // @1B4B returndata.length // } 1B43 5B JUMPDEST 1B44 50 POP 1B45 50 POP 1B46 50 POP 1B47 50 POP 1B48 60 PUSH1 0x40 1B4A 51 MLOAD 1B4B 3D RETURNDATASIZE 1B4C 60 PUSH1 0x20 1B4E 81 DUP2 1B4F 10 LT 1B50 15 ISZERO 1B51 61 PUSH2 0x1b59 1B54 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1B4A stack[-4] = memory[0x40:0x60] // @1B4B stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1b59, if !(returndata.length < 0x20) label_1B55: // Incoming jump from 0x1B54, if not !(returndata.length < 0x20) // Inputs[1] { @1B58 memory[0x00:0x00] } 1B55 60 PUSH1 0x00 1B57 80 DUP1 1B58 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B58 revert(memory[0x00:0x00]); } // Block terminates label_1B59: // Incoming jump from 0x1B54, if !(returndata.length < 0x20) // Inputs[3] // { // @1B5B memory[stack[-2]:stack[-2] + 0x20] // @1B5B stack[-2] // @1B5C stack[-4] // } 1B59 5B JUMPDEST 1B5A 50 POP 1B5B 51 MLOAD 1B5C 82 DUP3 1B5D 61 PUSH2 0x3db4 1B60 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1B5B stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @1B5C stack[-1] = stack[-4] // } // Block ends with unconditional jump to 0x3db4 label_1B61: // Incoming return from call to 0x1B2F at 0x1B2A // Inputs[2] // { // @1B62 stack[-8] // @1B62 stack[-1] // } 1B61 5B JUMPDEST 1B62 96 SWAP7 1B63 50 POP 1B64 61 PUSH2 0x1bdb 1B67 56 *JUMP // Stack delta = -1 // Outputs[1] { @1B62 stack[-8] = stack[-1] } // Block ends with unconditional jump to 0x1bdb label_1B68: // Incoming jump from 0x19FA, if !(stack[-7] == ~0x00) // Inputs[4] // { // @1B6C stack[-2] // @1B7D memory[0x40:0x60] // @1B91 memory[0x40:0x60] // @1B9A address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // } 1B68 5B JUMPDEST 1B69 61 PUSH2 0x1bd8 1B6C 82 DUP3 1B6D 60 PUSH1 0x01 1B6F 60 PUSH1 0x01 1B71 60 PUSH1 0xa0 1B73 1B SHL 1B74 03 SUB 1B75 16 AND 1B76 63 PUSH4 0xb3bcfa82 1B7B 60 PUSH1 0x40 1B7D 51 MLOAD 1B7E 81 DUP2 1B7F 63 PUSH4 0xffffffff 1B84 16 AND 1B85 60 PUSH1 0xe0 1B87 1B SHL 1B88 81 DUP2 1B89 52 MSTORE 1B8A 60 PUSH1 0x04 1B8C 01 ADD 1B8D 60 PUSH1 0x20 1B8F 60 PUSH1 0x40 1B91 51 MLOAD 1B92 80 DUP1 1B93 83 DUP4 1B94 03 SUB 1B95 81 DUP2 1B96 60 PUSH1 0x00 1B98 87 DUP8 1B99 80 DUP1 1B9A 3B EXTCODESIZE 1B9B 15 ISZERO 1B9C 80 DUP1 1B9D 15 ISZERO 1B9E 61 PUSH2 0x1ba6 1BA1 57 *JUMPI // Stack delta = +11 // Outputs[12] // { // @1B69 stack[0] = 0x1bd8 // @1B75 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1B76 stack[2] = 0xb3bcfa82 // @1B89 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xb3bcfa82) << 0xe0 // @1B8C stack[3] = 0x04 + memory[0x40:0x60] // @1B8D stack[4] = 0x20 // @1B91 stack[5] = memory[0x40:0x60] // @1B94 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1B95 stack[7] = memory[0x40:0x60] // @1B96 stack[8] = 0x00 // @1B98 stack[9] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1B9B stack[10] = !address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // } // Block ends with conditional jump to 0x1ba6, if !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length label_1BA2: // Incoming jump from 0x1BA1, if not !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // Inputs[1] { @1BA5 memory[0x00:0x00] } 1BA2 60 PUSH1 0x00 1BA4 80 DUP1 1BA5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BA5 revert(memory[0x00:0x00]); } // Block terminates label_1BA6: // Incoming jump from 0x1BA1, if !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // Inputs[9] // { // @1BA8 msg.gas // @1BA9 stack[-7] // @1BA9 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1BA9 stack[-4] // @1BA9 stack[-2] // @1BA9 stack[-3] // @1BA9 stack[-6] // @1BA9 stack[-5] // @1BA9 memory[stack[-4]:stack[-4] + stack[-5]] // } 1BA6 5B JUMPDEST 1BA7 50 POP 1BA8 5A GAS 1BA9 F1 CALL 1BAA 15 ISZERO 1BAB 80 DUP1 1BAC 15 ISZERO 1BAD 61 PUSH2 0x1bba 1BB0 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1BA9 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1BAA stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1bba, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1BB1: // Incoming jump from 0x1BB0, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1BB1 returndata.length // @1BB5 returndata[0x00:0x00 + returndata.length] // @1BB6 returndata.length // @1BB9 memory[0x00:0x00 + returndata.length] // } 1BB1 3D RETURNDATASIZE 1BB2 60 PUSH1 0x00 1BB4 80 DUP1 1BB5 3E RETURNDATACOPY 1BB6 3D RETURNDATASIZE 1BB7 60 PUSH1 0x00 1BB9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1BB5 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1BB9 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1BBA: // Incoming jump from 0x1BB0, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1BC1 memory[0x40:0x60] // @1BC2 returndata.length // } 1BBA 5B JUMPDEST 1BBB 50 POP 1BBC 50 POP 1BBD 50 POP 1BBE 50 POP 1BBF 60 PUSH1 0x40 1BC1 51 MLOAD 1BC2 3D RETURNDATASIZE 1BC3 60 PUSH1 0x20 1BC5 81 DUP2 1BC6 10 LT 1BC7 15 ISZERO 1BC8 61 PUSH2 0x1bd0 1BCB 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1BC1 stack[-4] = memory[0x40:0x60] // @1BC2 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1bd0, if !(returndata.length < 0x20) label_1BCC: // Incoming jump from 0x1BCB, if not !(returndata.length < 0x20) // Inputs[1] { @1BCF memory[0x00:0x00] } 1BCC 60 PUSH1 0x00 1BCE 80 DUP1 1BCF FD *REVERT // Stack delta = +0 // Outputs[1] { @1BCF revert(memory[0x00:0x00]); } // Block terminates label_1BD0: // Incoming jump from 0x1BCB, if !(returndata.length < 0x20) // Inputs[3] // { // @1BD2 memory[stack[-2]:stack[-2] + 0x20] // @1BD2 stack[-2] // @1BD3 stack[-10] // } 1BD0 5B JUMPDEST 1BD1 50 POP 1BD2 51 MLOAD 1BD3 88 DUP9 1BD4 61 PUSH2 0x3d50 1BD7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1BD2 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @1BD3 stack[-1] = stack[-10] // } // Block ends with unconditional jump to 0x3d50 1BD8 5B JUMPDEST 1BD9 90 SWAP1 1BDA 50 POP label_1BDB: // Incoming jump from 0x1B67 // Inputs[4] // { // @1BDF memory[0x00:0x20] // @1BE8 memory[0x00:0x20] // @1BF0 stack[-6] // @1BF4 stack[-1] // } 1BDB 5B JUMPDEST 1BDC 60 PUSH1 0x00 1BDE 80 DUP1 1BDF 51 MLOAD 1BE0 60 PUSH1 0x20 1BE2 61 PUSH2 0x4418 1BE5 83 DUP4 1BE6 39 CODECOPY 1BE7 81 DUP2 1BE8 51 MLOAD 1BE9 91 SWAP2 1BEA 52 MSTORE 1BEB 63 PUSH4 0x45e6bdcd 1BF0 87 DUP8 1BF1 61 PUSH2 0x1bf9 1BF4 84 DUP5 1BF5 61 PUSH2 0x3d62 1BF8 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1BE6 memory[0x00:0x20] = code[0x4418:0x4438] // @1BE9 stack[0] = memory[0x00:0x20] // @1BEA memory[0x00:0x20] = memory[0x00:0x20] // @1BEB stack[1] = 0x45e6bdcd // @1BF0 stack[2] = stack[-6] // @1BF1 stack[3] = 0x1bf9 // @1BF4 stack[4] = stack[-1] // } // Block ends with call to 0x3d62, returns to 0x1BF9 label_1BF9: // Incoming return from call to 0x3D62 at 0x1BF8 // Inputs[7] // { // @1BFC stack[-1] // @1C01 memory[0x40:0x60] // @1C02 stack[-3] // @1C12 stack[-2] // @1C2D memory[0x40:0x60] // @1C34 stack[-4] // @1C36 address(stack[-4]).code.length // } 1BF9 5B JUMPDEST 1BFA 60 PUSH1 0x00 1BFC 03 SUB 1BFD 60 PUSH1 0x00 1BFF 60 PUSH1 0x40 1C01 51 MLOAD 1C02 84 DUP5 1C03 63 PUSH4 0xffffffff 1C08 16 AND 1C09 60 PUSH1 0xe0 1C0B 1B SHL 1C0C 81 DUP2 1C0D 52 MSTORE 1C0E 60 PUSH1 0x04 1C10 01 ADD 1C11 80 DUP1 1C12 84 DUP5 1C13 81 DUP2 1C14 52 MSTORE 1C15 60 PUSH1 0x20 1C17 01 ADD 1C18 83 DUP4 1C19 81 DUP2 1C1A 52 MSTORE 1C1B 60 PUSH1 0x20 1C1D 01 ADD 1C1E 82 DUP3 1C1F 81 DUP2 1C20 52 MSTORE 1C21 60 PUSH1 0x20 1C23 01 ADD 1C24 93 SWAP4 1C25 50 POP 1C26 50 POP 1C27 50 POP 1C28 50 POP 1C29 60 PUSH1 0x00 1C2B 60 PUSH1 0x40 1C2D 51 MLOAD 1C2E 80 DUP1 1C2F 83 DUP4 1C30 03 SUB 1C31 81 DUP2 1C32 60 PUSH1 0x00 1C34 87 DUP8 1C35 80 DUP1 1C36 3B EXTCODESIZE 1C37 15 ISZERO 1C38 80 DUP1 1C39 15 ISZERO 1C3A 61 PUSH2 0x1c42 1C3D 57 *JUMPI // Stack delta = +6 // Outputs[12] // { // @1C0D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-3]) << 0xe0 // @1C14 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @1C1A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x00 - stack[-1] // @1C20 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x00 // @1C24 stack[-2] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1C29 stack[-1] = 0x00 // @1C2D stack[0] = memory[0x40:0x60] // @1C30 stack[1] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1C31 stack[2] = memory[0x40:0x60] // @1C32 stack[3] = 0x00 // @1C34 stack[4] = stack[-4] // @1C37 stack[5] = !address(stack[-4]).code.length // } // Block ends with conditional jump to 0x1c42, if !!address(stack[-4]).code.length label_1C3E: // Incoming jump from 0x1C3D, if not !!address(stack[-4]).code.length // Inputs[1] { @1C41 memory[0x00:0x00] } 1C3E 60 PUSH1 0x00 1C40 80 DUP1 1C41 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C41 revert(memory[0x00:0x00]); } // Block terminates label_1C42: // Incoming jump from 0x1C3D, if !!address(stack[-4]).code.length // Inputs[9] // { // @1C44 msg.gas // @1C45 stack[-4] // @1C45 stack[-6] // @1C45 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1C45 stack[-3] // @1C45 stack[-7] // @1C45 memory[stack[-4]:stack[-4] + stack[-5]] // @1C45 stack[-5] // @1C45 stack[-2] // } 1C42 5B JUMPDEST 1C43 50 POP 1C44 5A GAS 1C45 F1 CALL 1C46 15 ISZERO 1C47 80 DUP1 1C48 15 ISZERO 1C49 61 PUSH2 0x1c56 1C4C 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1C45 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1C46 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1c56, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1C4D: // Incoming jump from 0x1C4C, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1C4D returndata.length // @1C51 returndata[0x00:0x00 + returndata.length] // @1C52 returndata.length // @1C55 memory[0x00:0x00 + returndata.length] // } 1C4D 3D RETURNDATASIZE 1C4E 60 PUSH1 0x00 1C50 80 DUP1 1C51 3E RETURNDATACOPY 1C52 3D RETURNDATASIZE 1C53 60 PUSH1 0x00 1C55 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1C51 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1C55 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1C56: // Incoming jump from 0x1C4C, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[10] // { // @1C5C memory[0x40:0x60] // @1C6B stack[-10] // @1C6E address(this) // @1C78 stack[-5] // @1C7C memory[0x40:0x60] // @1C80 memory[0x00:0x20] // @1C89 memory[0x00:0x20] // @1C8C stack[-4] // @1C93 stack[-3] // @1CA8 address(memory[0x00:0x20]).code.length // } 1C56 5B JUMPDEST 1C57 50 POP 1C58 50 POP 1C59 60 PUSH1 0x40 1C5B 80 DUP1 1C5C 51 MLOAD 1C5D 63 PUSH4 0x13771f07 1C62 60 PUSH1 0xe3 1C64 1B SHL 1C65 81 DUP2 1C66 52 MSTORE 1C67 60 PUSH1 0x04 1C69 81 DUP2 1C6A 01 ADD 1C6B 8A DUP11 1C6C 90 SWAP1 1C6D 52 MSTORE 1C6E 30 ADDRESS 1C6F 60 PUSH1 0x24 1C71 82 DUP3 1C72 01 ADD 1C73 52 MSTORE 1C74 60 PUSH1 0x44 1C76 81 DUP2 1C77 01 ADD 1C78 85 DUP6 1C79 90 SWAP1 1C7A 52 MSTORE 1C7B 90 SWAP1 1C7C 51 MLOAD 1C7D 60 PUSH1 0x00 1C7F 80 DUP1 1C80 51 MLOAD 1C81 60 PUSH1 0x20 1C83 61 PUSH2 0x4418 1C86 83 DUP4 1C87 39 CODECOPY 1C88 81 DUP2 1C89 51 MLOAD 1C8A 91 SWAP2 1C8B 52 MSTORE 1C8C 93 SWAP4 1C8D 50 POP 1C8E 63 PUSH4 0x9bb8f838 1C93 92 SWAP3 1C94 50 POP 1C95 60 PUSH1 0x64 1C97 80 DUP1 1C98 83 DUP4 1C99 01 ADD 1C9A 92 SWAP3 1C9B 60 PUSH1 0x00 1C9D 92 SWAP3 1C9E 91 SWAP2 1C9F 90 SWAP1 1CA0 82 DUP3 1CA1 90 SWAP1 1CA2 03 SUB 1CA3 01 ADD 1CA4 81 DUP2 1CA5 83 DUP4 1CA6 87 DUP8 1CA7 80 DUP1 1CA8 3B EXTCODESIZE 1CA9 15 ISZERO 1CAA 80 DUP1 1CAB 15 ISZERO 1CAC 61 PUSH2 0x1cb4 1CAF 57 *JUMPI // Stack delta = +6 // Outputs[16] // { // @1C66 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x13771f07 << 0xe3 // @1C6D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-10] // @1C73 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = address(this) // @1C7A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-5] // @1C87 memory[0x00:0x20] = code[0x4418:0x4438] // @1C8B memory[0x00:0x20] = memory[0x00:0x20] // @1C8C stack[-4] = memory[0x00:0x20] // @1C93 stack[-3] = 0x9bb8f838 // @1C9A stack[-2] = memory[0x40:0x60] + 0x64 // @1C9D stack[-1] = 0x00 // @1C9E stack[0] = memory[0x40:0x60] // @1CA3 stack[1] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @1CA4 stack[2] = memory[0x40:0x60] // @1CA5 stack[3] = 0x00 // @1CA6 stack[4] = memory[0x00:0x20] // @1CA9 stack[5] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x1cb4, if !!address(memory[0x00:0x20]).code.length label_1CB0: // Incoming jump from 0x1CAF, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @1CB3 memory[0x00:0x00] } 1CB0 60 PUSH1 0x00 1CB2 80 DUP1 1CB3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CB3 revert(memory[0x00:0x00]); } // Block terminates label_1CB4: // Incoming jump from 0x1CAF, if !!address(memory[0x00:0x20]).code.length // Inputs[9] // { // @1CB6 msg.gas // @1CB7 stack[-4] // @1CB7 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1CB7 stack[-2] // @1CB7 stack[-5] // @1CB7 stack[-7] // @1CB7 memory[stack[-4]:stack[-4] + stack[-5]] // @1CB7 stack[-6] // @1CB7 stack[-3] // } 1CB4 5B JUMPDEST 1CB5 50 POP 1CB6 5A GAS 1CB7 F1 CALL 1CB8 15 ISZERO 1CB9 80 DUP1 1CBA 15 ISZERO 1CBB 61 PUSH2 0x1cc8 1CBE 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1CB7 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1CB8 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1cc8, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1CBF: // Incoming jump from 0x1CBE, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1CBF returndata.length // @1CC3 returndata[0x00:0x00 + returndata.length] // @1CC4 returndata.length // @1CC7 memory[0x00:0x00 + returndata.length] // } 1CBF 3D RETURNDATASIZE 1CC0 60 PUSH1 0x00 1CC2 80 DUP1 1CC3 3E RETURNDATACOPY 1CC4 3D RETURNDATASIZE 1CC5 60 PUSH1 0x00 1CC7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1CC3 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1CC7 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1CC8: // Incoming jump from 0x1CBE, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1CCF stack[-6] // @1CE0 memory[0x40:0x60] // @1CF4 memory[0x40:0x60] // @1CFD address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // } 1CC8 5B JUMPDEST 1CC9 50 POP 1CCA 50 POP 1CCB 50 POP 1CCC 50 POP 1CCD 60 PUSH1 0x00 1CCF 82 DUP3 1CD0 60 PUSH1 0x01 1CD2 60 PUSH1 0x01 1CD4 60 PUSH1 0xa0 1CD6 1B SHL 1CD7 03 SUB 1CD8 16 AND 1CD9 63 PUSH4 0x7bd2bea7 1CDE 60 PUSH1 0x40 1CE0 51 MLOAD 1CE1 81 DUP2 1CE2 63 PUSH4 0xffffffff 1CE7 16 AND 1CE8 60 PUSH1 0xe0 1CEA 1B SHL 1CEB 81 DUP2 1CEC 52 MSTORE 1CED 60 PUSH1 0x04 1CEF 01 ADD 1CF0 60 PUSH1 0x20 1CF2 60 PUSH1 0x40 1CF4 51 MLOAD 1CF5 80 DUP1 1CF6 83 DUP4 1CF7 03 SUB 1CF8 81 DUP2 1CF9 60 PUSH1 0x00 1CFB 87 DUP8 1CFC 80 DUP1 1CFD 3B EXTCODESIZE 1CFE 15 ISZERO 1CFF 80 DUP1 1D00 15 ISZERO 1D01 61 PUSH2 0x1d09 1D04 57 *JUMPI // Stack delta = +7 // Outputs[12] // { // @1CCD stack[-4] = 0x00 // @1CD8 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1CD9 stack[-2] = 0x7bd2bea7 // @1CEC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x7bd2bea7) << 0xe0 // @1CEF stack[-1] = 0x04 + memory[0x40:0x60] // @1CF0 stack[0] = 0x20 // @1CF4 stack[1] = memory[0x40:0x60] // @1CF7 stack[2] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1CF8 stack[3] = memory[0x40:0x60] // @1CF9 stack[4] = 0x00 // @1CFB stack[5] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1CFE stack[6] = !address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // } // Block ends with conditional jump to 0x1d09, if !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length label_1D05: // Incoming jump from 0x1D04, if not !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // Inputs[1] { @1D08 memory[0x00:0x00] } 1D05 60 PUSH1 0x00 1D07 80 DUP1 1D08 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D08 revert(memory[0x00:0x00]); } // Block terminates label_1D09: // Incoming jump from 0x1D04, if !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // Inputs[9] // { // @1D0B msg.gas // @1D0C stack[-7] // @1D0C stack[-2] // @1D0C stack[-3] // @1D0C address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1D0C memory[stack[-4]:stack[-4] + stack[-5]] // @1D0C stack[-6] // @1D0C stack[-4] // @1D0C stack[-5] // } 1D09 5B JUMPDEST 1D0A 50 POP 1D0B 5A GAS 1D0C F1 CALL 1D0D 15 ISZERO 1D0E 80 DUP1 1D0F 15 ISZERO 1D10 61 PUSH2 0x1d1d 1D13 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1D0C memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1D0D stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1d1d, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1D14: // Incoming jump from 0x1D13, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1D14 returndata.length // @1D18 returndata[0x00:0x00 + returndata.length] // @1D19 returndata.length // @1D1C memory[0x00:0x00 + returndata.length] // } 1D14 3D RETURNDATASIZE 1D15 60 PUSH1 0x00 1D17 80 DUP1 1D18 3E RETURNDATACOPY 1D19 3D RETURNDATASIZE 1D1A 60 PUSH1 0x00 1D1C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D18 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1D1C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1D1D: // Incoming jump from 0x1D13, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1D24 memory[0x40:0x60] // @1D25 returndata.length // } 1D1D 5B JUMPDEST 1D1E 50 POP 1D1F 50 POP 1D20 50 POP 1D21 50 POP 1D22 60 PUSH1 0x40 1D24 51 MLOAD 1D25 3D RETURNDATASIZE 1D26 60 PUSH1 0x20 1D28 81 DUP2 1D29 10 LT 1D2A 15 ISZERO 1D2B 61 PUSH2 0x1d33 1D2E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1D24 stack[-4] = memory[0x40:0x60] // @1D25 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1d33, if !(returndata.length < 0x20) label_1D2F: // Incoming jump from 0x1D2E, if not !(returndata.length < 0x20) // Inputs[1] { @1D32 memory[0x00:0x00] } 1D2F 60 PUSH1 0x00 1D31 80 DUP1 1D32 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D32 revert(memory[0x00:0x00]); } // Block terminates label_1D33: // Incoming jump from 0x1D2E, if !(returndata.length < 0x20) // Inputs[3] // { // @1D35 memory[stack[-2]:stack[-2] + 0x20] // @1D35 stack[-2] // @1D36 stack[-3] // } 1D33 5B JUMPDEST 1D34 50 POP 1D35 51 MLOAD 1D36 90 SWAP1 1D37 50 POP 1D38 61 PUSH2 0x1d40 1D3B 81 DUP2 1D3C 61 PUSH2 0x3d1b 1D3F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1D36 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @1D38 stack[-2] = 0x1d40 // @1D3B stack[-1] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3d1b, returns to 0x1D40 label_1D40: // Incoming return from call to 0x3D1B at 0x1D3F // Inputs[1] { @1D41 stack[-1] } 1D40 5B JUMPDEST 1D41 15 ISZERO 1D42 61 PUSH2 0x1e0e 1D45 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e0e, if !stack[-1] label_1D46: // Incoming jump from 0x1D45, if not !stack[-1] // Inputs[6] // { // @1D49 memory[0x40:0x60] // @1D54 address(this) // @1D5E stack[-8] // @1D62 memory[0x40:0x60] // @1D6B stack[-3] // @1D87 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 1D46 60 PUSH1 0x40 1D48 80 DUP1 1D49 51 MLOAD 1D4A 63 PUSH4 0xef693bed 1D4F 60 PUSH1 0xe0 1D51 1B SHL 1D52 81 DUP2 1D53 52 MSTORE 1D54 30 ADDRESS 1D55 60 PUSH1 0x04 1D57 82 DUP3 1D58 01 ADD 1D59 52 MSTORE 1D5A 60 PUSH1 0x24 1D5C 81 DUP2 1D5D 01 ADD 1D5E 8A DUP11 1D5F 90 SWAP1 1D60 52 MSTORE 1D61 90 SWAP1 1D62 51 MLOAD 1D63 60 PUSH1 0x01 1D65 60 PUSH1 0x01 1D67 60 PUSH1 0xa0 1D69 1B SHL 1D6A 03 SUB 1D6B 85 DUP6 1D6C 16 AND 1D6D 91 SWAP2 1D6E 63 PUSH4 0xef693bed 1D73 91 SWAP2 1D74 60 PUSH1 0x44 1D76 80 DUP1 1D77 83 DUP4 1D78 01 ADD 1D79 92 SWAP3 1D7A 60 PUSH1 0x00 1D7C 92 SWAP3 1D7D 91 SWAP2 1D7E 90 SWAP1 1D7F 82 DUP3 1D80 90 SWAP1 1D81 03 SUB 1D82 01 ADD 1D83 81 DUP2 1D84 83 DUP4 1D85 87 DUP8 1D86 80 DUP1 1D87 3B EXTCODESIZE 1D88 15 ISZERO 1D89 80 DUP1 1D8A 15 ISZERO 1D8B 61 PUSH2 0x1d93 1D8E 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @1D53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xef693bed << 0xe0 // @1D59 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1D60 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-8] // @1D6D stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1D73 stack[1] = 0xef693bed // @1D79 stack[2] = memory[0x40:0x60] + 0x44 // @1D7C stack[3] = 0x00 // @1D7D stack[4] = memory[0x40:0x60] // @1D82 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @1D83 stack[6] = memory[0x40:0x60] // @1D84 stack[7] = 0x00 // @1D85 stack[8] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1D88 stack[9] = !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1d93, if !!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_1D8F: // Incoming jump from 0x1D8E, if not !!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1D92 memory[0x00:0x00] } 1D8F 60 PUSH1 0x00 1D91 80 DUP1 1D92 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D92 revert(memory[0x00:0x00]); } // Block terminates label_1D93: // Incoming jump from 0x1D8E, if !!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @1D95 msg.gas // @1D96 memory[stack[-4]:stack[-4] + stack[-5]] // @1D96 stack[-6] // @1D96 stack[-4] // @1D96 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1D96 stack[-2] // @1D96 stack[-5] // @1D96 stack[-3] // @1D96 stack[-7] // } 1D93 5B JUMPDEST 1D94 50 POP 1D95 5A GAS 1D96 F1 CALL 1D97 15 ISZERO 1D98 80 DUP1 1D99 15 ISZERO 1D9A 61 PUSH2 0x1da7 1D9D 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1D96 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1D97 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1da7, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1D9E: // Incoming jump from 0x1D9D, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1D9E returndata.length // @1DA2 returndata[0x00:0x00 + returndata.length] // @1DA3 returndata.length // @1DA6 memory[0x00:0x00 + returndata.length] // } 1D9E 3D RETURNDATASIZE 1D9F 60 PUSH1 0x00 1DA1 80 DUP1 1DA2 3E RETURNDATACOPY 1DA3 3D RETURNDATASIZE 1DA4 60 PUSH1 0x00 1DA6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1DA2 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1DA6 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1DA7: // Incoming jump from 0x1D9D, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[5] // { // @1DAC stack[-5] // @1DBB stack[-12] // @1DBE memory[0x40:0x60] // @1DDC memory[0x40:0x60] // @1DE5 address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } 1DA7 5B JUMPDEST 1DA8 50 POP 1DA9 50 POP 1DAA 50 POP 1DAB 50 POP 1DAC 80 DUP1 1DAD 60 PUSH1 0x01 1DAF 60 PUSH1 0x01 1DB1 60 PUSH1 0xa0 1DB3 1B SHL 1DB4 03 SUB 1DB5 16 AND 1DB6 63 PUSH4 0x2e1a7d4d 1DBB 89 DUP10 1DBC 60 PUSH1 0x40 1DBE 51 MLOAD 1DBF 82 DUP3 1DC0 63 PUSH4 0xffffffff 1DC5 16 AND 1DC6 60 PUSH1 0xe0 1DC8 1B SHL 1DC9 81 DUP2 1DCA 52 MSTORE 1DCB 60 PUSH1 0x04 1DCD 01 ADD 1DCE 80 DUP1 1DCF 82 DUP3 1DD0 81 DUP2 1DD1 52 MSTORE 1DD2 60 PUSH1 0x20 1DD4 01 ADD 1DD5 91 SWAP2 1DD6 50 POP 1DD7 50 POP 1DD8 60 PUSH1 0x00 1DDA 60 PUSH1 0x40 1DDC 51 MLOAD 1DDD 80 DUP1 1DDE 83 DUP4 1DDF 03 SUB 1DE0 81 DUP2 1DE1 60 PUSH1 0x00 1DE3 87 DUP8 1DE4 80 DUP1 1DE5 3B EXTCODESIZE 1DE6 15 ISZERO 1DE7 80 DUP1 1DE8 15 ISZERO 1DE9 61 PUSH2 0x1df1 1DEC 57 *JUMPI // Stack delta = +6 // Outputs[12] // { // @1DB5 stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1DB6 stack[-3] = 0x2e1a7d4d // @1DCA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2e1a7d4d) << 0xe0 // @1DD1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-12] // @1DD5 stack[-2] = 0x20 + 0x04 + memory[0x40:0x60] // @1DD8 stack[-1] = 0x00 // @1DDC stack[0] = memory[0x40:0x60] // @1DDF stack[1] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1DE0 stack[2] = memory[0x40:0x60] // @1DE1 stack[3] = 0x00 // @1DE3 stack[4] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1DE6 stack[5] = !address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } // Block ends with conditional jump to 0x1df1, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length label_1DED: // Incoming jump from 0x1DEC, if not !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[1] { @1DF0 memory[0x00:0x00] } 1DED 60 PUSH1 0x00 1DEF 80 DUP1 1DF0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DF0 revert(memory[0x00:0x00]); } // Block terminates label_1DF1: // Incoming jump from 0x1DEC, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[9] // { // @1DF3 msg.gas // @1DF4 stack[-7] // @1DF4 stack[-4] // @1DF4 stack[-6] // @1DF4 stack[-5] // @1DF4 stack[-2] // @1DF4 stack[-3] // @1DF4 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1DF4 memory[stack[-4]:stack[-4] + stack[-5]] // } 1DF1 5B JUMPDEST 1DF2 50 POP 1DF3 5A GAS 1DF4 F1 CALL 1DF5 15 ISZERO 1DF6 80 DUP1 1DF7 15 ISZERO 1DF8 61 PUSH2 0x1e05 1DFB 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1DF4 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1DF5 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1e05, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1DFC: // Incoming jump from 0x1DFB, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1DFC returndata.length // @1E00 returndata[0x00:0x00 + returndata.length] // @1E01 returndata.length // @1E04 memory[0x00:0x00 + returndata.length] // } 1DFC 3D RETURNDATASIZE 1DFD 60 PUSH1 0x00 1DFF 80 DUP1 1E00 3E RETURNDATACOPY 1E01 3D RETURNDATASIZE 1E02 60 PUSH1 0x00 1E04 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E00 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1E04 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1E05: // Incoming jump from 0x1DFB, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 1E05 5B JUMPDEST 1E06 50 POP 1E07 50 POP 1E08 50 POP 1E09 50 POP 1E0A 61 PUSH2 0x1e75 1E0D 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to 0x1e75 label_1E0E: // Incoming jump from 0x1D45, if !stack[-1] // Inputs[6] // { // @1E12 memory[0x40:0x60] // @1E1D address(this) // @1E27 stack[-8] // @1E2B memory[0x40:0x60] // @1E34 stack[-3] // @1E50 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 1E0E 5B JUMPDEST 1E0F 60 PUSH1 0x40 1E11 80 DUP1 1E12 51 MLOAD 1E13 63 PUSH4 0xef693bed 1E18 60 PUSH1 0xe0 1E1A 1B SHL 1E1B 81 DUP2 1E1C 52 MSTORE 1E1D 30 ADDRESS 1E1E 60 PUSH1 0x04 1E20 82 DUP3 1E21 01 ADD 1E22 52 MSTORE 1E23 60 PUSH1 0x24 1E25 81 DUP2 1E26 01 ADD 1E27 8A DUP11 1E28 90 SWAP1 1E29 52 MSTORE 1E2A 90 SWAP1 1E2B 51 MLOAD 1E2C 60 PUSH1 0x01 1E2E 60 PUSH1 0x01 1E30 60 PUSH1 0xa0 1E32 1B SHL 1E33 03 SUB 1E34 85 DUP6 1E35 16 AND 1E36 91 SWAP2 1E37 63 PUSH4 0xef693bed 1E3C 91 SWAP2 1E3D 60 PUSH1 0x44 1E3F 80 DUP1 1E40 83 DUP4 1E41 01 ADD 1E42 92 SWAP3 1E43 60 PUSH1 0x00 1E45 92 SWAP3 1E46 91 SWAP2 1E47 90 SWAP1 1E48 82 DUP3 1E49 90 SWAP1 1E4A 03 SUB 1E4B 01 ADD 1E4C 81 DUP2 1E4D 83 DUP4 1E4E 87 DUP8 1E4F 80 DUP1 1E50 3B EXTCODESIZE 1E51 15 ISZERO 1E52 80 DUP1 1E53 15 ISZERO 1E54 61 PUSH2 0x1e5c 1E57 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @1E1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xef693bed << 0xe0 // @1E22 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1E29 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-8] // @1E36 stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1E3C stack[1] = 0xef693bed // @1E42 stack[2] = memory[0x40:0x60] + 0x44 // @1E45 stack[3] = 0x00 // @1E46 stack[4] = memory[0x40:0x60] // @1E4B stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @1E4C stack[6] = memory[0x40:0x60] // @1E4D stack[7] = 0x00 // @1E4E stack[8] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1E51 stack[9] = !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1e5c, if !!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_1E58: // Incoming jump from 0x1E57, if not !!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1E5B memory[0x00:0x00] } 1E58 60 PUSH1 0x00 1E5A 80 DUP1 1E5B FD *REVERT // Stack delta = +0 // Outputs[1] { @1E5B revert(memory[0x00:0x00]); } // Block terminates label_1E5C: // Incoming jump from 0x1E57, if !!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @1E5E msg.gas // @1E5F stack[-4] // @1E5F stack[-2] // @1E5F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1E5F stack[-6] // @1E5F stack[-7] // @1E5F stack[-5] // @1E5F memory[stack[-4]:stack[-4] + stack[-5]] // @1E5F stack[-3] // } 1E5C 5B JUMPDEST 1E5D 50 POP 1E5E 5A GAS 1E5F F1 CALL 1E60 15 ISZERO 1E61 80 DUP1 1E62 15 ISZERO 1E63 61 PUSH2 0x1e70 1E66 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1E5F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1E60 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1e70, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1E67: // Incoming jump from 0x1E66, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1E67 returndata.length // @1E6B returndata[0x00:0x00 + returndata.length] // @1E6C returndata.length // @1E6F memory[0x00:0x00 + returndata.length] // } 1E67 3D RETURNDATASIZE 1E68 60 PUSH1 0x00 1E6A 80 DUP1 1E6B 3E RETURNDATACOPY 1E6C 3D RETURNDATASIZE 1E6D 60 PUSH1 0x00 1E6F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E6B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1E6F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1E70: // Incoming jump from 0x1E66, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1E79 stack[-15] // @1E7A stack[-12] // } 1E70 5B JUMPDEST 1E71 50 POP 1E72 50 POP 1E73 50 POP 1E74 50 POP 1E75 5B JUMPDEST 1E76 61 PUSH2 0x1e7f 1E79 8B DUP12 1E7A 89 DUP10 1E7B 61 PUSH2 0x3b0e 1E7E 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1E76 stack[-4] = 0x1e7f // @1E79 stack[-3] = stack[-15] // @1E7A stack[-2] = stack[-12] // } // Block ends with call to 0x3b0e, returns to 0x1E7F label_1E7F: // Incoming return from call to 0x3B0E at 0x1E7E // Incoming return from call to 0x3B0E at 0x1E7E // Inputs[13] // { // @1E82 memory[0x40:0x60] // @1E9C memory[0x40:0x60] // @1EA1 stack[-7] // @1EA8 stack[-6] // @1EB0 stack[-8] // @1EBC stack[-12] // @1EBD stack[-5] // @1EC5 stack[-11] // @1ECA memory[0x40:0x60] // @1EDA stack[-15] // @1EDC stack[-14] // @1EDE stack[-9] // @1EDF stack[-13] // } 1E7F 5B JUMPDEST 1E80 60 PUSH1 0x40 1E82 51 MLOAD 1E83 80 DUP1 1E84 60 PUSH1 0x60 1E86 01 ADD 1E87 60 PUSH1 0x40 1E89 52 MSTORE 1E8A 80 DUP1 1E8B 60 PUSH1 0x34 1E8D 81 DUP2 1E8E 52 MSTORE 1E8F 60 PUSH1 0x20 1E91 01 ADD 1E92 61 PUSH2 0x425f 1E95 60 PUSH1 0x34 1E97 91 SWAP2 1E98 39 CODECOPY 1E99 60 PUSH1 0x40 1E9B 80 DUP1 1E9C 51 MLOAD 1E9D 60 PUSH1 0x20 1E9F 81 DUP2 1EA0 01 ADD 1EA1 99 SWAP10 1EA2 90 SWAP1 1EA3 99 SWAP10 1EA4 52 MSTORE 1EA5 88 DUP9 1EA6 81 DUP2 1EA7 01 ADD 1EA8 97 SWAP8 1EA9 90 SWAP1 1EAA 97 SWAP8 1EAB 52 MSTORE 1EAC 60 PUSH1 0x60 1EAE 88 DUP9 1EAF 01 ADD 1EB0 98 SWAP9 1EB1 90 SWAP1 1EB2 98 SWAP9 1EB3 52 MSTORE 1EB4 50 POP 1EB5 50 POP 1EB6 50 POP 1EB7 50 POP 1EB8 60 PUSH1 0x80 1EBA 83 DUP4 1EBB 01 ADD 1EBC 97 SWAP8 1EBD 90 SWAP1 1EBE 97 SWAP8 1EBF 52 MSTORE 1EC0 60 PUSH1 0xa0 1EC2 80 DUP1 1EC3 83 DUP4 1EC4 01 ADD 1EC5 96 SWAP7 1EC6 90 SWAP1 1EC7 96 SWAP7 1EC8 52 MSTORE 1EC9 80 DUP1 1ECA 51 MLOAD 1ECB 80 DUP1 1ECC 83 DUP4 1ECD 03 SUB 1ECE 90 SWAP1 1ECF 96 SWAP7 1ED0 01 ADD 1ED1 86 DUP7 1ED2 52 MSTORE 1ED3 60 PUSH1 0xc0 1ED5 90 SWAP1 1ED6 91 SWAP2 1ED7 01 ADD 1ED8 90 SWAP1 1ED9 52 MSTORE 1EDA 96 SWAP7 1EDB 92 SWAP3 1EDC 95 SWAP6 1EDD 50 POP 1EDE 91 SWAP2 1EDF 93 SWAP4 1EE0 50 POP 1EE1 50 POP 1EE2 50 POP 1EE3 50 POP 1EE4 56 *JUMP // Stack delta = -13 // Outputs[12] // { // @1E89 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @1E8E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x34 // @1E98 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x34] = code[0x425f:0x4293] // @1EA4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-7] // @1EAB memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-6] // @1EB3 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-8] // @1EBF memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-12] // @1EC8 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-11] // @1ED2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1ED9 memory[0x40:0x60] = memory[0x40:0x60] + 0xc0 // @1EDA stack[-15] = memory[0x40:0x60] // @1EDC stack[-14] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-15] label_1EE5: // Incoming jump from 0x0371 1EE5 5B JUMPDEST 1EE6 60 PUSH1 0x60 1EE8 80 DUP1 1EE9 61 PUSH2 0x1ef0 1EEC 61 PUSH2 0x41d9 1EEF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1EE6 stack[0] = 0x60 // @1EE8 stack[1] = 0x60 // @1EE9 stack[2] = 0x1ef0 // } // Block ends with call to 0x41d9, returns to 0x1EF0 label_1EF0: // Incoming return from call to 0x41D9 at 0x1EEF // Inputs[2] // { // @1EF6 stack[-7] // @1EF7 stack[-9] // } 1EF0 5B JUMPDEST 1EF1 60 PUSH1 0x00 1EF3 61 PUSH2 0x1efc 1EF6 88 DUP9 1EF7 8B DUP12 1EF8 61 PUSH2 0x3a55 1EFB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EF1 stack[0] = 0x00 // @1EF3 stack[1] = 0x1efc // @1EF6 stack[2] = stack[-7] // @1EF7 stack[3] = stack[-9] // } // Block ends with call to 0x3a55, returns to 0x1EFC label_1EFC: // Incoming return from call to 0x3A55 at 0x1EFB // Inputs[4] // { // @1EFD stack[-2] // @1EFD stack[-1] // @1F04 stack[-8] // @1F05 stack[-10] // } 1EFC 5B JUMPDEST 1EFD 90 SWAP1 1EFE 50 POP 1EFF 60 PUSH1 0x00 1F01 61 PUSH2 0x1f0a 1F04 88 DUP9 1F05 8B DUP12 1F06 61 PUSH2 0x3a55 1F09 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1EFD stack[-2] = stack[-1] // @1EFF stack[-1] = 0x00 // @1F01 stack[0] = 0x1f0a // @1F04 stack[1] = stack[-8] // @1F05 stack[2] = stack[-10] // } // Block ends with call to 0x3a55, returns to 0x1F0A label_1F0A: // Incoming return from call to 0x3A55 at 0x1F09 // Inputs[3] // { // @1F0B stack[-2] // @1F0B stack[-1] // @1F10 stack[-13] // } 1F0A 5B JUMPDEST 1F0B 90 SWAP1 1F0C 50 POP 1F0D 61 PUSH2 0x1f15 1F10 8C DUP13 1F11 61 PUSH2 0x3804 1F14 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F0B stack[-2] = stack[-1] // @1F0D stack[-1] = 0x1f15 // @1F10 stack[0] = stack[-13] // } // Block ends with call to 0x3804, returns to 0x1F15 label_1F15: // Incoming return from call to 0x3804 at 0x1F14 // Inputs[2] // { // @1F16 stack[-1] // @1F17 stack[-4] // } 1F15 5B JUMPDEST 1F16 80 DUP1 1F17 84 DUP5 1F18 52 MSTORE 1F19 60 PUSH1 0x00 1F1B 90 SWAP1 1F1C 81 DUP2 1F1D 90 SWAP1 1F1E 61 PUSH2 0x1f26 1F21 90 SWAP1 1F22 61 PUSH2 0x3950 1F25 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1F18 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @1F1B stack[-1] = 0x00 // @1F1D stack[0] = 0x00 // @1F21 stack[2] = stack[-1] // @1F21 stack[1] = 0x1f26 // } // Block ends with call to 0x3950, returns to 0x1F26 label_1F26: // Incoming return from call to 0x3950 at 0x1F25 // Inputs[7] // { // @1F27 stack[-1] // @1F27 stack[-3] // @1F29 stack[-4] // @1F29 stack[-2] // @1F51 memory[0x40:0x60] // @1F6F memory[0x40:0x60] // @1F76 address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } 1F26 5B JUMPDEST 1F27 91 SWAP2 1F28 50 POP 1F29 91 SWAP2 1F2A 50 POP 1F2B 73 PUSH20 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 1F40 60 PUSH1 0x01 1F42 60 PUSH1 0x01 1F44 60 PUSH1 0xa0 1F46 1B SHL 1F47 03 SUB 1F48 16 AND 1F49 63 PUSH4 0x4445d799 1F4E 83 DUP4 1F4F 60 PUSH1 0x40 1F51 51 MLOAD 1F52 82 DUP3 1F53 63 PUSH4 0xffffffff 1F58 16 AND 1F59 60 PUSH1 0xe0 1F5B 1B SHL 1F5C 81 DUP2 1F5D 52 MSTORE 1F5E 60 PUSH1 0x04 1F60 01 ADD 1F61 80 DUP1 1F62 82 DUP3 1F63 81 DUP2 1F64 52 MSTORE 1F65 60 PUSH1 0x20 1F67 01 ADD 1F68 91 SWAP2 1F69 50 POP 1F6A 50 POP 1F6B 60 PUSH1 0x20 1F6D 60 PUSH1 0x40 1F6F 51 MLOAD 1F70 80 DUP1 1F71 83 DUP4 1F72 03 SUB 1F73 81 DUP2 1F74 86 DUP7 1F75 80 DUP1 1F76 3B EXTCODESIZE 1F77 15 ISZERO 1F78 80 DUP1 1F79 15 ISZERO 1F7A 61 PUSH2 0x1f82 1F7D 57 *JUMPI // Stack delta = +7 // Outputs[13] // { // @1F27 stack[-3] = stack[-1] // @1F29 stack[-4] = stack[-2] // @1F48 stack[-2] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @1F49 stack[-1] = 0x4445d799 // @1F5D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x4445d799) << 0xe0 // @1F64 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @1F68 stack[0] = 0x20 + 0x04 + memory[0x40:0x60] // @1F6B stack[1] = 0x20 // @1F6F stack[2] = memory[0x40:0x60] // @1F72 stack[3] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1F73 stack[4] = memory[0x40:0x60] // @1F74 stack[5] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @1F77 stack[6] = !address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } // Block ends with conditional jump to 0x1f82, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length label_1F7E: // Incoming jump from 0x1F7D, if not !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[1] { @1F81 memory[0x00:0x00] } 1F7E 60 PUSH1 0x00 1F80 80 DUP1 1F81 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F81 revert(memory[0x00:0x00]); } // Block terminates label_1F82: // Incoming jump from 0x1F7D, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[8] // { // @1F84 msg.gas // @1F85 stack[-4] // @1F85 stack[-2] // @1F85 memory[stack[-3]:stack[-3] + stack[-4]] // @1F85 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1F85 stack[-6] // @1F85 stack[-5] // @1F85 stack[-3] // } 1F82 5B JUMPDEST 1F83 50 POP 1F84 5A GAS 1F85 FA STATICCALL 1F86 15 ISZERO 1F87 80 DUP1 1F88 15 ISZERO 1F89 61 PUSH2 0x1f96 1F8C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1F85 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1F86 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1f96, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1F8D: // Incoming jump from 0x1F8C, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1F8D returndata.length // @1F91 returndata[0x00:0x00 + returndata.length] // @1F92 returndata.length // @1F95 memory[0x00:0x00 + returndata.length] // } 1F8D 3D RETURNDATASIZE 1F8E 60 PUSH1 0x00 1F90 80 DUP1 1F91 3E RETURNDATACOPY 1F92 3D RETURNDATASIZE 1F93 60 PUSH1 0x00 1F95 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1F91 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1F95 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1F96: // Incoming jump from 0x1F8C, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1F9D memory[0x40:0x60] // @1F9E returndata.length // } 1F96 5B JUMPDEST 1F97 50 POP 1F98 50 POP 1F99 50 POP 1F9A 50 POP 1F9B 60 PUSH1 0x40 1F9D 51 MLOAD 1F9E 3D RETURNDATASIZE 1F9F 60 PUSH1 0x20 1FA1 81 DUP2 1FA2 10 LT 1FA3 15 ISZERO 1FA4 61 PUSH2 0x1fac 1FA7 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1F9D stack[-4] = memory[0x40:0x60] // @1F9E stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1fac, if !(returndata.length < 0x20) label_1FA8: // Incoming jump from 0x1FA7, if not !(returndata.length < 0x20) // Inputs[1] { @1FAB memory[0x00:0x00] } 1FA8 60 PUSH1 0x00 1FAA 80 DUP1 1FAB FD *REVERT // Stack delta = +0 // Outputs[1] { @1FAB revert(memory[0x00:0x00]); } // Block terminates label_1FAC: // Incoming jump from 0x1FA7, if !(returndata.length < 0x20) // Inputs[8] // { // @1FAE stack[-2] // @1FAE memory[stack[-2]:stack[-2] + 0x20] // @1FBA stack[-7] // @1FCA memory[0x40:0x60] // @1FD6 memory[0x40:0x60] // @1FDA memory[0x00:0x20] // @1FE3 memory[0x00:0x20] // @1FFC address(memory[0x00:0x20]).code.length // } 1FAC 5B JUMPDEST 1FAD 50 POP 1FAE 51 MLOAD 1FAF 60 PUSH1 0x01 1FB1 60 PUSH1 0x01 1FB3 60 PUSH1 0xa0 1FB5 1B SHL 1FB6 03 SUB 1FB7 16 AND 1FB8 60 PUSH1 0x20 1FBA 86 DUP7 1FBB 81 DUP2 1FBC 01 ADD 1FBD 82 DUP3 1FBE 90 SWAP1 1FBF 52 MSTORE 1FC0 60 PUSH1 0x40 1FC2 80 DUP1 1FC3 88 DUP9 1FC4 01 ADD 1FC5 92 SWAP3 1FC6 90 SWAP1 1FC7 92 SWAP3 1FC8 52 MSTORE 1FC9 81 DUP2 1FCA 51 MLOAD 1FCB 63 PUSH4 0x36569e77 1FD0 60 PUSH1 0xe0 1FD2 1B SHL 1FD3 81 DUP2 1FD4 52 MSTORE 1FD5 91 SWAP2 1FD6 51 MLOAD 1FD7 60 PUSH1 0x00 1FD9 80 DUP1 1FDA 51 MLOAD 1FDB 60 PUSH1 0x20 1FDD 61 PUSH2 0x4418 1FE0 83 DUP4 1FE1 39 CODECOPY 1FE2 81 DUP2 1FE3 51 MLOAD 1FE4 91 SWAP2 1FE5 52 MSTORE 1FE6 92 SWAP3 1FE7 63 PUSH4 0x36569e77 1FEC 92 SWAP3 1FED 60 PUSH1 0x04 1FEF 80 DUP1 1FF0 83 DUP4 1FF1 01 ADD 1FF2 93 SWAP4 1FF3 91 SWAP2 1FF4 92 SWAP3 1FF5 82 DUP3 1FF6 90 SWAP1 1FF7 03 SUB 1FF8 01 ADD 1FF9 81 DUP2 1FFA 86 DUP7 1FFB 80 DUP1 1FFC 3B EXTCODESIZE 1FFD 15 ISZERO 1FFE 80 DUP1 1FFF 15 ISZERO 2000 61 PUSH2 0x2008 2003 57 *JUMPI // Stack delta = +7 // Outputs[14] // { // @1FBF memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @1FC8 memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @1FD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x36569e77 << 0xe0 // @1FE1 memory[0x00:0x20] = code[0x4418:0x4438] // @1FE5 memory[0x00:0x20] = memory[0x00:0x20] // @1FE6 stack[-2] = memory[0x00:0x20] // @1FEC stack[-1] = 0x36569e77 // @1FF2 stack[0] = memory[0x40:0x60] + 0x04 // @1FF3 stack[2] = memory[0x40:0x60] // @1FF4 stack[1] = 0x20 // @1FF8 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @1FF9 stack[4] = memory[0x40:0x60] // @1FFA stack[5] = memory[0x00:0x20] // @1FFD stack[6] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x2008, if !!address(memory[0x00:0x20]).code.length label_2004: // Incoming jump from 0x2003, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @2007 memory[0x00:0x00] } 2004 60 PUSH1 0x00 2006 80 DUP1 2007 FD *REVERT // Stack delta = +0 // Outputs[1] { @2007 revert(memory[0x00:0x00]); } // Block terminates label_2008: // Incoming jump from 0x2003, if !!address(memory[0x00:0x20]).code.length // Inputs[8] // { // @200A msg.gas // @200B stack[-4] // @200B stack[-2] // @200B stack[-5] // @200B stack[-6] // @200B memory[stack[-3]:stack[-3] + stack[-4]] // @200B stack[-3] // @200B address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 2008 5B JUMPDEST 2009 50 POP 200A 5A GAS 200B FA STATICCALL 200C 15 ISZERO 200D 80 DUP1 200E 15 ISZERO 200F 61 PUSH2 0x201c 2012 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @200B memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @200C stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x201c, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2013: // Incoming jump from 0x2012, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2013 returndata.length // @2017 returndata[0x00:0x00 + returndata.length] // @2018 returndata.length // @201B memory[0x00:0x00 + returndata.length] // } 2013 3D RETURNDATASIZE 2014 60 PUSH1 0x00 2016 80 DUP1 2017 3E RETURNDATACOPY 2018 3D RETURNDATASIZE 2019 60 PUSH1 0x00 201B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2017 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @201B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_201C: // Incoming jump from 0x2012, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2023 memory[0x40:0x60] // @2024 returndata.length // } 201C 5B JUMPDEST 201D 50 POP 201E 50 POP 201F 50 POP 2020 50 POP 2021 60 PUSH1 0x40 2023 51 MLOAD 2024 3D RETURNDATASIZE 2025 60 PUSH1 0x20 2027 81 DUP2 2028 10 LT 2029 15 ISZERO 202A 61 PUSH2 0x2032 202D 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2023 stack[-4] = memory[0x40:0x60] // @2024 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2032, if !(returndata.length < 0x20) label_202E: // Incoming jump from 0x202D, if not !(returndata.length < 0x20) // Inputs[1] { @2031 memory[0x00:0x00] } 202E 60 PUSH1 0x00 2030 80 DUP1 2031 FD *REVERT // Stack delta = +0 // Outputs[1] { @2031 revert(memory[0x00:0x00]); } // Block terminates label_2032: // Incoming jump from 0x202D, if !(returndata.length < 0x20) // Inputs[7] // { // @2034 stack[-2] // @2034 memory[stack[-2]:stack[-2] + 0x20] // @2042 stack[-7] // @204A memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @204C memory[0x40:0x60] // @2058 memory[0x40:0x60] // @2077 address((0x01 << 0xa0) - 0x01 & memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20]).code.length // } 2032 5B JUMPDEST 2033 50 POP 2034 51 MLOAD 2035 60 PUSH1 0x01 2037 60 PUSH1 0x01 2039 60 PUSH1 0xa0 203B 1B SHL 203C 03 SUB 203D 90 SWAP1 203E 81 DUP2 203F 16 AND 2040 60 PUSH1 0x60 2042 87 DUP8 2043 01 ADD 2044 52 MSTORE 2045 60 PUSH1 0x40 2047 80 DUP1 2048 87 DUP8 2049 01 ADD 204A 51 MLOAD 204B 81 DUP2 204C 51 MLOAD 204D 63 PUSH4 0x7bd2bea7 2052 60 PUSH1 0xe0 2054 1B SHL 2055 81 DUP2 2056 52 MSTORE 2057 91 SWAP2 2058 51 MLOAD 2059 92 SWAP3 205A 16 AND 205B 91 SWAP2 205C 63 PUSH4 0x7bd2bea7 2061 91 SWAP2 2062 60 PUSH1 0x04 2064 80 DUP1 2065 82 DUP3 2066 01 ADD 2067 92 SWAP3 2068 60 PUSH1 0x20 206A 92 SWAP3 206B 90 SWAP1 206C 91 SWAP2 206D 90 SWAP1 206E 82 DUP3 206F 90 SWAP1 2070 03 SUB 2071 01 ADD 2072 81 DUP2 2073 60 PUSH1 0x00 2075 87 DUP8 2076 80 DUP1 2077 3B EXTCODESIZE 2078 15 ISZERO 2079 80 DUP1 207A 15 ISZERO 207B 61 PUSH2 0x2083 207E 57 *JUMPI // Stack delta = +8 // Outputs[12] // { // @2044 memory[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @2056 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7bd2bea7 << 0xe0 // @205B stack[-2] = (0x01 << 0xa0) - 0x01 & memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2061 stack[-1] = 0x7bd2bea7 // @2067 stack[0] = memory[0x40:0x60] + 0x04 // @206A stack[1] = 0x20 // @206C stack[2] = memory[0x40:0x60] // @2071 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @2072 stack[4] = memory[0x40:0x60] // @2073 stack[5] = 0x00 // @2075 stack[6] = (0x01 << 0xa0) - 0x01 & memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2078 stack[7] = !address((0x01 << 0xa0) - 0x01 & memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20]).code.length // } // Block ends with conditional jump to 0x2083, if !!address((0x01 << 0xa0) - 0x01 & memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20]).code.length label_207F: // Incoming jump from 0x207E, if not !!address((0x01 << 0xa0) - 0x01 & memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20]).code.length // Inputs[1] { @2082 memory[0x00:0x00] } 207F 60 PUSH1 0x00 2081 80 DUP1 2082 FD *REVERT // Stack delta = +0 // Outputs[1] { @2082 revert(memory[0x00:0x00]); } // Block terminates label_2083: // Incoming jump from 0x207E, if !!address((0x01 << 0xa0) - 0x01 & memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20]).code.length // Inputs[9] // { // @2085 msg.gas // @2086 stack[-2] // @2086 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2086 stack[-3] // @2086 stack[-5] // @2086 stack[-4] // @2086 stack[-6] // @2086 memory[stack[-4]:stack[-4] + stack[-5]] // @2086 stack[-7] // } 2083 5B JUMPDEST 2084 50 POP 2085 5A GAS 2086 F1 CALL 2087 15 ISZERO 2088 80 DUP1 2089 15 ISZERO 208A 61 PUSH2 0x2097 208D 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2086 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2087 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2097, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_208E: // Incoming jump from 0x208D, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @208E returndata.length // @2092 returndata[0x00:0x00 + returndata.length] // @2093 returndata.length // @2096 memory[0x00:0x00 + returndata.length] // } 208E 3D RETURNDATASIZE 208F 60 PUSH1 0x00 2091 80 DUP1 2092 3E RETURNDATACOPY 2093 3D RETURNDATASIZE 2094 60 PUSH1 0x00 2096 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2092 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2096 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2097: // Incoming jump from 0x208D, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @209E memory[0x40:0x60] // @209F returndata.length // } 2097 5B JUMPDEST 2098 50 POP 2099 50 POP 209A 50 POP 209B 50 POP 209C 60 PUSH1 0x40 209E 51 MLOAD 209F 3D RETURNDATASIZE 20A0 60 PUSH1 0x20 20A2 81 DUP2 20A3 10 LT 20A4 15 ISZERO 20A5 61 PUSH2 0x20ad 20A8 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @209E stack[-4] = memory[0x40:0x60] // @209F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x20ad, if !(returndata.length < 0x20) label_20A9: // Incoming jump from 0x20A8, if not !(returndata.length < 0x20) // Inputs[1] { @20AC memory[0x00:0x00] } 20A9 60 PUSH1 0x00 20AB 80 DUP1 20AC FD *REVERT // Stack delta = +0 // Outputs[1] { @20AC revert(memory[0x00:0x00]); } // Block terminates label_20AD: // Incoming jump from 0x20A8, if !(returndata.length < 0x20) // Inputs[3] // { // @20AF stack[-2] // @20AF memory[stack[-2]:stack[-2] + 0x20] // @20BB stack[-7] // } 20AD 5B JUMPDEST 20AE 50 POP 20AF 51 MLOAD 20B0 60 PUSH1 0x01 20B2 60 PUSH1 0x01 20B4 60 PUSH1 0xa0 20B6 1B SHL 20B7 03 SUB 20B8 16 AND 20B9 60 PUSH1 0x80 20BB 86 DUP7 20BC 01 ADD 20BD 81 DUP2 20BE 90 SWAP1 20BF 52 MSTORE 20C0 61 PUSH2 0x20c8 20C3 90 SWAP1 20C4 61 PUSH2 0x3d1b 20C7 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @20BF memory[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @20C3 stack[-2] = 0x20c8 // @20C3 stack[-1] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3d1b, returns to 0x20C8 label_20C8: // Incoming return from call to 0x3D1B at 0x20C7 // Inputs[1] { @20C9 stack[-1] } 20C8 5B JUMPDEST 20C9 15 ISZERO 20CA 61 PUSH2 0x213d 20CD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x213d, if !stack[-1] label_20CE: // Incoming jump from 0x20CD, if not !stack[-1] // Inputs[1] { @20D1 stack[-4] } 20CE 60 PUSH1 0x00 20D0 19 NOT 20D1 84 DUP5 20D2 14 EQ 20D3 61 PUSH2 0x20dc 20D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20dc, if stack[-4] == ~0x00 label_20D7: // Incoming jump from 0x20D6, if not stack[-4] == ~0x00 // Inputs[1] { @20D7 stack[-4] } 20D7 83 DUP4 20D8 61 PUSH2 0x20de 20DB 56 *JUMP // Stack delta = +1 // Outputs[1] { @20D7 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x20de label_20DC: // Incoming jump from 0x20D6, if stack[-4] == ~0x00 // Inputs[8] // { // @20DD address(this).balance // @20DD address(this) // @20DF stack[-4] // @20E1 stack[-5] // @20E5 memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20] // @20F7 memory[0x40:0x60] // @210B memory[0x40:0x60] // @2113 address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // } 20DC 5B JUMPDEST 20DD 47 SELFBALANCE 20DE 5B JUMPDEST 20DF 93 SWAP4 20E0 50 POP 20E1 84 DUP5 20E2 60 PUSH1 0x80 20E4 01 ADD 20E5 51 MLOAD 20E6 60 PUSH1 0x01 20E8 60 PUSH1 0x01 20EA 60 PUSH1 0xa0 20EC 1B SHL 20ED 03 SUB 20EE 16 AND 20EF 63 PUSH4 0xd0e30db0 20F4 85 DUP6 20F5 60 PUSH1 0x40 20F7 51 MLOAD 20F8 82 DUP3 20F9 63 PUSH4 0xffffffff 20FE 16 AND 20FF 60 PUSH1 0xe0 2101 1B SHL 2102 81 DUP2 2103 52 MSTORE 2104 60 PUSH1 0x04 2106 01 ADD 2107 60 PUSH1 0x00 2109 60 PUSH1 0x40 210B 51 MLOAD 210C 80 DUP1 210D 83 DUP4 210E 03 SUB 210F 81 DUP2 2110 85 DUP6 2111 88 DUP9 2112 80 DUP1 2113 3B EXTCODESIZE 2114 15 ISZERO 2115 80 DUP1 2116 15 ISZERO 2117 61 PUSH2 0x211f 211A 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @20DF stack[-4] = address(this).balance // @20EE stack[0] = (0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20] // @20EF stack[1] = 0xd0e30db0 // @20F4 stack[2] = address(this).balance // @2103 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd0e30db0) << 0xe0 // @2106 stack[3] = 0x04 + memory[0x40:0x60] // @2107 stack[4] = 0x00 // @210B stack[5] = memory[0x40:0x60] // @210E stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @210F stack[7] = memory[0x40:0x60] // @2110 stack[8] = address(this).balance // @2111 stack[9] = (0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20] // @2114 stack[10] = !address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // } // Block ends with conditional jump to 0x211f, if !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length label_211B: // Incoming jump from 0x211A, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20]).code.length // Incoming jump from 0x211A, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // Inputs[1] { @211E memory[0x00:0x00] } 211B 60 PUSH1 0x00 211D 80 DUP1 211E FD *REVERT // Stack delta = +0 // Outputs[1] { @211E revert(memory[0x00:0x00]); } // Block terminates label_211F: // Incoming jump from 0x211A, if !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20]).code.length // Incoming jump from 0x211A, if !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // Inputs[9] // { // @2121 msg.gas // @2122 stack[-2] // @2122 stack[-5] // @2122 stack[-7] // @2122 memory[stack[-4]:stack[-4] + stack[-5]] // @2122 stack[-6] // @2122 stack[-4] // @2122 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2122 stack[-3] // } 211F 5B JUMPDEST 2120 50 POP 2121 5A GAS 2122 F1 CALL 2123 15 ISZERO 2124 80 DUP1 2125 15 ISZERO 2126 61 PUSH2 0x2133 2129 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2122 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2123 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2133, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_212A: // Incoming jump from 0x2129, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @212A returndata.length // @212E returndata[0x00:0x00 + returndata.length] // @212F returndata.length // @2132 memory[0x00:0x00 + returndata.length] // } 212A 3D RETURNDATASIZE 212B 60 PUSH1 0x00 212D 80 DUP1 212E 3E RETURNDATACOPY 212F 3D RETURNDATASIZE 2130 60 PUSH1 0x00 2132 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @212E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2132 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2133: // Incoming jump from 0x2129, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 2133 5B JUMPDEST 2134 50 POP 2135 50 POP 2136 50 POP 2137 50 POP 2138 50 POP 2139 61 PUSH2 0x21cd 213C 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to 0x21cd label_213D: // Incoming jump from 0x20CD, if !stack[-1] // Inputs[1] { @2141 stack[-4] } 213D 5B JUMPDEST 213E 60 PUSH1 0x00 2140 19 NOT 2141 84 DUP5 2142 14 EQ 2143 61 PUSH2 0x214c 2146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x214c, if stack[-4] == ~0x00 label_2147: // Incoming jump from 0x2146, if not stack[-4] == ~0x00 // Inputs[1] { @2147 stack[-4] } 2147 83 DUP4 2148 61 PUSH2 0x21ca 214B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2147 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x21ca label_214C: // Incoming jump from 0x2146, if stack[-4] == ~0x00 // Inputs[6] // { // @214D stack[-5] // @2151 memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20] // @2160 address(this) // @2163 memory[0x40:0x60] // @218A memory[0x40:0x60] // @2191 address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // } 214C 5B JUMPDEST 214D 84 DUP5 214E 60 PUSH1 0x80 2150 01 ADD 2151 51 MLOAD 2152 60 PUSH1 0x01 2154 60 PUSH1 0x01 2156 60 PUSH1 0xa0 2158 1B SHL 2159 03 SUB 215A 16 AND 215B 63 PUSH4 0x70a08231 2160 30 ADDRESS 2161 60 PUSH1 0x40 2163 51 MLOAD 2164 82 DUP3 2165 63 PUSH4 0xffffffff 216A 16 AND 216B 60 PUSH1 0xe0 216D 1B SHL 216E 81 DUP2 216F 52 MSTORE 2170 60 PUSH1 0x04 2172 01 ADD 2173 80 DUP1 2174 82 DUP3 2175 60 PUSH1 0x01 2177 60 PUSH1 0x01 2179 60 PUSH1 0xa0 217B 1B SHL 217C 03 SUB 217D 16 AND 217E 81 DUP2 217F 52 MSTORE 2180 60 PUSH1 0x20 2182 01 ADD 2183 91 SWAP2 2184 50 POP 2185 50 POP 2186 60 PUSH1 0x20 2188 60 PUSH1 0x40 218A 51 MLOAD 218B 80 DUP1 218C 83 DUP4 218D 03 SUB 218E 81 DUP2 218F 86 DUP7 2190 80 DUP1 2191 3B EXTCODESIZE 2192 15 ISZERO 2193 80 DUP1 2194 15 ISZERO 2195 61 PUSH2 0x219d 2198 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @215A stack[0] = (0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20] // @215B stack[1] = 0x70a08231 // @216F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @217F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & address(this) // @2183 stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @2186 stack[3] = 0x20 // @218A stack[4] = memory[0x40:0x60] // @218D stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @218E stack[6] = memory[0x40:0x60] // @218F stack[7] = (0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20] // @2192 stack[8] = !address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // } // Block ends with conditional jump to 0x219d, if !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length label_2199: // Incoming jump from 0x2198, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // Inputs[1] { @219C memory[0x00:0x00] } 2199 60 PUSH1 0x00 219B 80 DUP1 219C FD *REVERT // Stack delta = +0 // Outputs[1] { @219C revert(memory[0x00:0x00]); } // Block terminates label_219D: // Incoming jump from 0x2198, if !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // Inputs[8] // { // @219F msg.gas // @21A0 memory[stack[-3]:stack[-3] + stack[-4]] // @21A0 stack[-2] // @21A0 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @21A0 stack[-3] // @21A0 stack[-5] // @21A0 stack[-6] // @21A0 stack[-4] // } 219D 5B JUMPDEST 219E 50 POP 219F 5A GAS 21A0 FA STATICCALL 21A1 15 ISZERO 21A2 80 DUP1 21A3 15 ISZERO 21A4 61 PUSH2 0x21b1 21A7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @21A0 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @21A1 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x21b1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_21A8: // Incoming jump from 0x21A7, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @21A8 returndata.length // @21AC returndata[0x00:0x00 + returndata.length] // @21AD returndata.length // @21B0 memory[0x00:0x00 + returndata.length] // } 21A8 3D RETURNDATASIZE 21A9 60 PUSH1 0x00 21AB 80 DUP1 21AC 3E RETURNDATACOPY 21AD 3D RETURNDATASIZE 21AE 60 PUSH1 0x00 21B0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @21AC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @21B0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_21B1: // Incoming jump from 0x21A7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @21B8 memory[0x40:0x60] // @21B9 returndata.length // } 21B1 5B JUMPDEST 21B2 50 POP 21B3 50 POP 21B4 50 POP 21B5 50 POP 21B6 60 PUSH1 0x40 21B8 51 MLOAD 21B9 3D RETURNDATASIZE 21BA 60 PUSH1 0x20 21BC 81 DUP2 21BD 10 LT 21BE 15 ISZERO 21BF 61 PUSH2 0x21c7 21C2 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @21B8 stack[-4] = memory[0x40:0x60] // @21B9 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x21c7, if !(returndata.length < 0x20) label_21C3: // Incoming jump from 0x21C2, if not !(returndata.length < 0x20) // Inputs[1] { @21C6 memory[0x00:0x00] } 21C3 60 PUSH1 0x00 21C5 80 DUP1 21C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @21C6 revert(memory[0x00:0x00]); } // Block terminates label_21C7: // Incoming jump from 0x21C2, if !(returndata.length < 0x20) // Inputs[2] // { // @21C9 stack[-2] // @21C9 memory[stack[-2]:stack[-2] + 0x20] // } 21C7 5B JUMPDEST 21C8 50 POP 21C9 51 MLOAD // Stack delta = -1 // Outputs[1] { @21C9 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_21CA: // Incoming jump from 0x214B // Incoming jump from 0x21C9 // Inputs[8] // { // @21CB stack[-5] // @21CB stack[-1] // @21CE stack[-6] // @21D2 memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20] // @21E5 memory[0x20 + stack[-6]:0x20 + stack[-6] + 0x20] // @21E9 memory[0x40:0x60] // @2217 memory[0x40:0x60] // @2220 address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20]).code.length // } 21CA 5B JUMPDEST 21CB 93 SWAP4 21CC 50 POP 21CD 5B JUMPDEST 21CE 84 DUP5 21CF 60 PUSH1 0x80 21D1 01 ADD 21D2 51 MLOAD 21D3 60 PUSH1 0x01 21D5 60 PUSH1 0x01 21D7 60 PUSH1 0xa0 21D9 1B SHL 21DA 03 SUB 21DB 16 AND 21DC 63 PUSH4 0x095ea7b3 21E1 86 DUP7 21E2 60 PUSH1 0x20 21E4 01 ADD 21E5 51 MLOAD 21E6 86 DUP7 21E7 60 PUSH1 0x40 21E9 51 MLOAD 21EA 83 DUP4 21EB 63 PUSH4 0xffffffff 21F0 16 AND 21F1 60 PUSH1 0xe0 21F3 1B SHL 21F4 81 DUP2 21F5 52 MSTORE 21F6 60 PUSH1 0x04 21F8 01 ADD 21F9 80 DUP1 21FA 83 DUP4 21FB 60 PUSH1 0x01 21FD 60 PUSH1 0x01 21FF 60 PUSH1 0xa0 2201 1B SHL 2202 03 SUB 2203 16 AND 2204 81 DUP2 2205 52 MSTORE 2206 60 PUSH1 0x20 2208 01 ADD 2209 82 DUP3 220A 81 DUP2 220B 52 MSTORE 220C 60 PUSH1 0x20 220E 01 ADD 220F 92 SWAP3 2210 50 POP 2211 50 POP 2212 50 POP 2213 60 PUSH1 0x00 2215 60 PUSH1 0x40 2217 51 MLOAD 2218 80 DUP1 2219 83 DUP4 221A 03 SUB 221B 81 DUP2 221C 60 PUSH1 0x00 221E 87 DUP8 221F 80 DUP1 2220 3B EXTCODESIZE 2221 15 ISZERO 2222 80 DUP1 2223 15 ISZERO 2224 61 PUSH2 0x222c 2227 57 *JUMPI // Stack delta = +9 // Outputs[14] // { // @21CB stack[-5] = stack[-1] // @21DB stack[-1] = (0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20] // @21DC stack[0] = 0x095ea7b3 // @21F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x095ea7b3) << 0xe0 // @2205 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + stack[-6]:0x20 + stack[-6] + 0x20] // @220B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @220F stack[1] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2213 stack[2] = 0x00 // @2217 stack[3] = memory[0x40:0x60] // @221A stack[4] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @221B stack[5] = memory[0x40:0x60] // @221C stack[6] = 0x00 // @221E stack[7] = (0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20] // @2221 stack[8] = !address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20]).code.length // } // Block ends with conditional jump to 0x222c, if !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20]).code.length label_2228: // Incoming jump from 0x2227, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // Incoming jump from 0x2227, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20]).code.length // Inputs[1] { @222B memory[0x00:0x00] } 2228 60 PUSH1 0x00 222A 80 DUP1 222B FD *REVERT // Stack delta = +0 // Outputs[1] { @222B revert(memory[0x00:0x00]); } // Block terminates label_222C: // Incoming jump from 0x2227, if !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-5]:0x80 + stack[-5] + 0x20]).code.length // Incoming jump from 0x2227, if !!address((0x01 << 0xa0) - 0x01 & memory[0x80 + stack[-6]:0x80 + stack[-6] + 0x20]).code.length // Inputs[9] // { // @222E msg.gas // @222F stack[-3] // @222F stack[-2] // @222F stack[-5] // @222F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @222F stack[-7] // @222F stack[-4] // @222F memory[stack[-4]:stack[-4] + stack[-5]] // @222F stack[-6] // } 222C 5B JUMPDEST 222D 50 POP 222E 5A GAS 222F F1 CALL 2230 15 ISZERO 2231 80 DUP1 2232 15 ISZERO 2233 61 PUSH2 0x2240 2236 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @222F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2230 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2240, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2237: // Incoming jump from 0x2236, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2237 returndata.length // @223B returndata[0x00:0x00 + returndata.length] // @223C returndata.length // @223F memory[0x00:0x00 + returndata.length] // } 2237 3D RETURNDATASIZE 2238 60 PUSH1 0x00 223A 80 DUP1 223B 3E RETURNDATACOPY 223C 3D RETURNDATASIZE 223D 60 PUSH1 0x00 223F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @223B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @223F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2240: // Incoming jump from 0x2236, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[7] // { // @2245 stack[-9] // @2249 memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20] // @2258 stack[-5] // @2259 stack[-8] // @225C memory[0x40:0x60] // @228A memory[0x40:0x60] // @2293 address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length // } 2240 5B JUMPDEST 2241 50 POP 2242 50 POP 2243 50 POP 2244 50 POP 2245 84 DUP5 2246 60 PUSH1 0x40 2248 01 ADD 2249 51 MLOAD 224A 60 PUSH1 0x01 224C 60 PUSH1 0x01 224E 60 PUSH1 0xa0 2250 1B SHL 2251 03 SUB 2252 16 AND 2253 63 PUSH4 0x3b4da69f 2258 82 DUP3 2259 86 DUP7 225A 60 PUSH1 0x40 225C 51 MLOAD 225D 83 DUP4 225E 63 PUSH4 0xffffffff 2263 16 AND 2264 60 PUSH1 0xe0 2266 1B SHL 2267 81 DUP2 2268 52 MSTORE 2269 60 PUSH1 0x04 226B 01 ADD 226C 80 DUP1 226D 83 DUP4 226E 60 PUSH1 0x01 2270 60 PUSH1 0x01 2272 60 PUSH1 0xa0 2274 1B SHL 2275 03 SUB 2276 16 AND 2277 81 DUP2 2278 52 MSTORE 2279 60 PUSH1 0x20 227B 01 ADD 227C 82 DUP3 227D 81 DUP2 227E 52 MSTORE 227F 60 PUSH1 0x20 2281 01 ADD 2282 92 SWAP3 2283 50 POP 2284 50 POP 2285 50 POP 2286 60 PUSH1 0x00 2288 60 PUSH1 0x40 228A 51 MLOAD 228B 80 DUP1 228C 83 DUP4 228D 03 SUB 228E 81 DUP2 228F 60 PUSH1 0x00 2291 87 DUP8 2292 80 DUP1 2293 3B EXTCODESIZE 2294 15 ISZERO 2295 80 DUP1 2296 15 ISZERO 2297 61 PUSH2 0x229f 229A 57 *JUMPI // Stack delta = +6 // Outputs[13] // { // @2252 stack[-4] = (0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20] // @2253 stack[-3] = 0x3b4da69f // @2268 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x3b4da69f) << 0xe0 // @2278 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @227E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-8] // @2282 stack[-2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2286 stack[-1] = 0x00 // @228A stack[0] = memory[0x40:0x60] // @228D stack[1] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @228E stack[2] = memory[0x40:0x60] // @228F stack[3] = 0x00 // @2291 stack[4] = (0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20] // @2294 stack[5] = !address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length // } // Block ends with conditional jump to 0x229f, if !!address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length label_229B: // Incoming jump from 0x229A, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length // Inputs[1] { @229E memory[0x00:0x00] } 229B 60 PUSH1 0x00 229D 80 DUP1 229E FD *REVERT // Stack delta = +0 // Outputs[1] { @229E revert(memory[0x00:0x00]); } // Block terminates label_229F: // Incoming jump from 0x229A, if !!address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length // Inputs[9] // { // @22A1 msg.gas // @22A2 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @22A2 stack[-4] // @22A2 stack[-5] // @22A2 stack[-7] // @22A2 memory[stack[-4]:stack[-4] + stack[-5]] // @22A2 stack[-3] // @22A2 stack[-2] // @22A2 stack[-6] // } 229F 5B JUMPDEST 22A0 50 POP 22A1 5A GAS 22A2 F1 CALL 22A3 15 ISZERO 22A4 80 DUP1 22A5 15 ISZERO 22A6 61 PUSH2 0x22b3 22A9 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @22A2 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @22A3 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x22b3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_22AA: // Incoming jump from 0x22A9, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @22AA returndata.length // @22AE returndata[0x00:0x00 + returndata.length] // @22AF returndata.length // @22B2 memory[0x00:0x00 + returndata.length] // } 22AA 3D RETURNDATASIZE 22AB 60 PUSH1 0x00 22AD 80 DUP1 22AE 3E RETURNDATACOPY 22AF 3D RETURNDATASIZE 22B0 60 PUSH1 0x00 22B2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @22AE memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @22B2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_22B3: // Incoming jump from 0x22A9, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[8] // { // @22BB memory[0x00:0x20] // @22C4 memory[0x00:0x20] // @22D5 stack[-9] // @22D9 memory[0x00 + stack[-9]:0x00 + stack[-9] + 0x20] // @22E4 memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20] // @22F5 memory[0x40:0x60] // @2309 memory[0x40:0x60] // @2312 address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length // } 22B3 5B JUMPDEST 22B4 50 POP 22B5 50 POP 22B6 50 POP 22B7 50 POP 22B8 60 PUSH1 0x00 22BA 80 DUP1 22BB 51 MLOAD 22BC 60 PUSH1 0x20 22BE 61 PUSH2 0x4418 22C1 83 DUP4 22C2 39 CODECOPY 22C3 81 DUP2 22C4 51 MLOAD 22C5 91 SWAP2 22C6 52 MSTORE 22C7 60 PUSH1 0x01 22C9 60 PUSH1 0x01 22CB 60 PUSH1 0xa0 22CD 1B SHL 22CE 03 SUB 22CF 16 AND 22D0 63 PUSH4 0x45e6bdcd 22D5 86 DUP7 22D6 60 PUSH1 0x00 22D8 01 ADD 22D9 51 MLOAD 22DA 61 PUSH2 0x2350 22DD 61 PUSH2 0x12f6 22E0 89 DUP10 22E1 60 PUSH1 0x40 22E3 01 ADD 22E4 51 MLOAD 22E5 60 PUSH1 0x01 22E7 60 PUSH1 0x01 22E9 60 PUSH1 0xa0 22EB 1B SHL 22EC 03 SUB 22ED 16 AND 22EE 63 PUSH4 0xb3bcfa82 22F3 60 PUSH1 0x40 22F5 51 MLOAD 22F6 81 DUP2 22F7 63 PUSH4 0xffffffff 22FC 16 AND 22FD 60 PUSH1 0xe0 22FF 1B SHL 2300 81 DUP2 2301 52 MSTORE 2302 60 PUSH1 0x04 2304 01 ADD 2305 60 PUSH1 0x20 2307 60 PUSH1 0x40 2309 51 MLOAD 230A 80 DUP1 230B 83 DUP4 230C 03 SUB 230D 81 DUP2 230E 60 PUSH1 0x00 2310 87 DUP8 2311 80 DUP1 2312 3B EXTCODESIZE 2313 15 ISZERO 2314 80 DUP1 2315 15 ISZERO 2316 61 PUSH2 0x231e 2319 57 *JUMPI // Stack delta = +11 // Outputs[18] // { // @22C2 memory[0x00:0x20] = code[0x4418:0x4438] // @22C6 memory[0x00:0x20] = memory[0x00:0x20] // @22CF stack[-4] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @22D0 stack[-3] = 0x45e6bdcd // @22D9 stack[-2] = memory[0x00 + stack[-9]:0x00 + stack[-9] + 0x20] // @22DA stack[-1] = 0x2350 // @22DD stack[0] = 0x12f6 // @22ED stack[1] = (0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20] // @22EE stack[2] = 0xb3bcfa82 // @2301 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xb3bcfa82) << 0xe0 // @2304 stack[3] = 0x04 + memory[0x40:0x60] // @2305 stack[4] = 0x20 // @2309 stack[5] = memory[0x40:0x60] // @230C stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @230D stack[7] = memory[0x40:0x60] // @230E stack[8] = 0x00 // @2310 stack[9] = (0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20] // @2313 stack[10] = !address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length // } // Block ends with conditional jump to 0x231e, if !!address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length label_231A: // Incoming jump from 0x2319, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length // Inputs[1] { @231D memory[0x00:0x00] } 231A 60 PUSH1 0x00 231C 80 DUP1 231D FD *REVERT // Stack delta = +0 // Outputs[1] { @231D revert(memory[0x00:0x00]); } // Block terminates label_231E: // Incoming jump from 0x2319, if !!address((0x01 << 0xa0) - 0x01 & memory[0x40 + stack[-9]:0x40 + stack[-9] + 0x20]).code.length // Inputs[9] // { // @2320 msg.gas // @2321 stack[-7] // @2321 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2321 stack[-5] // @2321 stack[-2] // @2321 stack[-3] // @2321 stack[-6] // @2321 memory[stack[-4]:stack[-4] + stack[-5]] // @2321 stack[-4] // } 231E 5B JUMPDEST 231F 50 POP 2320 5A GAS 2321 F1 CALL 2322 15 ISZERO 2323 80 DUP1 2324 15 ISZERO 2325 61 PUSH2 0x2332 2328 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2321 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2322 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2332, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2329: // Incoming jump from 0x2328, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2329 returndata.length // @232D returndata[0x00:0x00 + returndata.length] // @232E returndata.length // @2331 memory[0x00:0x00 + returndata.length] // } 2329 3D RETURNDATASIZE 232A 60 PUSH1 0x00 232C 80 DUP1 232D 3E RETURNDATACOPY 232E 3D RETURNDATASIZE 232F 60 PUSH1 0x00 2331 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @232D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2331 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2332: // Incoming jump from 0x2328, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @2339 memory[0x40:0x60] // @233A returndata.length // } 2332 5B JUMPDEST 2333 50 POP 2334 50 POP 2335 50 POP 2336 50 POP 2337 60 PUSH1 0x40 2339 51 MLOAD 233A 3D RETURNDATASIZE 233B 60 PUSH1 0x20 233D 81 DUP2 233E 10 LT 233F 15 ISZERO 2340 61 PUSH2 0x2348 2343 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2339 stack[-4] = memory[0x40:0x60] // @233A stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2348, if !(returndata.length < 0x20) label_2344: // Incoming jump from 0x2343, if not !(returndata.length < 0x20) // Inputs[1] { @2347 memory[0x00:0x00] } 2344 60 PUSH1 0x00 2346 80 DUP1 2347 FD *REVERT // Stack delta = +0 // Outputs[1] { @2347 revert(memory[0x00:0x00]); } // Block terminates label_2348: // Incoming jump from 0x2343, if !(returndata.length < 0x20) // Inputs[3] // { // @234A stack[-2] // @234A memory[stack[-2]:stack[-2] + 0x20] // @234B stack[-11] // } 2348 5B JUMPDEST 2349 50 POP 234A 51 MLOAD 234B 89 DUP10 234C 61 PUSH2 0x3d50 234F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @234A stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @234B stack[-1] = stack[-11] // } // Block ends with unconditional jump to 0x3d50 2350 5B JUMPDEST 2351 61 PUSH2 0x2360 2354 89 DUP10 2355 60 PUSH1 0x60 2357 01 ADD 2358 51 MLOAD 2359 86 DUP7 235A 88 DUP9 235B 8A DUP11 235C 61 PUSH2 0x3b8b 235F 56 *JUMP 2360 5B JUMPDEST 2361 60 PUSH1 0x40 2363 51 MLOAD 2364 84 DUP5 2365 63 PUSH4 0xffffffff 236A 16 AND 236B 60 PUSH1 0xe0 236D 1B SHL 236E 81 DUP2 236F 52 MSTORE 2370 60 PUSH1 0x04 2372 01 ADD 2373 80 DUP1 2374 84 DUP5 2375 81 DUP2 2376 52 MSTORE 2377 60 PUSH1 0x20 2379 01 ADD 237A 83 DUP4 237B 81 DUP2 237C 52 MSTORE 237D 60 PUSH1 0x20 237F 01 ADD 2380 82 DUP3 2381 81 DUP2 2382 52 MSTORE 2383 60 PUSH1 0x20 2385 01 ADD 2386 93 SWAP4 2387 50 POP 2388 50 POP 2389 50 POP 238A 50 POP 238B 60 PUSH1 0x00 238D 60 PUSH1 0x40 238F 51 MLOAD 2390 80 DUP1 2391 83 DUP4 2392 03 SUB 2393 81 DUP2 2394 60 PUSH1 0x00 2396 87 DUP8 2397 80 DUP1 2398 3B EXTCODESIZE 2399 15 ISZERO 239A 80 DUP1 239B 15 ISZERO 239C 61 PUSH2 0x23a4 239F 57 *JUMPI 23A0 60 PUSH1 0x00 23A2 80 DUP1 23A3 FD *REVERT 23A4 5B JUMPDEST 23A5 50 POP 23A6 5A GAS 23A7 F1 CALL 23A8 15 ISZERO 23A9 80 DUP1 23AA 15 ISZERO 23AB 61 PUSH2 0x23b8 23AE 57 *JUMPI 23AF 3D RETURNDATASIZE 23B0 60 PUSH1 0x00 23B2 80 DUP1 23B3 3E RETURNDATACOPY 23B4 3D RETURNDATASIZE 23B5 60 PUSH1 0x00 23B7 FD *REVERT 23B8 5B JUMPDEST 23B9 50 POP 23BA 50 POP 23BB 86 DUP7 23BC 51 MLOAD 23BD 60 PUSH1 0x00 23BF 80 DUP1 23C0 51 MLOAD 23C1 60 PUSH1 0x20 23C3 61 PUSH2 0x4418 23C6 83 DUP4 23C7 39 CODECOPY 23C8 81 DUP2 23C9 51 MLOAD 23CA 91 SWAP2 23CB 52 MSTORE 23CC 92 SWAP3 23CD 50 POP 23CE 63 PUSH4 0xf9f30db6 23D3 91 SWAP2 23D4 50 POP 23D5 30 ADDRESS 23D6 61 PUSH2 0x23de 23D9 87 DUP8 23DA 61 PUSH2 0x3af1 23DD 56 *JUMP 23DE 5B JUMPDEST 23DF 60 PUSH1 0x40 23E1 51 MLOAD 23E2 84 DUP5 23E3 63 PUSH4 0xffffffff 23E8 16 AND 23E9 60 PUSH1 0xe0 23EB 1B SHL 23EC 81 DUP2 23ED 52 MSTORE 23EE 60 PUSH1 0x04 23F0 01 ADD 23F1 80 DUP1 23F2 84 DUP5 23F3 81 DUP2 23F4 52 MSTORE 23F5 60 PUSH1 0x20 23F7 01 ADD 23F8 83 DUP4 23F9 60 PUSH1 0x01 23FB 60 PUSH1 0x01 23FD 60 PUSH1 0xa0 23FF 1B SHL 2400 03 SUB 2401 16 AND 2402 81 DUP2 2403 52 MSTORE 2404 60 PUSH1 0x20 2406 01 ADD 2407 82 DUP3 2408 81 DUP2 2409 52 MSTORE 240A 60 PUSH1 0x20 240C 01 ADD 240D 93 SWAP4 240E 50 POP 240F 50 POP 2410 50 POP 2411 50 POP 2412 60 PUSH1 0x00 2414 60 PUSH1 0x40 2416 51 MLOAD 2417 80 DUP1 2418 83 DUP4 2419 03 SUB 241A 81 DUP2 241B 60 PUSH1 0x00 241D 87 DUP8 241E 80 DUP1 241F 3B EXTCODESIZE 2420 15 ISZERO 2421 80 DUP1 2422 15 ISZERO 2423 61 PUSH2 0x242b 2426 57 *JUMPI 2427 60 PUSH1 0x00 2429 80 DUP1 242A FD *REVERT 242B 5B JUMPDEST 242C 50 POP 242D 5A GAS 242E F1 CALL 242F 15 ISZERO 2430 80 DUP1 2431 15 ISZERO 2432 61 PUSH2 0x243f 2435 57 *JUMPI 2436 3D RETURNDATASIZE 2437 60 PUSH1 0x00 2439 80 DUP1 243A 3E RETURNDATACOPY 243B 3D RETURNDATASIZE 243C 60 PUSH1 0x00 243E FD *REVERT 243F 5B JUMPDEST 2440 50 POP 2441 50 POP 2442 50 POP 2443 60 PUSH1 0x60 2445 86 DUP7 2446 01 ADD 2447 51 MLOAD 2448 60 PUSH1 0x40 244A 80 DUP1 244B 51 MLOAD 244C 63 PUSH4 0x4538c4eb 2451 60 PUSH1 0xe0 2453 1B SHL 2454 81 DUP2 2455 52 MSTORE 2456 30 ADDRESS 2457 60 PUSH1 0x04 2459 82 DUP3 245A 01 ADD 245B 52 MSTORE 245C 60 PUSH1 0x00 245E 80 DUP1 245F 51 MLOAD 2460 60 PUSH1 0x20 2462 61 PUSH2 0x4293 2465 83 DUP4 2466 39 CODECOPY 2467 81 DUP2 2468 51 MLOAD 2469 91 SWAP2 246A 52 MSTORE 246B 60 PUSH1 0x24 246D 82 DUP3 246E 01 ADD 246F 52 MSTORE 2470 90 SWAP1 2471 51 MLOAD 2472 60 PUSH1 0x01 2474 60 PUSH1 0x01 2476 60 PUSH1 0xa0 2478 1B SHL 2479 03 SUB 247A 90 SWAP1 247B 92 SWAP3 247C 16 AND 247D 92 SWAP3 247E 50 POP 247F 63 PUSH4 0x4538c4eb 2484 91 SWAP2 2485 60 PUSH1 0x44 2487 80 DUP1 2488 83 DUP4 2489 01 ADD 248A 92 SWAP3 248B 60 PUSH1 0x20 248D 92 SWAP3 248E 91 SWAP2 248F 90 SWAP1 2490 82 DUP3 2491 90 SWAP1 2492 03 SUB 2493 01 ADD 2494 81 DUP2 2495 86 DUP7 2496 80 DUP1 2497 3B EXTCODESIZE 2498 15 ISZERO 2499 80 DUP1 249A 15 ISZERO 249B 61 PUSH2 0x24a3 249E 57 *JUMPI 249F 60 PUSH1 0x00 24A1 80 DUP1 24A2 FD *REVERT 24A3 5B JUMPDEST 24A4 50 POP 24A5 5A GAS 24A6 FA STATICCALL 24A7 15 ISZERO 24A8 80 DUP1 24A9 15 ISZERO 24AA 61 PUSH2 0x24b7 24AD 57 *JUMPI 24AE 3D RETURNDATASIZE 24AF 60 PUSH1 0x00 24B1 80 DUP1 24B2 3E RETURNDATACOPY 24B3 3D RETURNDATASIZE 24B4 60 PUSH1 0x00 24B6 FD *REVERT 24B7 5B JUMPDEST 24B8 50 POP 24B9 50 POP 24BA 50 POP 24BB 50 POP 24BC 60 PUSH1 0x40 24BE 51 MLOAD 24BF 3D RETURNDATASIZE 24C0 60 PUSH1 0x20 24C2 81 DUP2 24C3 10 LT 24C4 15 ISZERO 24C5 61 PUSH2 0x24cd 24C8 57 *JUMPI 24C9 60 PUSH1 0x00 24CB 80 DUP1 24CC FD *REVERT 24CD 5B JUMPDEST 24CE 50 POP 24CF 51 MLOAD 24D0 61 PUSH2 0x254d 24D3 57 *JUMPI 24D4 84 DUP5 24D5 60 PUSH1 0x60 24D7 01 ADD 24D8 51 MLOAD 24D9 60 PUSH1 0x01 24DB 60 PUSH1 0x01 24DD 60 PUSH1 0xa0 24DF 1B SHL 24E0 03 SUB 24E1 16 AND 24E2 63 PUSH4 0xa3b22fc4 24E7 60 PUSH1 0x00 24E9 80 DUP1 24EA 51 MLOAD 24EB 60 PUSH1 0x20 24ED 61 PUSH2 0x4293 24F0 83 DUP4 24F1 39 CODECOPY 24F2 81 DUP2 24F3 51 MLOAD 24F4 91 SWAP2 24F5 52 MSTORE 24F6 60 PUSH1 0x40 24F8 51 MLOAD 24F9 82 DUP3 24FA 63 PUSH4 0xffffffff 24FF 16 AND 2500 60 PUSH1 0xe0 2502 1B SHL 2503 81 DUP2 2504 52 MSTORE 2505 60 PUSH1 0x04 2507 01 ADD 2508 80 DUP1 2509 82 DUP3 250A 60 PUSH1 0x01 250C 60 PUSH1 0x01 250E 60 PUSH1 0xa0 2510 1B SHL 2511 03 SUB 2512 16 AND 2513 81 DUP2 2514 52 MSTORE 2515 60 PUSH1 0x20 2517 01 ADD 2518 91 SWAP2 2519 50 POP 251A 50 POP 251B 60 PUSH1 0x00 251D 60 PUSH1 0x40 251F 51 MLOAD 2520 80 DUP1 2521 83 DUP4 2522 03 SUB 2523 81 DUP2 2524 60 PUSH1 0x00 2526 87 DUP8 2527 80 DUP1 2528 3B EXTCODESIZE 2529 15 ISZERO 252A 80 DUP1 252B 15 ISZERO 252C 61 PUSH2 0x2534 252F 57 *JUMPI 2530 60 PUSH1 0x00 2532 80 DUP1 2533 FD *REVERT 2534 5B JUMPDEST 2535 50 POP 2536 5A GAS 2537 F1 CALL 2538 15 ISZERO 2539 80 DUP1 253A 15 ISZERO 253B 61 PUSH2 0x2548 253E 57 *JUMPI 253F 3D RETURNDATASIZE 2540 60 PUSH1 0x00 2542 80 DUP1 2543 3E RETURNDATACOPY 2544 3D RETURNDATASIZE 2545 60 PUSH1 0x00 2547 FD *REVERT 2548 5B JUMPDEST 2549 50 POP 254A 50 POP 254B 50 POP 254C 50 POP 254D 5B JUMPDEST 254E 60 PUSH1 0x40 2550 80 DUP1 2551 51 MLOAD 2552 63 PUSH4 0xef693bed 2557 60 PUSH1 0xe0 2559 1B SHL 255A 81 DUP2 255B 52 MSTORE 255C 30 ADDRESS 255D 60 PUSH1 0x04 255F 82 DUP3 2560 01 ADD 2561 52 MSTORE 2562 60 PUSH1 0x24 2564 81 DUP2 2565 01 ADD 2566 85 DUP6 2567 90 SWAP1 2568 52 MSTORE 2569 90 SWAP1 256A 51 MLOAD 256B 60 PUSH1 0x00 256D 80 DUP1 256E 51 MLOAD 256F 60 PUSH1 0x20 2571 61 PUSH2 0x4293 2574 83 DUP4 2575 39 CODECOPY 2576 81 DUP2 2577 51 MLOAD 2578 91 SWAP2 2579 52 MSTORE 257A 91 SWAP2 257B 63 PUSH4 0xef693bed 2580 91 SWAP2 2581 60 PUSH1 0x44 2583 80 DUP1 2584 83 DUP4 2585 01 ADD 2586 92 SWAP3 2587 60 PUSH1 0x00 2589 92 SWAP3 258A 91 SWAP2 258B 90 SWAP1 258C 82 DUP3 258D 90 SWAP1 258E 03 SUB 258F 01 ADD 2590 81 DUP2 2591 83 DUP4 2592 87 DUP8 2593 80 DUP1 2594 3B EXTCODESIZE 2595 15 ISZERO 2596 80 DUP1 2597 15 ISZERO 2598 61 PUSH2 0x25a0 259B 57 *JUMPI 259C 60 PUSH1 0x00 259E 80 DUP1 259F FD *REVERT 25A0 5B JUMPDEST 25A1 50 POP 25A2 5A GAS 25A3 F1 CALL 25A4 15 ISZERO 25A5 80 DUP1 25A6 15 ISZERO 25A7 61 PUSH2 0x25b4 25AA 57 *JUMPI 25AB 3D RETURNDATASIZE 25AC 60 PUSH1 0x00 25AE 80 DUP1 25AF 3E RETURNDATACOPY 25B0 3D RETURNDATASIZE 25B1 60 PUSH1 0x00 25B3 FD *REVERT 25B4 5B JUMPDEST 25B5 50 POP 25B6 50 POP 25B7 50 POP 25B8 50 POP 25B9 61 PUSH2 0x25c2 25BC 89 DUP10 25BD 85 DUP6 25BE 61 PUSH2 0x3b0e 25C1 56 *JUMP 25C2 5B JUMPDEST 25C3 61 PUSH2 0x25cc 25C6 88 DUP9 25C7 84 DUP5 25C8 61 PUSH2 0x3b0e 25CB 56 *JUMP 25CC 5B JUMPDEST 25CD 60 PUSH1 0x40 25CF 51 MLOAD 25D0 80 DUP1 25D1 60 PUSH1 0x80 25D3 01 ADD 25D4 60 PUSH1 0x40 25D6 52 MSTORE 25D7 80 DUP1 25D8 60 PUSH1 0x54 25DA 81 DUP2 25DB 52 MSTORE 25DC 60 PUSH1 0x20 25DE 01 ADD 25DF 61 PUSH2 0x43c4 25E2 60 PUSH1 0x54 25E4 91 SWAP2 25E5 39 CODECOPY 25E6 94 SWAP5 25E7 51 MLOAD 25E8 60 PUSH1 0x40 25EA 80 DUP1 25EB 51 MLOAD 25EC 60 PUSH1 0x20 25EE 81 DUP2 25EF 01 ADD 25F0 92 SWAP3 25F1 90 SWAP1 25F2 92 SWAP3 25F3 52 MSTORE 25F4 81 DUP2 25F5 81 DUP2 25F6 01 ADD 25F7 93 SWAP4 25F8 90 SWAP1 25F9 93 SWAP4 25FA 52 MSTORE 25FB 60 PUSH1 0x60 25FD 81 DUP2 25FE 01 ADD 25FF 94 SWAP5 2600 90 SWAP1 2601 94 SWAP5 2602 52 MSTORE 2603 50 POP 2604 60 PUSH1 0x80 2606 83 DUP4 2607 01 ADD 2608 91 SWAP2 2609 90 SWAP1 260A 91 SWAP2 260B 52 MSTORE 260C 60 PUSH1 0xa0 260E 82 DUP3 260F 01 ADD 2610 98 SWAP9 2611 90 SWAP1 2612 98 SWAP9 2613 52 MSTORE 2614 60 PUSH1 0xc0 2616 81 DUP2 2617 01 ADD 2618 96 SWAP7 2619 90 SWAP1 261A 96 SWAP7 261B 52 MSTORE 261C 60 PUSH1 0xe0 261E 86 DUP7 261F 01 ADD 2620 94 SWAP5 2621 90 SWAP1 2622 94 SWAP5 2623 52 MSTORE 2624 50 POP 2625 50 POP 2626 61 PUSH2 0x0100 2629 80 DUP1 262A 84 DUP5 262B 01 ADD 262C 91 SWAP2 262D 90 SWAP1 262E 91 SWAP2 262F 52 MSTORE 2630 83 DUP4 2631 51 MLOAD 2632 80 DUP1 2633 84 DUP5 2634 03 SUB 2635 90 SWAP1 2636 91 SWAP2 2637 01 ADD 2638 81 DUP2 2639 52 MSTORE 263A 61 PUSH2 0x0120 263D 90 SWAP1 263E 92 SWAP3 263F 01 ADD 2640 90 SWAP1 2641 92 SWAP3 2642 52 MSTORE 2643 90 SWAP1 2644 94 SWAP5 2645 90 SWAP1 2646 93 SWAP4 2647 50 POP 2648 91 SWAP2 2649 50 POP 264A 50 POP 264B 56 *JUMP label_264C: // Incoming jump from 0x039D // Inputs[5] // { // @2650 address(this) // @265F stack[-1] // @2662 memory[0x40:0x60] // @2689 memory[0x40:0x60] // @2690 address((0x01 << 0xa0) - 0x01 & address(this)).code.length // } 264C 5B JUMPDEST 264D 60 PUSH1 0x60 264F 80 DUP1 2650 30 ADDRESS 2651 60 PUSH1 0x01 2653 60 PUSH1 0x01 2655 60 PUSH1 0xa0 2657 1B SHL 2658 03 SUB 2659 16 AND 265A 63 PUSH4 0x2520e7ff 265F 84 DUP5 2660 60 PUSH1 0x40 2662 51 MLOAD 2663 82 DUP3 2664 63 PUSH4 0xffffffff 2669 16 AND 266A 60 PUSH1 0xe0 266C 1B SHL 266D 81 DUP2 266E 52 MSTORE 266F 60 PUSH1 0x04 2671 01 ADD 2672 80 DUP1 2673 82 DUP3 2674 60 PUSH1 0x01 2676 60 PUSH1 0x01 2678 60 PUSH1 0xa0 267A 1B SHL 267B 03 SUB 267C 16 AND 267D 81 DUP2 267E 52 MSTORE 267F 60 PUSH1 0x20 2681 01 ADD 2682 91 SWAP2 2683 50 POP 2684 50 POP 2685 60 PUSH1 0x20 2687 60 PUSH1 0x40 2689 51 MLOAD 268A 80 DUP1 268B 83 DUP4 268C 03 SUB 268D 81 DUP2 268E 86 DUP7 268F 80 DUP1 2690 3B EXTCODESIZE 2691 15 ISZERO 2692 80 DUP1 2693 15 ISZERO 2694 61 PUSH2 0x269c 2697 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @264D stack[0] = 0x60 // @264F stack[1] = 0x60 // @2659 stack[2] = (0x01 << 0xa0) - 0x01 & address(this) // @265A stack[3] = 0x2520e7ff // @266E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2520e7ff) << 0xe0 // @267E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2682 stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @2685 stack[5] = 0x20 // @2689 stack[6] = memory[0x40:0x60] // @268C stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @268D stack[8] = memory[0x40:0x60] // @268E stack[9] = (0x01 << 0xa0) - 0x01 & address(this) // @2691 stack[10] = !address((0x01 << 0xa0) - 0x01 & address(this)).code.length // } // Block ends with conditional jump to 0x269c, if !!address((0x01 << 0xa0) - 0x01 & address(this)).code.length label_2698: // Incoming jump from 0x2697, if not !!address((0x01 << 0xa0) - 0x01 & address(this)).code.length // Inputs[1] { @269B memory[0x00:0x00] } 2698 60 PUSH1 0x00 269A 80 DUP1 269B FD *REVERT // Stack delta = +0 // Outputs[1] { @269B revert(memory[0x00:0x00]); } // Block terminates label_269C: // Incoming jump from 0x2697, if !!address((0x01 << 0xa0) - 0x01 & address(this)).code.length // Inputs[8] // { // @269E msg.gas // @269F stack[-6] // @269F stack[-4] // @269F stack[-5] // @269F stack[-3] // @269F memory[stack[-3]:stack[-3] + stack[-4]] // @269F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @269F stack[-2] // } 269C 5B JUMPDEST 269D 50 POP 269E 5A GAS 269F FA STATICCALL 26A0 15 ISZERO 26A1 80 DUP1 26A2 15 ISZERO 26A3 61 PUSH2 0x26b0 26A6 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @269F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @26A0 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x26b0, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_26A7: // Incoming jump from 0x26A6, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @26A7 returndata.length // @26AB returndata[0x00:0x00 + returndata.length] // @26AC returndata.length // @26AF memory[0x00:0x00 + returndata.length] // } 26A7 3D RETURNDATASIZE 26A8 60 PUSH1 0x00 26AA 80 DUP1 26AB 3E RETURNDATACOPY 26AC 3D RETURNDATASIZE 26AD 60 PUSH1 0x00 26AF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @26AB memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @26AF revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_26B0: // Incoming jump from 0x26A6, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @26B7 memory[0x40:0x60] // @26B8 returndata.length // } 26B0 5B JUMPDEST 26B1 50 POP 26B2 50 POP 26B3 50 POP 26B4 50 POP 26B5 60 PUSH1 0x40 26B7 51 MLOAD 26B8 3D RETURNDATASIZE 26B9 60 PUSH1 0x20 26BB 81 DUP2 26BC 10 LT 26BD 15 ISZERO 26BE 61 PUSH2 0x26c6 26C1 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @26B7 stack[-4] = memory[0x40:0x60] // @26B8 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x26c6, if !(returndata.length < 0x20) label_26C2: // Incoming jump from 0x26C1, if not !(returndata.length < 0x20) // Inputs[1] { @26C5 memory[0x00:0x00] } 26C2 60 PUSH1 0x00 26C4 80 DUP1 26C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @26C5 revert(memory[0x00:0x00]); } // Block terminates label_26C6: // Incoming jump from 0x26C1, if !(returndata.length < 0x20) // Inputs[2] // { // @26C8 memory[stack[-2]:stack[-2] + 0x20] // @26C8 stack[-2] // } 26C6 5B JUMPDEST 26C7 50 POP 26C8 51 MLOAD 26C9 61 PUSH2 0x2711 26CC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2711, if memory[stack[-2]:stack[-2] + 0x20] label_26CD: // Incoming jump from 0x26CC, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @26D0 memory[0x40:0x60] // @2707 memory[0x40:0x60] // @2710 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 26CD 60 PUSH1 0x40 26CF 80 DUP1 26D0 51 MLOAD 26D1 62 PUSH3 0x461bcd 26D5 60 PUSH1 0xe5 26D7 1B SHL 26D8 81 DUP2 26D9 52 MSTORE 26DA 60 PUSH1 0x20 26DC 60 PUSH1 0x04 26DE 82 DUP3 26DF 01 ADD 26E0 52 MSTORE 26E1 60 PUSH1 0x15 26E3 60 PUSH1 0x24 26E5 82 DUP3 26E6 01 ADD 26E7 52 MSTORE 26E8 74 PUSH21 0x0dccaf0e89eeedccae45ad2e65adcdee85ac2eae8d 26FE 60 PUSH1 0x5b 2700 1B SHL 2701 60 PUSH1 0x44 2703 82 DUP3 2704 01 ADD 2705 52 MSTORE 2706 90 SWAP1 2707 51 MLOAD 2708 90 SWAP1 2709 81 DUP2 270A 90 SWAP1 270B 03 SUB 270C 60 PUSH1 0x64 270E 01 ADD 270F 90 SWAP1 2710 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @26D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @26E0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @26E7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @2705 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x0dccaf0e89eeedccae45ad2e65adcdee85ac2eae8d << 0x5b // @2710 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2711: // Incoming jump from 0x26CC, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @2717 stack[-4] } 2711 5B JUMPDEST 2712 60 PUSH1 0x00 2714 61 PUSH2 0x271c 2717 85 DUP6 2718 61 PUSH2 0x3804 271B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2712 stack[0] = 0x00 // @2714 stack[1] = 0x271c // @2717 stack[2] = stack[-4] // } // Block ends with call to 0x3804, returns to 0x271C label_271C: // Incoming return from call to 0x3804 at 0x271B // Inputs[2] // { // @271D stack[-2] // @271D stack[-1] // } 271C 5B JUMPDEST 271D 90 SWAP1 271E 50 POP 271F 60 PUSH1 0x00 2721 61 PUSH2 0x2729 2724 82 DUP3 2725 61 PUSH2 0x3950 2728 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @271D stack[-2] = stack[-1] // @271F stack[-1] = 0x00 // @2721 stack[0] = 0x2729 // @2724 stack[1] = stack[-1] // } // Block ends with call to 0x3950, returns to 0x2729 label_2729: // Incoming return from call to 0x3950 at 0x2728 // Inputs[9] // { // @272B stack[-2] // @272B stack[-3] // @272D address(this) // @273A memory[0x00:0x20] // @2743 memory[0x00:0x20] // @2754 stack[-4] // @2757 memory[0x40:0x60] // @2775 memory[0x40:0x60] // @277C address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 2729 5B JUMPDEST 272A 50 POP 272B 90 SWAP1 272C 50 POP 272D 30 ADDRESS 272E 60 PUSH1 0x01 2730 60 PUSH1 0x01 2732 60 PUSH1 0xa0 2734 1B SHL 2735 03 SUB 2736 16 AND 2737 60 PUSH1 0x00 2739 80 DUP1 273A 51 MLOAD 273B 60 PUSH1 0x20 273D 61 PUSH2 0x4418 2740 83 DUP4 2741 39 CODECOPY 2742 81 DUP2 2743 51 MLOAD 2744 91 SWAP2 2745 52 MSTORE 2746 60 PUSH1 0x01 2748 60 PUSH1 0x01 274A 60 PUSH1 0xa0 274C 1B SHL 274D 03 SUB 274E 16 AND 274F 63 PUSH4 0x8161b120 2754 84 DUP5 2755 60 PUSH1 0x40 2757 51 MLOAD 2758 82 DUP3 2759 63 PUSH4 0xffffffff 275E 16 AND 275F 60 PUSH1 0xe0 2761 1B SHL 2762 81 DUP2 2763 52 MSTORE 2764 60 PUSH1 0x04 2766 01 ADD 2767 80 DUP1 2768 82 DUP3 2769 81 DUP2 276A 52 MSTORE 276B 60 PUSH1 0x20 276D 01 ADD 276E 91 SWAP2 276F 50 POP 2770 50 POP 2771 60 PUSH1 0x20 2773 60 PUSH1 0x40 2775 51 MLOAD 2776 80 DUP1 2777 83 DUP4 2778 03 SUB 2779 81 DUP2 277A 86 DUP7 277B 80 DUP1 277C 3B EXTCODESIZE 277D 15 ISZERO 277E 80 DUP1 277F 15 ISZERO 2780 61 PUSH2 0x2788 2783 57 *JUMPI // Stack delta = +8 // Outputs[15] // { // @272B stack[-3] = stack[-2] // @2736 stack[-2] = (0x01 << 0xa0) - 0x01 & address(this) // @2741 memory[0x00:0x20] = code[0x4418:0x4438] // @2745 memory[0x00:0x20] = memory[0x00:0x20] // @274E stack[-1] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @274F stack[0] = 0x8161b120 // @2763 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x8161b120) << 0xe0 // @276A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-4] // @276E stack[1] = 0x20 + 0x04 + memory[0x40:0x60] // @2771 stack[2] = 0x20 // @2775 stack[3] = memory[0x40:0x60] // @2778 stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2779 stack[5] = memory[0x40:0x60] // @277A stack[6] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @277D stack[7] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x2788, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_2784: // Incoming jump from 0x2783, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @2787 memory[0x00:0x00] } 2784 60 PUSH1 0x00 2786 80 DUP1 2787 FD *REVERT // Stack delta = +0 // Outputs[1] { @2787 revert(memory[0x00:0x00]); } // Block terminates label_2788: // Incoming jump from 0x2783, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @278A msg.gas // @278B stack[-3] // @278B stack[-4] // @278B stack[-2] // @278B stack[-6] // @278B address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @278B memory[stack[-3]:stack[-3] + stack[-4]] // @278B stack[-5] // } 2788 5B JUMPDEST 2789 50 POP 278A 5A GAS 278B FA STATICCALL 278C 15 ISZERO 278D 80 DUP1 278E 15 ISZERO 278F 61 PUSH2 0x279c 2792 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @278B memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @278C stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x279c, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2793: // Incoming jump from 0x2792, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2793 returndata.length // @2797 returndata[0x00:0x00 + returndata.length] // @2798 returndata.length // @279B memory[0x00:0x00 + returndata.length] // } 2793 3D RETURNDATASIZE 2794 60 PUSH1 0x00 2796 80 DUP1 2797 3E RETURNDATACOPY 2798 3D RETURNDATASIZE 2799 60 PUSH1 0x00 279B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2797 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @279B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_279C: // Incoming jump from 0x2792, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @27A3 memory[0x40:0x60] // @27A4 returndata.length // } 279C 5B JUMPDEST 279D 50 POP 279E 50 POP 279F 50 POP 27A0 50 POP 27A1 60 PUSH1 0x40 27A3 51 MLOAD 27A4 3D RETURNDATASIZE 27A5 60 PUSH1 0x20 27A7 81 DUP2 27A8 10 LT 27A9 15 ISZERO 27AA 61 PUSH2 0x27b2 27AD 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @27A3 stack[-4] = memory[0x40:0x60] // @27A4 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x27b2, if !(returndata.length < 0x20) label_27AE: // Incoming jump from 0x27AD, if not !(returndata.length < 0x20) // Inputs[1] { @27B1 memory[0x00:0x00] } 27AE 60 PUSH1 0x00 27B0 80 DUP1 27B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @27B1 revert(memory[0x00:0x00]); } // Block terminates label_27B2: // Incoming jump from 0x27AD, if !(returndata.length < 0x20) // Inputs[3] // { // @27B4 memory[stack[-2]:stack[-2] + 0x20] // @27B4 stack[-2] // @27BE stack[-3] // } 27B2 5B JUMPDEST 27B3 50 POP 27B4 51 MLOAD 27B5 60 PUSH1 0x01 27B7 60 PUSH1 0x01 27B9 60 PUSH1 0xa0 27BB 1B SHL 27BC 03 SUB 27BD 16 AND 27BE 14 EQ 27BF 61 PUSH2 0x27fb 27C2 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x27fb, if (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] label_27C3: // Incoming jump from 0x27C2, if not (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[3] // { // @27C6 memory[0x40:0x60] // @27F1 memory[0x40:0x60] // @27FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 27C3 60 PUSH1 0x40 27C5 80 DUP1 27C6 51 MLOAD 27C7 62 PUSH3 0x461bcd 27CB 60 PUSH1 0xe5 27CD 1B SHL 27CE 81 DUP2 27CF 52 MSTORE 27D0 60 PUSH1 0x20 27D2 60 PUSH1 0x04 27D4 82 DUP3 27D5 01 ADD 27D6 52 MSTORE 27D7 60 PUSH1 0x09 27D9 60 PUSH1 0x24 27DB 82 DUP3 27DC 01 ADD 27DD 52 MSTORE 27DE 68 PUSH9 0x3737ba16b7bbb732b9 27E8 60 PUSH1 0xb9 27EA 1B SHL 27EB 60 PUSH1 0x44 27ED 82 DUP3 27EE 01 ADD 27EF 52 MSTORE 27F0 90 SWAP1 27F1 51 MLOAD 27F2 90 SWAP1 27F3 81 DUP2 27F4 90 SWAP1 27F5 03 SUB 27F6 60 PUSH1 0x64 27F8 01 ADD 27F9 90 SWAP1 27FA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @27CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @27D6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @27DD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @27EF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x3737ba16b7bbb732b9 << 0xb9 // @27FA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_27FB: // Incoming jump from 0x27C2, if (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[7] // { // @27FF memory[0x40:0x60] // @280E stack[-2] // @2819 stack[-5] // @2821 memory[0x40:0x60] // @2825 memory[0x00:0x20] // @282E memory[0x00:0x20] // @284B address(memory[0x00:0x20]).code.length // } 27FB 5B JUMPDEST 27FC 60 PUSH1 0x40 27FE 80 DUP1 27FF 51 MLOAD 2800 63 PUSH4 0x1f95f98d 2805 60 PUSH1 0xe3 2807 1B SHL 2808 81 DUP2 2809 52 MSTORE 280A 60 PUSH1 0x04 280C 81 DUP2 280D 01 ADD 280E 84 DUP5 280F 90 SWAP1 2810 52 MSTORE 2811 60 PUSH1 0x01 2813 60 PUSH1 0x01 2815 60 PUSH1 0xa0 2817 1B SHL 2818 03 SUB 2819 87 DUP8 281A 16 AND 281B 60 PUSH1 0x24 281D 82 DUP3 281E 01 ADD 281F 52 MSTORE 2820 90 SWAP1 2821 51 MLOAD 2822 60 PUSH1 0x00 2824 80 DUP1 2825 51 MLOAD 2826 60 PUSH1 0x20 2828 61 PUSH2 0x4418 282B 83 DUP4 282C 39 CODECOPY 282D 81 DUP2 282E 51 MLOAD 282F 91 SWAP2 2830 52 MSTORE 2831 91 SWAP2 2832 63 PUSH4 0xfcafcc68 2837 91 SWAP2 2838 60 PUSH1 0x44 283A 80 DUP1 283B 83 DUP4 283C 01 ADD 283D 92 SWAP3 283E 60 PUSH1 0x00 2840 92 SWAP3 2841 91 SWAP2 2842 90 SWAP1 2843 82 DUP3 2844 90 SWAP1 2845 03 SUB 2846 01 ADD 2847 81 DUP2 2848 83 DUP4 2849 87 DUP8 284A 80 DUP1 284B 3B EXTCODESIZE 284C 15 ISZERO 284D 80 DUP1 284E 15 ISZERO 284F 61 PUSH2 0x2857 2852 57 *JUMPI // Stack delta = +10 // Outputs[15] // { // @2809 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1f95f98d << 0xe3 // @2810 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-2] // @281F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @282C memory[0x00:0x20] = code[0x4418:0x4438] // @2830 memory[0x00:0x20] = memory[0x00:0x20] // @2831 stack[0] = memory[0x00:0x20] // @2837 stack[1] = 0xfcafcc68 // @283D stack[2] = memory[0x40:0x60] + 0x44 // @2840 stack[3] = 0x00 // @2841 stack[4] = memory[0x40:0x60] // @2846 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @2847 stack[6] = memory[0x40:0x60] // @2848 stack[7] = 0x00 // @2849 stack[8] = memory[0x00:0x20] // @284C stack[9] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x2857, if !!address(memory[0x00:0x20]).code.length label_2853: // Incoming jump from 0x2852, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @2856 memory[0x00:0x00] } 2853 60 PUSH1 0x00 2855 80 DUP1 2856 FD *REVERT // Stack delta = +0 // Outputs[1] { @2856 revert(memory[0x00:0x00]); } // Block terminates label_2857: // Incoming jump from 0x2852, if !!address(memory[0x00:0x20]).code.length // Inputs[9] // { // @2859 msg.gas // @285A stack[-4] // @285A stack[-5] // @285A stack[-7] // @285A stack[-6] // @285A memory[stack[-4]:stack[-4] + stack[-5]] // @285A stack[-3] // @285A stack[-2] // @285A address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 2857 5B JUMPDEST 2858 50 POP 2859 5A GAS 285A F1 CALL 285B 15 ISZERO 285C 80 DUP1 285D 15 ISZERO 285E 61 PUSH2 0x286b 2861 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @285A memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @285B stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x286b, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2862: // Incoming jump from 0x2861, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2862 returndata.length // @2866 returndata[0x00:0x00 + returndata.length] // @2867 returndata.length // @286A memory[0x00:0x00 + returndata.length] // } 2862 3D RETURNDATASIZE 2863 60 PUSH1 0x00 2865 80 DUP1 2866 3E RETURNDATACOPY 2867 3D RETURNDATASIZE 2868 60 PUSH1 0x00 286A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2866 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @286A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_286B: // Incoming jump from 0x2861, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[8] // { // @2872 memory[0x40:0x60] // @288C memory[0x40:0x60] // @2891 stack[-6] // @2898 stack[-5] // @28A5 stack[-9] // @28B1 memory[0x40:0x60] // @28C2 stack[-11] // @28C4 stack[-10] // } 286B 5B JUMPDEST 286C 50 POP 286D 50 POP 286E 50 POP 286F 50 POP 2870 60 PUSH1 0x40 2872 51 MLOAD 2873 80 DUP1 2874 60 PUSH1 0x60 2876 01 ADD 2877 60 PUSH1 0x40 2879 52 MSTORE 287A 80 DUP1 287B 60 PUSH1 0x24 287D 81 DUP2 287E 52 MSTORE 287F 60 PUSH1 0x20 2881 01 ADD 2882 61 PUSH2 0x4208 2885 60 PUSH1 0x24 2887 91 SWAP2 2888 39 CODECOPY 2889 60 PUSH1 0x40 288B 80 DUP1 288C 51 MLOAD 288D 60 PUSH1 0x20 288F 81 DUP2 2890 01 ADD 2891 94 SWAP5 2892 90 SWAP1 2893 94 SWAP5 2894 52 MSTORE 2895 83 DUP4 2896 81 DUP2 2897 01 ADD 2898 92 SWAP3 2899 90 SWAP1 289A 92 SWAP3 289B 52 MSTORE 289C 60 PUSH1 0x01 289E 60 PUSH1 0x01 28A0 60 PUSH1 0xa0 28A2 1B SHL 28A3 03 SUB 28A4 90 SWAP1 28A5 95 SWAP6 28A6 16 AND 28A7 60 PUSH1 0x60 28A9 80 DUP1 28AA 84 DUP5 28AB 01 ADD 28AC 91 SWAP2 28AD 90 SWAP1 28AE 91 SWAP2 28AF 52 MSTORE 28B0 81 DUP2 28B1 51 MLOAD 28B2 80 DUP1 28B3 84 DUP5 28B4 03 SUB 28B5 90 SWAP1 28B6 91 SWAP2 28B7 01 ADD 28B8 81 DUP2 28B9 52 MSTORE 28BA 60 PUSH1 0x80 28BC 90 SWAP1 28BD 92 SWAP3 28BE 01 ADD 28BF 90 SWAP1 28C0 52 MSTORE 28C1 92 SWAP3 28C2 94 SWAP5 28C3 92 SWAP3 28C4 93 SWAP4 28C5 50 POP 28C6 50 POP 28C7 50 POP 28C8 56 *JUMP // Stack delta = -9 // Outputs[10] // { // @2879 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @287E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x24 // @2888 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x24] = code[0x4208:0x422c] // @2894 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-6] // @289B memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-5] // @28AF memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @28B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x60 + (memory[0x40:0x60] - memory[0x40:0x60]) // @28C0 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @28C2 stack[-11] = memory[0x40:0x60] // @28C4 stack[-10] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-11] label_28C9: // Incoming jump from 0x03CC // Inputs[2] // { // @28D2 stack[-2] // @28D3 stack[-3] // } 28C9 5B JUMPDEST 28CA 60 PUSH1 0x60 28CC 80 DUP1 28CD 60 PUSH1 0x00 28CF 61 PUSH2 0x28d8 28D2 85 DUP6 28D3 87 DUP8 28D4 61 PUSH2 0x3a55 28D7 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @28CA stack[0] = 0x60 // @28CC stack[1] = 0x60 // @28CD stack[2] = 0x00 // @28CF stack[3] = 0x28d8 // @28D2 stack[4] = stack[-2] // @28D3 stack[5] = stack[-3] // } // Block ends with call to 0x3a55, returns to 0x28D8 label_28D8: // Incoming return from call to 0x3A55 at 0x28D7 // Inputs[3] // { // @28D9 stack[-1] // @28D9 stack[-2] // @28E1 stack[-8] // } 28D8 5B JUMPDEST 28D9 90 SWAP1 28DA 50 POP 28DB 60 PUSH1 0x00 28DD 80 DUP1 28DE 61 PUSH2 0x28e6 28E1 89 DUP10 28E2 61 PUSH2 0x3950 28E5 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @28D9 stack[-2] = stack[-1] // @28DB stack[-1] = 0x00 // @28DD stack[0] = 0x00 // @28DE stack[1] = 0x28e6 // @28E1 stack[2] = stack[-8] // } // Block ends with call to 0x3950, returns to 0x28E6 label_28E6: // Incoming return from call to 0x3950 at 0x28E5 // Inputs[7] // { // @28E7 stack[-1] // @28E7 stack[-3] // @28E9 stack[-4] // @28E9 stack[-2] // @2913 memory[0x40:0x60] // @2931 memory[0x40:0x60] // @2938 address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } 28E6 5B JUMPDEST 28E7 91 SWAP2 28E8 50 POP 28E9 91 SWAP2 28EA 50 POP 28EB 60 PUSH1 0x00 28ED 73 PUSH20 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 2902 60 PUSH1 0x01 2904 60 PUSH1 0x01 2906 60 PUSH1 0xa0 2908 1B SHL 2909 03 SUB 290A 16 AND 290B 63 PUSH4 0x4445d799 2910 84 DUP5 2911 60 PUSH1 0x40 2913 51 MLOAD 2914 82 DUP3 2915 63 PUSH4 0xffffffff 291A 16 AND 291B 60 PUSH1 0xe0 291D 1B SHL 291E 81 DUP2 291F 52 MSTORE 2920 60 PUSH1 0x04 2922 01 ADD 2923 80 DUP1 2924 82 DUP3 2925 81 DUP2 2926 52 MSTORE 2927 60 PUSH1 0x20 2929 01 ADD 292A 91 SWAP2 292B 50 POP 292C 50 POP 292D 60 PUSH1 0x20 292F 60 PUSH1 0x40 2931 51 MLOAD 2932 80 DUP1 2933 83 DUP4 2934 03 SUB 2935 81 DUP2 2936 86 DUP7 2937 80 DUP1 2938 3B EXTCODESIZE 2939 15 ISZERO 293A 80 DUP1 293B 15 ISZERO 293C 61 PUSH2 0x2944 293F 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @28E7 stack[-3] = stack[-1] // @28E9 stack[-4] = stack[-2] // @28EB stack[-2] = 0x00 // @290A stack[-1] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @290B stack[0] = 0x4445d799 // @291F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x4445d799) << 0xe0 // @2926 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @292A stack[1] = 0x20 + 0x04 + memory[0x40:0x60] // @292D stack[2] = 0x20 // @2931 stack[3] = memory[0x40:0x60] // @2934 stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2935 stack[5] = memory[0x40:0x60] // @2936 stack[6] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @2939 stack[7] = !address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } // Block ends with conditional jump to 0x2944, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length label_2940: // Incoming jump from 0x293F, if not !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[1] { @2943 memory[0x00:0x00] } 2940 60 PUSH1 0x00 2942 80 DUP1 2943 FD *REVERT // Stack delta = +0 // Outputs[1] { @2943 revert(memory[0x00:0x00]); } // Block terminates label_2944: // Incoming jump from 0x293F, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[8] // { // @2946 msg.gas // @2947 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2947 stack[-2] // @2947 stack[-5] // @2947 stack[-4] // @2947 stack[-3] // @2947 stack[-6] // @2947 memory[stack[-3]:stack[-3] + stack[-4]] // } 2944 5B JUMPDEST 2945 50 POP 2946 5A GAS 2947 FA STATICCALL 2948 15 ISZERO 2949 80 DUP1 294A 15 ISZERO 294B 61 PUSH2 0x2958 294E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2947 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2948 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2958, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_294F: // Incoming jump from 0x294E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @294F returndata.length // @2953 returndata[0x00:0x00 + returndata.length] // @2954 returndata.length // @2957 memory[0x00:0x00 + returndata.length] // } 294F 3D RETURNDATASIZE 2950 60 PUSH1 0x00 2952 80 DUP1 2953 3E RETURNDATACOPY 2954 3D RETURNDATASIZE 2955 60 PUSH1 0x00 2957 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2953 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2957 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2958: // Incoming jump from 0x294E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @295F memory[0x40:0x60] // @2960 returndata.length // } 2958 5B JUMPDEST 2959 50 POP 295A 50 POP 295B 50 POP 295C 50 POP 295D 60 PUSH1 0x40 295F 51 MLOAD 2960 3D RETURNDATASIZE 2961 60 PUSH1 0x20 2963 81 DUP2 2964 10 LT 2965 15 ISZERO 2966 61 PUSH2 0x296e 2969 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @295F stack[-4] = memory[0x40:0x60] // @2960 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x296e, if !(returndata.length < 0x20) label_296A: // Incoming jump from 0x2969, if not !(returndata.length < 0x20) // Inputs[1] { @296D memory[0x00:0x00] } 296A 60 PUSH1 0x00 296C 80 DUP1 296D FD *REVERT // Stack delta = +0 // Outputs[1] { @296D revert(memory[0x00:0x00]); } // Block terminates label_296E: // Incoming jump from 0x2969, if !(returndata.length < 0x20) // Inputs[4] // { // @2970 memory[stack[-2]:stack[-2] + 0x20] // @2970 stack[-2] // @2971 stack[-3] // @2979 stack[-6] // } 296E 5B JUMPDEST 296F 50 POP 2970 51 MLOAD 2971 90 SWAP1 2972 50 POP 2973 80 DUP1 2974 60 PUSH1 0x00 2976 60 PUSH1 0x00 2978 19 NOT 2979 86 DUP7 297A 14 EQ 297B 15 ISZERO 297C 61 PUSH2 0x2abf 297F 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2971 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @2973 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @2974 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2abf, if !(stack[-6] == ~0x00) label_2980: // Incoming jump from 0x297F, if not !(stack[-6] == ~0x00) // Inputs[5] // { // @2983 memory[0x00:0x20] // @298C memory[0x00:0x20] // @299F memory[0x40:0x60] // @29B3 memory[0x40:0x60] // @29BA address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 2980 60 PUSH1 0x00 2982 80 DUP1 2983 51 MLOAD 2984 60 PUSH1 0x20 2986 61 PUSH2 0x4418 2989 83 DUP4 298A 39 CODECOPY 298B 81 DUP2 298C 51 MLOAD 298D 91 SWAP2 298E 52 MSTORE 298F 60 PUSH1 0x01 2991 60 PUSH1 0x01 2993 60 PUSH1 0xa0 2995 1B SHL 2996 03 SUB 2997 16 AND 2998 63 PUSH4 0x36569e77 299D 60 PUSH1 0x40 299F 51 MLOAD 29A0 81 DUP2 29A1 63 PUSH4 0xffffffff 29A6 16 AND 29A7 60 PUSH1 0xe0 29A9 1B SHL 29AA 81 DUP2 29AB 52 MSTORE 29AC 60 PUSH1 0x04 29AE 01 ADD 29AF 60 PUSH1 0x20 29B1 60 PUSH1 0x40 29B3 51 MLOAD 29B4 80 DUP1 29B5 83 DUP4 29B6 03 SUB 29B7 81 DUP2 29B8 86 DUP7 29B9 80 DUP1 29BA 3B EXTCODESIZE 29BB 15 ISZERO 29BC 80 DUP1 29BD 15 ISZERO 29BE 61 PUSH2 0x29c6 29C1 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @298A memory[0x00:0x20] = code[0x4418:0x4438] // @298E memory[0x00:0x20] = memory[0x00:0x20] // @2997 stack[0] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @2998 stack[1] = 0x36569e77 // @29AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @29AE stack[2] = 0x04 + memory[0x40:0x60] // @29AF stack[3] = 0x20 // @29B3 stack[4] = memory[0x40:0x60] // @29B6 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @29B7 stack[6] = memory[0x40:0x60] // @29B8 stack[7] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @29BB stack[8] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x29c6, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_29C2: // Incoming jump from 0x29C1, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @29C5 memory[0x00:0x00] } 29C2 60 PUSH1 0x00 29C4 80 DUP1 29C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @29C5 revert(memory[0x00:0x00]); } // Block terminates label_29C6: // Incoming jump from 0x29C1, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @29C8 msg.gas // @29C9 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @29C9 stack[-2] // @29C9 stack[-5] // @29C9 stack[-4] // @29C9 stack[-3] // @29C9 stack[-6] // @29C9 memory[stack[-3]:stack[-3] + stack[-4]] // } 29C6 5B JUMPDEST 29C7 50 POP 29C8 5A GAS 29C9 FA STATICCALL 29CA 15 ISZERO 29CB 80 DUP1 29CC 15 ISZERO 29CD 61 PUSH2 0x29da 29D0 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @29C9 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @29CA stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x29da, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_29D1: // Incoming jump from 0x29D0, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @29D1 returndata.length // @29D5 returndata[0x00:0x00 + returndata.length] // @29D6 returndata.length // @29D9 memory[0x00:0x00 + returndata.length] // } 29D1 3D RETURNDATASIZE 29D2 60 PUSH1 0x00 29D4 80 DUP1 29D5 3E RETURNDATACOPY 29D6 3D RETURNDATASIZE 29D7 60 PUSH1 0x00 29D9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @29D5 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @29D9 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_29DA: // Incoming jump from 0x29D0, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @29E1 memory[0x40:0x60] // @29E2 returndata.length // } 29DA 5B JUMPDEST 29DB 50 POP 29DC 50 POP 29DD 50 POP 29DE 50 POP 29DF 60 PUSH1 0x40 29E1 51 MLOAD 29E2 3D RETURNDATASIZE 29E3 60 PUSH1 0x20 29E5 81 DUP2 29E6 10 LT 29E7 15 ISZERO 29E8 61 PUSH2 0x29f0 29EB 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @29E1 stack[-4] = memory[0x40:0x60] // @29E2 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x29f0, if !(returndata.length < 0x20) label_29EC: // Incoming jump from 0x29EB, if not !(returndata.length < 0x20) // Inputs[1] { @29EF memory[0x00:0x00] } 29EC 60 PUSH1 0x00 29EE 80 DUP1 29EF FD *REVERT // Stack delta = +0 // Outputs[1] { @29EF revert(memory[0x00:0x00]); } // Block terminates label_29F0: // Incoming jump from 0x29EB, if !(returndata.length < 0x20) // Inputs[7] // { // @29F2 memory[stack[-2]:stack[-2] + 0x20] // @29F2 stack[-2] // @29F6 memory[0x40:0x60] // @2A05 stack[-7] // @2A10 stack[-6] // @2A19 memory[0x40:0x60] // @2A37 address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } 29F0 5B JUMPDEST 29F1 50 POP 29F2 51 MLOAD 29F3 60 PUSH1 0x40 29F5 80 DUP1 29F6 51 MLOAD 29F7 63 PUSH4 0x214414d5 29FC 60 PUSH1 0xe0 29FE 1B SHL 29FF 81 DUP2 2A00 52 MSTORE 2A01 60 PUSH1 0x04 2A03 81 DUP2 2A04 01 ADD 2A05 88 DUP9 2A06 90 SWAP1 2A07 52 MSTORE 2A08 60 PUSH1 0x01 2A0A 60 PUSH1 0x01 2A0C 60 PUSH1 0xa0 2A0E 1B SHL 2A0F 03 SUB 2A10 87 DUP8 2A11 81 DUP2 2A12 16 AND 2A13 60 PUSH1 0x24 2A15 83 DUP4 2A16 01 ADD 2A17 52 MSTORE 2A18 91 SWAP2 2A19 51 MLOAD 2A1A 91 SWAP2 2A1B 90 SWAP1 2A1C 92 SWAP3 2A1D 16 AND 2A1E 91 SWAP2 2A1F 63 PUSH4 0x214414d5 2A24 91 SWAP2 2A25 60 PUSH1 0x44 2A27 80 DUP1 2A28 83 DUP4 2A29 01 ADD 2A2A 92 SWAP3 2A2B 60 PUSH1 0x20 2A2D 92 SWAP3 2A2E 91 SWAP2 2A2F 90 SWAP1 2A30 82 DUP3 2A31 90 SWAP1 2A32 03 SUB 2A33 01 ADD 2A34 81 DUP2 2A35 86 DUP7 2A36 80 DUP1 2A37 3B EXTCODESIZE 2A38 15 ISZERO 2A39 80 DUP1 2A3A 15 ISZERO 2A3B 61 PUSH2 0x2a43 2A3E 57 *JUMPI // Stack delta = +7 // Outputs[12] // { // @2A00 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x214414d5 << 0xe0 // @2A07 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-7] // @2A17 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @2A1E stack[-2] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @2A24 stack[-1] = 0x214414d5 // @2A2A stack[0] = memory[0x40:0x60] + 0x44 // @2A2D stack[1] = 0x20 // @2A2E stack[2] = memory[0x40:0x60] // @2A33 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @2A34 stack[4] = memory[0x40:0x60] // @2A35 stack[5] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @2A38 stack[6] = !address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x2a43, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length label_2A3F: // Incoming jump from 0x2A3E, if not !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @2A42 memory[0x00:0x00] } 2A3F 60 PUSH1 0x00 2A41 80 DUP1 2A42 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A42 revert(memory[0x00:0x00]); } // Block terminates label_2A43: // Incoming jump from 0x2A3E, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @2A45 msg.gas // @2A46 stack[-5] // @2A46 memory[stack[-3]:stack[-3] + stack[-4]] // @2A46 stack[-6] // @2A46 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2A46 stack[-4] // @2A46 stack[-2] // @2A46 stack[-3] // } 2A43 5B JUMPDEST 2A44 50 POP 2A45 5A GAS 2A46 FA STATICCALL 2A47 15 ISZERO 2A48 80 DUP1 2A49 15 ISZERO 2A4A 61 PUSH2 0x2a57 2A4D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2A46 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2A47 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2a57, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2A4E: // Incoming jump from 0x2A4D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2A4E returndata.length // @2A52 returndata[0x00:0x00 + returndata.length] // @2A53 returndata.length // @2A56 memory[0x00:0x00 + returndata.length] // } 2A4E 3D RETURNDATASIZE 2A4F 60 PUSH1 0x00 2A51 80 DUP1 2A52 3E RETURNDATACOPY 2A53 3D RETURNDATASIZE 2A54 60 PUSH1 0x00 2A56 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2A52 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2A56 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2A57: // Incoming jump from 0x2A4D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2A5E memory[0x40:0x60] // @2A5F returndata.length // } 2A57 5B JUMPDEST 2A58 50 POP 2A59 50 POP 2A5A 50 POP 2A5B 50 POP 2A5C 60 PUSH1 0x40 2A5E 51 MLOAD 2A5F 3D RETURNDATASIZE 2A60 60 PUSH1 0x20 2A62 81 DUP2 2A63 10 LT 2A64 15 ISZERO 2A65 61 PUSH2 0x2a6d 2A68 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2A5E stack[-4] = memory[0x40:0x60] // @2A5F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2a6d, if !(returndata.length < 0x20) label_2A69: // Incoming jump from 0x2A68, if not !(returndata.length < 0x20) // Inputs[1] { @2A6C memory[0x00:0x00] } 2A69 60 PUSH1 0x00 2A6B 80 DUP1 2A6C FD *REVERT // Stack delta = +0 // Outputs[1] { @2A6C revert(memory[0x00:0x00]); } // Block terminates label_2A6D: // Incoming jump from 0x2A68, if !(returndata.length < 0x20) // Inputs[7] // { // @2A6F stack[-2] // @2A6F memory[stack[-2]:stack[-2] + 0x20] // @2A73 memory[0x40:0x60] // @2A7F memory[0x40:0x60] // @2A81 stack[-3] // @2A8F stack[-4] // @2AAC address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 2A6D 5B JUMPDEST 2A6E 50 POP 2A6F 51 MLOAD 2A70 60 PUSH1 0x40 2A72 80 DUP1 2A73 51 MLOAD 2A74 63 PUSH4 0x59de7d41 2A79 60 PUSH1 0xe1 2A7B 1B SHL 2A7C 81 DUP2 2A7D 52 MSTORE 2A7E 90 SWAP1 2A7F 51 MLOAD 2A80 91 SWAP2 2A81 92 SWAP3 2A82 50 POP 2A83 61 PUSH2 0x2ab8 2A86 91 SWAP2 2A87 60 PUSH1 0x01 2A89 60 PUSH1 0x01 2A8B 60 PUSH1 0xa0 2A8D 1B SHL 2A8E 03 SUB 2A8F 85 DUP6 2A90 16 AND 2A91 91 SWAP2 2A92 63 PUSH4 0xb3bcfa82 2A97 91 SWAP2 2A98 60 PUSH1 0x04 2A9A 80 DUP1 2A9B 83 DUP4 2A9C 01 ADD 2A9D 92 SWAP3 2A9E 60 PUSH1 0x20 2AA0 92 SWAP3 2AA1 91 SWAP2 2AA2 90 SWAP1 2AA3 82 DUP3 2AA4 90 SWAP1 2AA5 03 SUB 2AA6 01 ADD 2AA7 81 DUP2 2AA8 60 PUSH1 0x00 2AAA 87 DUP8 2AAB 80 DUP1 2AAC 3B EXTCODESIZE 2AAD 15 ISZERO 2AAE 80 DUP1 2AAF 15 ISZERO 2AB0 61 PUSH2 0x1b2f 2AB3 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @2A7D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x59de7d41 << 0xe1 // @2A81 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @2A86 stack[-2] = 0x2ab8 // @2A91 stack[-1] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2A97 stack[0] = 0xb3bcfa82 // @2A9D stack[1] = memory[0x40:0x60] + 0x04 // @2AA0 stack[2] = 0x20 // @2AA1 stack[3] = memory[0x40:0x60] // @2AA6 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @2AA7 stack[5] = memory[0x40:0x60] // @2AA8 stack[6] = 0x00 // @2AAA stack[7] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2AAD stack[8] = !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional call to 0x1b2f, returns to 0x2AB8, if !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_2AB4: // Incoming jump from 0x2AB3, if not !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @2AB7 memory[0x00:0x00] } 2AB4 60 PUSH1 0x00 2AB6 80 DUP1 2AB7 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AB7 revert(memory[0x00:0x00]); } // Block terminates label_2AB8: // Incoming return from call to 0x1B2F at 0x2AB3 // Inputs[2] // { // @2AB9 stack[-7] // @2AB9 stack[-1] // } 2AB8 5B JUMPDEST 2AB9 95 SWAP6 2ABA 50 POP 2ABB 61 PUSH2 0x2b32 2ABE 56 *JUMP // Stack delta = -1 // Outputs[1] { @2AB9 stack[-7] = stack[-1] } // Block ends with unconditional jump to 0x2b32 label_2ABF: // Incoming jump from 0x297F, if !(stack[-6] == ~0x00) // Inputs[4] // { // @2AC3 stack[-2] // @2AD4 memory[0x40:0x60] // @2AE8 memory[0x40:0x60] // @2AF1 address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // } 2ABF 5B JUMPDEST 2AC0 61 PUSH2 0x2b2f 2AC3 82 DUP3 2AC4 60 PUSH1 0x01 2AC6 60 PUSH1 0x01 2AC8 60 PUSH1 0xa0 2ACA 1B SHL 2ACB 03 SUB 2ACC 16 AND 2ACD 63 PUSH4 0xb3bcfa82 2AD2 60 PUSH1 0x40 2AD4 51 MLOAD 2AD5 81 DUP2 2AD6 63 PUSH4 0xffffffff 2ADB 16 AND 2ADC 60 PUSH1 0xe0 2ADE 1B SHL 2ADF 81 DUP2 2AE0 52 MSTORE 2AE1 60 PUSH1 0x04 2AE3 01 ADD 2AE4 60 PUSH1 0x20 2AE6 60 PUSH1 0x40 2AE8 51 MLOAD 2AE9 80 DUP1 2AEA 83 DUP4 2AEB 03 SUB 2AEC 81 DUP2 2AED 60 PUSH1 0x00 2AEF 87 DUP8 2AF0 80 DUP1 2AF1 3B EXTCODESIZE 2AF2 15 ISZERO 2AF3 80 DUP1 2AF4 15 ISZERO 2AF5 61 PUSH2 0x2afd 2AF8 57 *JUMPI // Stack delta = +11 // Outputs[12] // { // @2AC0 stack[0] = 0x2b2f // @2ACC stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @2ACD stack[2] = 0xb3bcfa82 // @2AE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xb3bcfa82) << 0xe0 // @2AE3 stack[3] = 0x04 + memory[0x40:0x60] // @2AE4 stack[4] = 0x20 // @2AE8 stack[5] = memory[0x40:0x60] // @2AEB stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2AEC stack[7] = memory[0x40:0x60] // @2AED stack[8] = 0x00 // @2AEF stack[9] = (0x01 << 0xa0) - 0x01 & stack[-2] // @2AF2 stack[10] = !address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // } // Block ends with conditional jump to 0x2afd, if !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length label_2AF9: // Incoming jump from 0x2AF8, if not !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // Inputs[1] { @2AFC memory[0x00:0x00] } 2AF9 60 PUSH1 0x00 2AFB 80 DUP1 2AFC FD *REVERT // Stack delta = +0 // Outputs[1] { @2AFC revert(memory[0x00:0x00]); } // Block terminates label_2AFD: // Incoming jump from 0x2AF8, if !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // Inputs[9] // { // @2AFF msg.gas // @2B00 memory[stack[-4]:stack[-4] + stack[-5]] // @2B00 stack[-3] // @2B00 stack[-6] // @2B00 stack[-2] // @2B00 stack[-7] // @2B00 stack[-4] // @2B00 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2B00 stack[-5] // } 2AFD 5B JUMPDEST 2AFE 50 POP 2AFF 5A GAS 2B00 F1 CALL 2B01 15 ISZERO 2B02 80 DUP1 2B03 15 ISZERO 2B04 61 PUSH2 0x2b11 2B07 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2B00 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2B01 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2b11, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2B08: // Incoming jump from 0x2B07, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2B08 returndata.length // @2B0C returndata[0x00:0x00 + returndata.length] // @2B0D returndata.length // @2B10 memory[0x00:0x00 + returndata.length] // } 2B08 3D RETURNDATASIZE 2B09 60 PUSH1 0x00 2B0B 80 DUP1 2B0C 3E RETURNDATACOPY 2B0D 3D RETURNDATASIZE 2B0E 60 PUSH1 0x00 2B10 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2B0C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2B10 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2B11: // Incoming jump from 0x2B07, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @2B18 memory[0x40:0x60] // @2B19 returndata.length // } 2B11 5B JUMPDEST 2B12 50 POP 2B13 50 POP 2B14 50 POP 2B15 50 POP 2B16 60 PUSH1 0x40 2B18 51 MLOAD 2B19 3D RETURNDATASIZE 2B1A 60 PUSH1 0x20 2B1C 81 DUP2 2B1D 10 LT 2B1E 15 ISZERO 2B1F 61 PUSH2 0x2b27 2B22 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2B18 stack[-4] = memory[0x40:0x60] // @2B19 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2b27, if !(returndata.length < 0x20) label_2B23: // Incoming jump from 0x2B22, if not !(returndata.length < 0x20) // Inputs[1] { @2B26 memory[0x00:0x00] } 2B23 60 PUSH1 0x00 2B25 80 DUP1 2B26 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B26 revert(memory[0x00:0x00]); } // Block terminates label_2B27: // Incoming jump from 0x2B22, if !(returndata.length < 0x20) // Inputs[3] // { // @2B29 stack[-2] // @2B29 memory[stack[-2]:stack[-2] + 0x20] // @2B2A stack[-9] // } 2B27 5B JUMPDEST 2B28 50 POP 2B29 51 MLOAD 2B2A 87 DUP8 2B2B 61 PUSH2 0x3d50 2B2E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2B29 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @2B2A stack[-1] = stack[-9] // } // Block ends with unconditional jump to 0x3d50 2B2F 5B JUMPDEST 2B30 90 SWAP1 2B31 50 POP label_2B32: // Incoming jump from 0x2ABE // Inputs[8] // { // @2B36 memory[0x40:0x60] // @2B45 stack[-12] // @2B48 address(this) // @2B52 stack[-1] // @2B56 memory[0x40:0x60] // @2B5A memory[0x00:0x20] // @2B63 memory[0x00:0x20] // @2B80 address(memory[0x00:0x20]).code.length // } 2B32 5B JUMPDEST 2B33 60 PUSH1 0x40 2B35 80 DUP1 2B36 51 MLOAD 2B37 63 PUSH4 0x13771f07 2B3C 60 PUSH1 0xe3 2B3E 1B SHL 2B3F 81 DUP2 2B40 52 MSTORE 2B41 60 PUSH1 0x04 2B43 81 DUP2 2B44 01 ADD 2B45 8E DUP15 2B46 90 SWAP1 2B47 52 MSTORE 2B48 30 ADDRESS 2B49 60 PUSH1 0x24 2B4B 82 DUP3 2B4C 01 ADD 2B4D 52 MSTORE 2B4E 60 PUSH1 0x44 2B50 81 DUP2 2B51 01 ADD 2B52 83 DUP4 2B53 90 SWAP1 2B54 52 MSTORE 2B55 90 SWAP1 2B56 51 MLOAD 2B57 60 PUSH1 0x00 2B59 80 DUP1 2B5A 51 MLOAD 2B5B 60 PUSH1 0x20 2B5D 61 PUSH2 0x4418 2B60 83 DUP4 2B61 39 CODECOPY 2B62 81 DUP2 2B63 51 MLOAD 2B64 91 SWAP2 2B65 52 MSTORE 2B66 91 SWAP2 2B67 63 PUSH4 0x9bb8f838 2B6C 91 SWAP2 2B6D 60 PUSH1 0x64 2B6F 80 DUP1 2B70 83 DUP4 2B71 01 ADD 2B72 92 SWAP3 2B73 60 PUSH1 0x00 2B75 92 SWAP3 2B76 91 SWAP2 2B77 90 SWAP1 2B78 82 DUP3 2B79 90 SWAP1 2B7A 03 SUB 2B7B 01 ADD 2B7C 81 DUP2 2B7D 83 DUP4 2B7E 87 DUP8 2B7F 80 DUP1 2B80 3B EXTCODESIZE 2B81 15 ISZERO 2B82 80 DUP1 2B83 15 ISZERO 2B84 61 PUSH2 0x2b8c 2B87 57 *JUMPI // Stack delta = +10 // Outputs[16] // { // @2B40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x13771f07 << 0xe3 // @2B47 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-12] // @2B4D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = address(this) // @2B54 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @2B61 memory[0x00:0x20] = code[0x4418:0x4438] // @2B65 memory[0x00:0x20] = memory[0x00:0x20] // @2B66 stack[0] = memory[0x00:0x20] // @2B6C stack[1] = 0x9bb8f838 // @2B72 stack[2] = memory[0x40:0x60] + 0x64 // @2B75 stack[3] = 0x00 // @2B76 stack[4] = memory[0x40:0x60] // @2B7B stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @2B7C stack[6] = memory[0x40:0x60] // @2B7D stack[7] = 0x00 // @2B7E stack[8] = memory[0x00:0x20] // @2B81 stack[9] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x2b8c, if !!address(memory[0x00:0x20]).code.length label_2B88: // Incoming jump from 0x2B87, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @2B8B memory[0x00:0x00] } 2B88 60 PUSH1 0x00 2B8A 80 DUP1 2B8B FD *REVERT // Stack delta = +0 // Outputs[1] { @2B8B revert(memory[0x00:0x00]); } // Block terminates label_2B8C: // Incoming jump from 0x2B87, if !!address(memory[0x00:0x20]).code.length // Inputs[9] // { // @2B8E msg.gas // @2B8F stack[-7] // @2B8F stack[-4] // @2B8F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2B8F stack[-5] // @2B8F stack[-3] // @2B8F stack[-6] // @2B8F memory[stack[-4]:stack[-4] + stack[-5]] // @2B8F stack[-2] // } 2B8C 5B JUMPDEST 2B8D 50 POP 2B8E 5A GAS 2B8F F1 CALL 2B90 15 ISZERO 2B91 80 DUP1 2B92 15 ISZERO 2B93 61 PUSH2 0x2ba0 2B96 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2B8F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2B90 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2ba0, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2B97: // Incoming jump from 0x2B96, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2B97 returndata.length // @2B9B returndata[0x00:0x00 + returndata.length] // @2B9C returndata.length // @2B9F memory[0x00:0x00 + returndata.length] // } 2B97 3D RETURNDATASIZE 2B98 60 PUSH1 0x00 2B9A 80 DUP1 2B9B 3E RETURNDATACOPY 2B9C 3D RETURNDATASIZE 2B9D 60 PUSH1 0x00 2B9F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2B9B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2B9F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2BA0: // Incoming jump from 0x2B96, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2BA7 stack[-6] // @2BB8 memory[0x40:0x60] // @2BCC memory[0x40:0x60] // @2BD5 address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // } 2BA0 5B JUMPDEST 2BA1 50 POP 2BA2 50 POP 2BA3 50 POP 2BA4 50 POP 2BA5 60 PUSH1 0x00 2BA7 82 DUP3 2BA8 60 PUSH1 0x01 2BAA 60 PUSH1 0x01 2BAC 60 PUSH1 0xa0 2BAE 1B SHL 2BAF 03 SUB 2BB0 16 AND 2BB1 63 PUSH4 0x7bd2bea7 2BB6 60 PUSH1 0x40 2BB8 51 MLOAD 2BB9 81 DUP2 2BBA 63 PUSH4 0xffffffff 2BBF 16 AND 2BC0 60 PUSH1 0xe0 2BC2 1B SHL 2BC3 81 DUP2 2BC4 52 MSTORE 2BC5 60 PUSH1 0x04 2BC7 01 ADD 2BC8 60 PUSH1 0x20 2BCA 60 PUSH1 0x40 2BCC 51 MLOAD 2BCD 80 DUP1 2BCE 83 DUP4 2BCF 03 SUB 2BD0 81 DUP2 2BD1 60 PUSH1 0x00 2BD3 87 DUP8 2BD4 80 DUP1 2BD5 3B EXTCODESIZE 2BD6 15 ISZERO 2BD7 80 DUP1 2BD8 15 ISZERO 2BD9 61 PUSH2 0x2be1 2BDC 57 *JUMPI // Stack delta = +7 // Outputs[12] // { // @2BA5 stack[-4] = 0x00 // @2BB0 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-6] // @2BB1 stack[-2] = 0x7bd2bea7 // @2BC4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x7bd2bea7) << 0xe0 // @2BC7 stack[-1] = 0x04 + memory[0x40:0x60] // @2BC8 stack[0] = 0x20 // @2BCC stack[1] = memory[0x40:0x60] // @2BCF stack[2] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2BD0 stack[3] = memory[0x40:0x60] // @2BD1 stack[4] = 0x00 // @2BD3 stack[5] = (0x01 << 0xa0) - 0x01 & stack[-6] // @2BD6 stack[6] = !address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // } // Block ends with conditional jump to 0x2be1, if !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length label_2BDD: // Incoming jump from 0x2BDC, if not !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // Inputs[1] { @2BE0 memory[0x00:0x00] } 2BDD 60 PUSH1 0x00 2BDF 80 DUP1 2BE0 FD *REVERT // Stack delta = +0 // Outputs[1] { @2BE0 revert(memory[0x00:0x00]); } // Block terminates label_2BE1: // Incoming jump from 0x2BDC, if !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // Inputs[9] // { // @2BE3 msg.gas // @2BE4 stack[-6] // @2BE4 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2BE4 stack[-2] // @2BE4 memory[stack[-4]:stack[-4] + stack[-5]] // @2BE4 stack[-3] // @2BE4 stack[-4] // @2BE4 stack[-7] // @2BE4 stack[-5] // } 2BE1 5B JUMPDEST 2BE2 50 POP 2BE3 5A GAS 2BE4 F1 CALL 2BE5 15 ISZERO 2BE6 80 DUP1 2BE7 15 ISZERO 2BE8 61 PUSH2 0x2bf5 2BEB 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2BE4 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2BE5 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2bf5, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2BEC: // Incoming jump from 0x2BEB, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2BEC returndata.length // @2BF0 returndata[0x00:0x00 + returndata.length] // @2BF1 returndata.length // @2BF4 memory[0x00:0x00 + returndata.length] // } 2BEC 3D RETURNDATASIZE 2BED 60 PUSH1 0x00 2BEF 80 DUP1 2BF0 3E RETURNDATACOPY 2BF1 3D RETURNDATASIZE 2BF2 60 PUSH1 0x00 2BF4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2BF0 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2BF4 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2BF5: // Incoming jump from 0x2BEB, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @2BFC memory[0x40:0x60] // @2BFD returndata.length // } 2BF5 5B JUMPDEST 2BF6 50 POP 2BF7 50 POP 2BF8 50 POP 2BF9 50 POP 2BFA 60 PUSH1 0x40 2BFC 51 MLOAD 2BFD 3D RETURNDATASIZE 2BFE 60 PUSH1 0x20 2C00 81 DUP2 2C01 10 LT 2C02 15 ISZERO 2C03 61 PUSH2 0x2c0b 2C06 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2BFC stack[-4] = memory[0x40:0x60] // @2BFD stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2c0b, if !(returndata.length < 0x20) label_2C07: // Incoming jump from 0x2C06, if not !(returndata.length < 0x20) // Inputs[1] { @2C0A memory[0x00:0x00] } 2C07 60 PUSH1 0x00 2C09 80 DUP1 2C0A FD *REVERT // Stack delta = +0 // Outputs[1] { @2C0A revert(memory[0x00:0x00]); } // Block terminates label_2C0B: // Incoming jump from 0x2C06, if !(returndata.length < 0x20) // Inputs[9] // { // @2C0D memory[stack[-2]:stack[-2] + 0x20] // @2C0D stack[-2] // @2C11 memory[0x40:0x60] // @2C1C address(this) // @2C26 stack[-9] // @2C2A memory[0x40:0x60] // @2C2C stack[-3] // @2C36 stack[-5] // @2C53 address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // } 2C0B 5B JUMPDEST 2C0C 50 POP 2C0D 51 MLOAD 2C0E 60 PUSH1 0x40 2C10 80 DUP1 2C11 51 MLOAD 2C12 63 PUSH4 0xef693bed 2C17 60 PUSH1 0xe0 2C19 1B SHL 2C1A 81 DUP2 2C1B 52 MSTORE 2C1C 30 ADDRESS 2C1D 60 PUSH1 0x04 2C1F 82 DUP3 2C20 01 ADD 2C21 52 MSTORE 2C22 60 PUSH1 0x24 2C24 81 DUP2 2C25 01 ADD 2C26 8A DUP11 2C27 90 SWAP1 2C28 52 MSTORE 2C29 90 SWAP1 2C2A 51 MLOAD 2C2B 91 SWAP2 2C2C 92 SWAP3 2C2D 50 POP 2C2E 60 PUSH1 0x01 2C30 60 PUSH1 0x01 2C32 60 PUSH1 0xa0 2C34 1B SHL 2C35 03 SUB 2C36 85 DUP6 2C37 16 AND 2C38 91 SWAP2 2C39 63 PUSH4 0xef693bed 2C3E 91 SWAP2 2C3F 60 PUSH1 0x44 2C41 80 DUP1 2C42 82 DUP3 2C43 01 ADD 2C44 92 SWAP3 2C45 60 PUSH1 0x00 2C47 92 SWAP3 2C48 90 SWAP1 2C49 91 SWAP2 2C4A 90 SWAP1 2C4B 82 DUP3 2C4C 90 SWAP1 2C4D 03 SUB 2C4E 01 ADD 2C4F 81 DUP2 2C50 83 DUP4 2C51 87 DUP8 2C52 80 DUP1 2C53 3B EXTCODESIZE 2C54 15 ISZERO 2C55 80 DUP1 2C56 15 ISZERO 2C57 61 PUSH2 0x2c5f 2C5A 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @2C1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xef693bed << 0xe0 // @2C21 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @2C28 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-9] // @2C2C stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @2C38 stack[-2] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2C3E stack[-1] = 0xef693bed // @2C44 stack[0] = memory[0x40:0x60] + 0x44 // @2C47 stack[1] = 0x00 // @2C49 stack[2] = memory[0x40:0x60] // @2C4E stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @2C4F stack[4] = memory[0x40:0x60] // @2C50 stack[5] = 0x00 // @2C51 stack[6] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2C54 stack[7] = !address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x2c5f, if !!address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length label_2C5B: // Incoming jump from 0x2C5A, if not !!address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @2C5E memory[0x00:0x00] } 2C5B 60 PUSH1 0x00 2C5D 80 DUP1 2C5E FD *REVERT // Stack delta = +0 // Outputs[1] { @2C5E revert(memory[0x00:0x00]); } // Block terminates label_2C5F: // Incoming jump from 0x2C5A, if !!address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @2C61 msg.gas // @2C62 memory[stack[-4]:stack[-4] + stack[-5]] // @2C62 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2C62 stack[-3] // @2C62 stack[-5] // @2C62 stack[-4] // @2C62 stack[-2] // @2C62 stack[-7] // @2C62 stack[-6] // } 2C5F 5B JUMPDEST 2C60 50 POP 2C61 5A GAS 2C62 F1 CALL 2C63 15 ISZERO 2C64 80 DUP1 2C65 15 ISZERO 2C66 61 PUSH2 0x2c73 2C69 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2C62 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2C63 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2c73, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2C6A: // Incoming jump from 0x2C69, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2C6A returndata.length // @2C6E returndata[0x00:0x00 + returndata.length] // @2C6F returndata.length // @2C72 memory[0x00:0x00 + returndata.length] // } 2C6A 3D RETURNDATASIZE 2C6B 60 PUSH1 0x00 2C6D 80 DUP1 2C6E 3E RETURNDATACOPY 2C6F 3D RETURNDATASIZE 2C70 60 PUSH1 0x00 2C72 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2C6E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2C72 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2C73: // Incoming jump from 0x2C69, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @2C7B stack[-5] } 2C73 5B JUMPDEST 2C74 50 POP 2C75 50 POP 2C76 50 POP 2C77 50 POP 2C78 61 PUSH2 0x2c80 2C7B 81 DUP2 2C7C 61 PUSH2 0x3d1b 2C7F 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2C78 stack[-4] = 0x2c80 // @2C7B stack[-3] = stack[-5] // } // Block ends with call to 0x3d1b, returns to 0x2C80 label_2C80: // Incoming return from call to 0x3D1B at 0x2C7F // Inputs[1] { @2C81 stack[-1] } 2C80 5B JUMPDEST 2C81 15 ISZERO 2C82 61 PUSH2 0x2ce4 2C85 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2ce4, if !stack[-1] label_2C86: // Incoming jump from 0x2C85, if not !stack[-1] // Inputs[5] // { // @2C86 stack[-1] // @2C95 stack[-7] // @2C98 memory[0x40:0x60] // @2CB6 memory[0x40:0x60] // @2CBF address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } 2C86 80 DUP1 2C87 60 PUSH1 0x01 2C89 60 PUSH1 0x01 2C8B 60 PUSH1 0xa0 2C8D 1B SHL 2C8E 03 SUB 2C8F 16 AND 2C90 63 PUSH4 0x2e1a7d4d 2C95 88 DUP9 2C96 60 PUSH1 0x40 2C98 51 MLOAD 2C99 82 DUP3 2C9A 63 PUSH4 0xffffffff 2C9F 16 AND 2CA0 60 PUSH1 0xe0 2CA2 1B SHL 2CA3 81 DUP2 2CA4 52 MSTORE 2CA5 60 PUSH1 0x04 2CA7 01 ADD 2CA8 80 DUP1 2CA9 82 DUP3 2CAA 81 DUP2 2CAB 52 MSTORE 2CAC 60 PUSH1 0x20 2CAE 01 ADD 2CAF 91 SWAP2 2CB0 50 POP 2CB1 50 POP 2CB2 60 PUSH1 0x00 2CB4 60 PUSH1 0x40 2CB6 51 MLOAD 2CB7 80 DUP1 2CB8 83 DUP4 2CB9 03 SUB 2CBA 81 DUP2 2CBB 60 PUSH1 0x00 2CBD 87 DUP8 2CBE 80 DUP1 2CBF 3B EXTCODESIZE 2CC0 15 ISZERO 2CC1 80 DUP1 2CC2 15 ISZERO 2CC3 61 PUSH2 0x2ccb 2CC6 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @2C8F stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2C90 stack[1] = 0x2e1a7d4d // @2CA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2e1a7d4d) << 0xe0 // @2CAB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-7] // @2CAF stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @2CB2 stack[3] = 0x00 // @2CB6 stack[4] = memory[0x40:0x60] // @2CB9 stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2CBA stack[6] = memory[0x40:0x60] // @2CBB stack[7] = 0x00 // @2CBD stack[8] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2CC0 stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } // Block ends with conditional jump to 0x2ccb, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length label_2CC7: // Incoming jump from 0x2CC6, if not !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[1] { @2CCA memory[0x00:0x00] } 2CC7 60 PUSH1 0x00 2CC9 80 DUP1 2CCA FD *REVERT // Stack delta = +0 // Outputs[1] { @2CCA revert(memory[0x00:0x00]); } // Block terminates label_2CCB: // Incoming jump from 0x2CC6, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[9] // { // @2CCD msg.gas // @2CCE address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2CCE stack[-3] // @2CCE stack[-2] // @2CCE stack[-5] // @2CCE stack[-4] // @2CCE stack[-6] // @2CCE stack[-7] // @2CCE memory[stack[-4]:stack[-4] + stack[-5]] // } 2CCB 5B JUMPDEST 2CCC 50 POP 2CCD 5A GAS 2CCE F1 CALL 2CCF 15 ISZERO 2CD0 80 DUP1 2CD1 15 ISZERO 2CD2 61 PUSH2 0x2cdf 2CD5 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2CCE memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2CCF stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2cdf, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2CD6: // Incoming jump from 0x2CD5, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2CD6 returndata.length // @2CDA returndata[0x00:0x00 + returndata.length] // @2CDB returndata.length // @2CDE memory[0x00:0x00 + returndata.length] // } 2CD6 3D RETURNDATASIZE 2CD7 60 PUSH1 0x00 2CD9 80 DUP1 2CDA 3E RETURNDATACOPY 2CDB 3D RETURNDATASIZE 2CDC 60 PUSH1 0x00 2CDE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2CDA memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2CDE revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2CDF: // Incoming jump from 0x2CD5, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 2CDF 5B JUMPDEST 2CE0 50 POP 2CE1 50 POP 2CE2 50 POP 2CE3 50 POP // Stack delta = -4 // Block continues label_2CE4: // Incoming jump from 0x2C85, if !stack[-1] // Incoming jump from 0x2CE3 // Inputs[2] // { // @2CE8 stack[-10] // @2CE9 stack[-7] // } 2CE4 5B JUMPDEST 2CE5 61 PUSH2 0x2cee 2CE8 8A DUP11 2CE9 88 DUP9 2CEA 61 PUSH2 0x3b0e 2CED 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2CE5 stack[0] = 0x2cee // @2CE8 stack[1] = stack[-10] // @2CE9 stack[2] = stack[-7] // } // Block ends with call to 0x3b0e, returns to 0x2CEE label_2CEE: // Incoming return from call to 0x3B0E at 0x2CED // Inputs[12] // { // @2CF1 memory[0x40:0x60] // @2D0B memory[0x40:0x60] // @2D10 stack[-13] // @2D17 stack[-6] // @2D1F stack[-7] // @2D2B stack[-11] // @2D2C stack[-5] // @2D34 stack[-10] // @2D39 memory[0x40:0x60] // @2D4B stack[-9] // @2D4C stack[-14] // @2D50 stack[-12] // } 2CEE 5B JUMPDEST 2CEF 60 PUSH1 0x40 2CF1 51 MLOAD 2CF2 80 DUP1 2CF3 60 PUSH1 0x60 2CF5 01 ADD 2CF6 60 PUSH1 0x40 2CF8 52 MSTORE 2CF9 80 DUP1 2CFA 60 PUSH1 0x3e 2CFC 81 DUP2 2CFD 52 MSTORE 2CFE 60 PUSH1 0x20 2D00 01 ADD 2D01 61 PUSH2 0x4300 2D04 60 PUSH1 0x3e 2D06 91 SWAP2 2D07 39 CODECOPY 2D08 60 PUSH1 0x40 2D0A 80 DUP1 2D0B 51 MLOAD 2D0C 60 PUSH1 0x20 2D0E 81 DUP2 2D0F 01 ADD 2D10 9F SWAP16 2D11 90 SWAP1 2D12 9F SWAP16 2D13 52 MSTORE 2D14 8E DUP15 2D15 81 DUP2 2D16 01 ADD 2D17 97 SWAP8 2D18 90 SWAP1 2D19 97 SWAP8 2D1A 52 MSTORE 2D1B 60 PUSH1 0x60 2D1D 8E DUP15 2D1E 01 ADD 2D1F 97 SWAP8 2D20 90 SWAP1 2D21 97 SWAP8 2D22 52 MSTORE 2D23 50 POP 2D24 50 POP 2D25 50 POP 2D26 50 POP 2D27 60 PUSH1 0x80 2D29 89 DUP10 2D2A 01 ADD 2D2B 96 SWAP7 2D2C 90 SWAP1 2D2D 96 SWAP7 2D2E 52 MSTORE 2D2F 60 PUSH1 0xa0 2D31 80 DUP1 2D32 89 DUP10 2D33 01 ADD 2D34 95 SWAP6 2D35 90 SWAP1 2D36 95 SWAP6 2D37 52 MSTORE 2D38 80 DUP1 2D39 51 MLOAD 2D3A 80 DUP1 2D3B 89 DUP10 2D3C 03 SUB 2D3D 90 SWAP1 2D3E 95 SWAP6 2D3F 01 ADD 2D40 85 DUP6 2D41 52 MSTORE 2D42 60 PUSH1 0xc0 2D44 90 SWAP1 2D45 97 SWAP8 2D46 01 ADD 2D47 90 SWAP1 2D48 96 SWAP7 2D49 52 MSTORE 2D4A 50 POP 2D4B 93 SWAP4 2D4C 94 SWAP5 2D4D 90 SWAP1 2D4E 93 SWAP4 2D4F 50 POP 2D50 91 SWAP2 2D51 50 POP 2D52 50 POP 2D53 56 *JUMP // Stack delta = -12 // Outputs[12] // { // @2CF8 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @2CFD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3e // @2D07 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x3e] = code[0x4300:0x433e] // @2D13 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-13] // @2D1A memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-6] // @2D22 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-7] // @2D2E memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-11] // @2D37 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-10] // @2D41 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @2D49 memory[0x40:0x60] = memory[0x40:0x60] + 0xc0 // @2D4C stack[-14] = memory[0x40:0x60] // @2D4E stack[-13] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-14] label_2D54: // Incoming jump from 0x03FB // Inputs[2] // { // @2D5D stack[-2] // @2D5E stack[-3] // } 2D54 5B JUMPDEST 2D55 60 PUSH1 0x60 2D57 80 DUP1 2D58 60 PUSH1 0x00 2D5A 61 PUSH2 0x2d63 2D5D 85 DUP6 2D5E 87 DUP8 2D5F 61 PUSH2 0x3a55 2D62 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2D55 stack[0] = 0x60 // @2D57 stack[1] = 0x60 // @2D58 stack[2] = 0x00 // @2D5A stack[3] = 0x2d63 // @2D5D stack[4] = stack[-2] // @2D5E stack[5] = stack[-3] // } // Block ends with call to 0x3a55, returns to 0x2D63 label_2D63: // Incoming return from call to 0x3A55 at 0x2D62 // Inputs[3] // { // @2D64 stack[-1] // @2D64 stack[-2] // @2D6B stack[-8] // } 2D63 5B JUMPDEST 2D64 90 SWAP1 2D65 50 POP 2D66 60 PUSH1 0x00 2D68 61 PUSH2 0x2d70 2D6B 88 DUP9 2D6C 61 PUSH2 0x3804 2D6F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2D64 stack[-2] = stack[-1] // @2D66 stack[-1] = 0x00 // @2D68 stack[0] = 0x2d70 // @2D6B stack[1] = stack[-8] // } // Block ends with call to 0x3804, returns to 0x2D70 label_2D70: // Incoming return from call to 0x3804 at 0x2D6F // Inputs[2] // { // @2D71 stack[-1] // @2D71 stack[-2] // } 2D70 5B JUMPDEST 2D71 90 SWAP1 2D72 50 POP 2D73 60 PUSH1 0x00 2D75 80 DUP1 2D76 61 PUSH2 0x2d7e 2D79 83 DUP4 2D7A 61 PUSH2 0x3950 2D7D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2D71 stack[-2] = stack[-1] // @2D73 stack[-1] = 0x00 // @2D75 stack[0] = 0x00 // @2D76 stack[1] = 0x2d7e // @2D79 stack[2] = stack[-1] // } // Block ends with call to 0x3950, returns to 0x2D7E label_2D7E: // Incoming return from call to 0x3950 at 0x2D7D // Inputs[9] // { // @2D7F stack[-3] // @2D7F stack[-1] // @2D81 stack[-2] // @2D81 stack[-4] // @2D88 memory[0x00:0x20] // @2D91 memory[0x00:0x20] // @2DA4 memory[0x40:0x60] // @2DB8 memory[0x40:0x60] // @2DBF address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 2D7E 5B JUMPDEST 2D7F 91 SWAP2 2D80 50 POP 2D81 91 SWAP2 2D82 50 POP 2D83 60 PUSH1 0x00 2D85 60 PUSH1 0x00 2D87 80 DUP1 2D88 51 MLOAD 2D89 60 PUSH1 0x20 2D8B 61 PUSH2 0x4418 2D8E 83 DUP4 2D8F 39 CODECOPY 2D90 81 DUP2 2D91 51 MLOAD 2D92 91 SWAP2 2D93 52 MSTORE 2D94 60 PUSH1 0x01 2D96 60 PUSH1 0x01 2D98 60 PUSH1 0xa0 2D9A 1B SHL 2D9B 03 SUB 2D9C 16 AND 2D9D 63 PUSH4 0x36569e77 2DA2 60 PUSH1 0x40 2DA4 51 MLOAD 2DA5 81 DUP2 2DA6 63 PUSH4 0xffffffff 2DAB 16 AND 2DAC 60 PUSH1 0xe0 2DAE 1B SHL 2DAF 81 DUP2 2DB0 52 MSTORE 2DB1 60 PUSH1 0x04 2DB3 01 ADD 2DB4 60 PUSH1 0x20 2DB6 60 PUSH1 0x40 2DB8 51 MLOAD 2DB9 80 DUP1 2DBA 83 DUP4 2DBB 03 SUB 2DBC 81 DUP2 2DBD 86 DUP7 2DBE 80 DUP1 2DBF 3B EXTCODESIZE 2DC0 15 ISZERO 2DC1 80 DUP1 2DC2 15 ISZERO 2DC3 61 PUSH2 0x2dcb 2DC6 57 *JUMPI // Stack delta = +8 // Outputs[15] // { // @2D7F stack[-3] = stack[-1] // @2D81 stack[-4] = stack[-2] // @2D83 stack[-2] = 0x00 // @2D8F memory[0x00:0x20] = code[0x4418:0x4438] // @2D93 memory[0x00:0x20] = memory[0x00:0x20] // @2D9C stack[-1] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @2D9D stack[0] = 0x36569e77 // @2DB0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @2DB3 stack[1] = 0x04 + memory[0x40:0x60] // @2DB4 stack[2] = 0x20 // @2DB8 stack[3] = memory[0x40:0x60] // @2DBB stack[4] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2DBC stack[5] = memory[0x40:0x60] // @2DBD stack[6] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @2DC0 stack[7] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x2dcb, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_2DC7: // Incoming jump from 0x2DC6, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @2DCA memory[0x00:0x00] } 2DC7 60 PUSH1 0x00 2DC9 80 DUP1 2DCA FD *REVERT // Stack delta = +0 // Outputs[1] { @2DCA revert(memory[0x00:0x00]); } // Block terminates label_2DCB: // Incoming jump from 0x2DC6, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @2DCD msg.gas // @2DCE address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2DCE memory[stack[-3]:stack[-3] + stack[-4]] // @2DCE stack[-4] // @2DCE stack[-5] // @2DCE stack[-6] // @2DCE stack[-2] // @2DCE stack[-3] // } 2DCB 5B JUMPDEST 2DCC 50 POP 2DCD 5A GAS 2DCE FA STATICCALL 2DCF 15 ISZERO 2DD0 80 DUP1 2DD1 15 ISZERO 2DD2 61 PUSH2 0x2ddf 2DD5 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2DCE memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2DCF stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2ddf, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2DD6: // Incoming jump from 0x2DD5, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2DD6 returndata.length // @2DDA returndata[0x00:0x00 + returndata.length] // @2DDB returndata.length // @2DDE memory[0x00:0x00 + returndata.length] // } 2DD6 3D RETURNDATASIZE 2DD7 60 PUSH1 0x00 2DD9 80 DUP1 2DDA 3E RETURNDATACOPY 2DDB 3D RETURNDATASIZE 2DDC 60 PUSH1 0x00 2DDE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2DDA memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2DDE revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2DDF: // Incoming jump from 0x2DD5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2DE6 memory[0x40:0x60] // @2DE7 returndata.length // } 2DDF 5B JUMPDEST 2DE0 50 POP 2DE1 50 POP 2DE2 50 POP 2DE3 50 POP 2DE4 60 PUSH1 0x40 2DE6 51 MLOAD 2DE7 3D RETURNDATASIZE 2DE8 60 PUSH1 0x20 2DEA 81 DUP2 2DEB 10 LT 2DEC 15 ISZERO 2DED 61 PUSH2 0x2df5 2DF0 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2DE6 stack[-4] = memory[0x40:0x60] // @2DE7 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2df5, if !(returndata.length < 0x20) label_2DF1: // Incoming jump from 0x2DF0, if not !(returndata.length < 0x20) // Inputs[1] { @2DF4 memory[0x00:0x00] } 2DF1 60 PUSH1 0x00 2DF3 80 DUP1 2DF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @2DF4 revert(memory[0x00:0x00]); } // Block terminates label_2DF5: // Incoming jump from 0x2DF0, if !(returndata.length < 0x20) // Inputs[5] // { // @2DF7 stack[-2] // @2DF7 memory[stack[-2]:stack[-2] + 0x20] // @2DF8 stack[-3] // @2E00 stack[-5] // @2E01 stack[-4] // } 2DF5 5B JUMPDEST 2DF6 50 POP 2DF7 51 MLOAD 2DF8 90 SWAP1 2DF9 50 POP 2DFA 60 PUSH1 0x00 2DFC 61 PUSH2 0x2e06 2DFF 82 DUP3 2E00 85 DUP6 2E01 85 DUP6 2E02 61 PUSH2 0x3dcd 2E05 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @2DF8 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @2DFA stack[-2] = 0x00 // @2DFC stack[-1] = 0x2e06 // @2DFF stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2E00 stack[1] = stack[-5] // @2E01 stack[2] = stack[-4] // } // Block ends with unconditional jump to 0x3dcd 2E06 5B JUMPDEST 2E07 90 SWAP1 2E08 50 POP 2E09 60 PUSH1 0x00 2E0B 19 NOT 2E0C 86 DUP7 2E0D 14 EQ 2E0E 61 PUSH2 0x2e17 2E11 57 *JUMPI 2E12 85 DUP6 2E13 61 PUSH2 0x2e19 2E16 56 *JUMP 2E17 5B JUMPDEST 2E18 80 DUP1 2E19 5B JUMPDEST 2E1A 95 SWAP6 2E1B 50 POP 2E1C 85 DUP6 2E1D 81 DUP2 2E1E 10 LT 2E1F 15 ISZERO 2E20 61 PUSH2 0x2e65 2E23 57 *JUMPI 2E24 60 PUSH1 0x40 2E26 80 DUP1 2E27 51 MLOAD 2E28 62 PUSH3 0x461bcd 2E2C 60 PUSH1 0xe5 2E2E 1B SHL 2E2F 81 DUP2 2E30 52 MSTORE 2E31 60 PUSH1 0x20 2E33 60 PUSH1 0x04 2E35 82 DUP3 2E36 01 ADD 2E37 52 MSTORE 2E38 60 PUSH1 0x12 2E3A 60 PUSH1 0x24 2E3C 82 DUP3 2E3D 01 ADD 2E3E 52 MSTORE 2E3F 71 PUSH18 0x1c185e5a5b99cb595e18d95cdccb5919589d 2E52 60 PUSH1 0x72 2E54 1B SHL 2E55 60 PUSH1 0x44 2E57 82 DUP3 2E58 01 ADD 2E59 52 MSTORE 2E5A 90 SWAP1 2E5B 51 MLOAD 2E5C 90 SWAP1 2E5D 81 DUP2 2E5E 90 SWAP1 2E5F 03 SUB 2E60 60 PUSH1 0x64 2E62 01 ADD 2E63 90 SWAP1 2E64 FD *REVERT 2E65 5B JUMPDEST 2E66 60 PUSH1 0x00 2E68 80 DUP1 2E69 51 MLOAD 2E6A 60 PUSH1 0x20 2E6C 61 PUSH2 0x4293 2E6F 83 DUP4 2E70 39 CODECOPY 2E71 81 DUP2 2E72 51 MLOAD 2E73 91 SWAP2 2E74 52 MSTORE 2E75 60 PUSH1 0x01 2E77 60 PUSH1 0x01 2E79 60 PUSH1 0xa0 2E7B 1B SHL 2E7C 03 SUB 2E7D 16 AND 2E7E 63 PUSH4 0xf4b9fa75 2E83 60 PUSH1 0x40 2E85 51 MLOAD 2E86 81 DUP2 2E87 63 PUSH4 0xffffffff 2E8C 16 AND 2E8D 60 PUSH1 0xe0 2E8F 1B SHL 2E90 81 DUP2 2E91 52 MSTORE 2E92 60 PUSH1 0x04 2E94 01 ADD 2E95 60 PUSH1 0x20 2E97 60 PUSH1 0x40 2E99 51 MLOAD 2E9A 80 DUP1 2E9B 83 DUP4 2E9C 03 SUB 2E9D 81 DUP2 2E9E 60 PUSH1 0x00 2EA0 87 DUP8 2EA1 80 DUP1 2EA2 3B EXTCODESIZE 2EA3 15 ISZERO 2EA4 80 DUP1 2EA5 15 ISZERO 2EA6 61 PUSH2 0x2eae 2EA9 57 *JUMPI 2EAA 60 PUSH1 0x00 2EAC 80 DUP1 2EAD FD *REVERT 2EAE 5B JUMPDEST 2EAF 50 POP 2EB0 5A GAS 2EB1 F1 CALL 2EB2 15 ISZERO 2EB3 80 DUP1 2EB4 15 ISZERO 2EB5 61 PUSH2 0x2ec2 2EB8 57 *JUMPI 2EB9 3D RETURNDATASIZE 2EBA 60 PUSH1 0x00 2EBC 80 DUP1 2EBD 3E RETURNDATACOPY 2EBE 3D RETURNDATASIZE 2EBF 60 PUSH1 0x00 2EC1 FD *REVERT 2EC2 5B JUMPDEST 2EC3 50 POP 2EC4 50 POP 2EC5 50 POP 2EC6 50 POP 2EC7 60 PUSH1 0x40 2EC9 51 MLOAD 2ECA 3D RETURNDATASIZE 2ECB 60 PUSH1 0x20 2ECD 81 DUP2 2ECE 10 LT 2ECF 15 ISZERO 2ED0 61 PUSH2 0x2ed8 2ED3 57 *JUMPI 2ED4 60 PUSH1 0x00 2ED6 80 DUP1 2ED7 FD *REVERT 2ED8 5B JUMPDEST 2ED9 50 POP 2EDA 51 MLOAD 2EDB 60 PUSH1 0x40 2EDD 80 DUP1 2EDE 51 MLOAD 2EDF 63 PUSH4 0x095ea7b3 2EE4 60 PUSH1 0xe0 2EE6 1B SHL 2EE7 81 DUP2 2EE8 52 MSTORE 2EE9 60 PUSH1 0x00 2EEB 80 DUP1 2EEC 51 MLOAD 2EED 60 PUSH1 0x20 2EEF 61 PUSH2 0x4293 2EF2 83 DUP4 2EF3 39 CODECOPY 2EF4 81 DUP2 2EF5 51 MLOAD 2EF6 91 SWAP2 2EF7 52 MSTORE 2EF8 60 PUSH1 0x04 2EFA 82 DUP3 2EFB 01 ADD 2EFC 52 MSTORE 2EFD 60 PUSH1 0x24 2EFF 81 DUP2 2F00 01 ADD 2F01 89 DUP10 2F02 90 SWAP1 2F03 52 MSTORE 2F04 90 SWAP1 2F05 51 MLOAD 2F06 60 PUSH1 0x01 2F08 60 PUSH1 0x01 2F0A 60 PUSH1 0xa0 2F0C 1B SHL 2F0D 03 SUB 2F0E 90 SWAP1 2F0F 92 SWAP3 2F10 16 AND 2F11 91 SWAP2 2F12 63 PUSH4 0x095ea7b3 2F17 91 SWAP2 2F18 60 PUSH1 0x44 2F1A 80 DUP1 2F1B 82 DUP3 2F1C 01 ADD 2F1D 92 SWAP3 2F1E 60 PUSH1 0x00 2F20 92 SWAP3 2F21 90 SWAP1 2F22 91 SWAP2 2F23 90 SWAP1 2F24 82 DUP3 2F25 90 SWAP1 2F26 03 SUB 2F27 01 ADD 2F28 81 DUP2 2F29 83 DUP4 2F2A 87 DUP8 2F2B 80 DUP1 2F2C 3B EXTCODESIZE 2F2D 15 ISZERO 2F2E 80 DUP1 2F2F 15 ISZERO 2F30 61 PUSH2 0x2f38 2F33 57 *JUMPI 2F34 60 PUSH1 0x00 2F36 80 DUP1 2F37 FD *REVERT 2F38 5B JUMPDEST 2F39 50 POP 2F3A 5A GAS 2F3B F1 CALL 2F3C 15 ISZERO 2F3D 80 DUP1 2F3E 15 ISZERO 2F3F 61 PUSH2 0x2f4c 2F42 57 *JUMPI 2F43 3D RETURNDATASIZE 2F44 60 PUSH1 0x00 2F46 80 DUP1 2F47 3E RETURNDATACOPY 2F48 3D RETURNDATASIZE 2F49 60 PUSH1 0x00 2F4B FD *REVERT 2F4C 5B JUMPDEST 2F4D 50 POP 2F4E 50 POP 2F4F 60 PUSH1 0x40 2F51 80 DUP1 2F52 51 MLOAD 2F53 63 PUSH4 0x3b4da69f 2F58 60 PUSH1 0xe0 2F5A 1B SHL 2F5B 81 DUP2 2F5C 52 MSTORE 2F5D 60 PUSH1 0x01 2F5F 60 PUSH1 0x01 2F61 60 PUSH1 0xa0 2F63 1B SHL 2F64 03 SUB 2F65 87 DUP8 2F66 16 AND 2F67 60 PUSH1 0x04 2F69 82 DUP3 2F6A 01 ADD 2F6B 52 MSTORE 2F6C 60 PUSH1 0x24 2F6E 81 DUP2 2F6F 01 ADD 2F70 8A DUP11 2F71 90 SWAP1 2F72 52 MSTORE 2F73 90 SWAP1 2F74 51 MLOAD 2F75 60 PUSH1 0x00 2F77 80 DUP1 2F78 51 MLOAD 2F79 60 PUSH1 0x20 2F7B 61 PUSH2 0x4293 2F7E 83 DUP4 2F7F 39 CODECOPY 2F80 81 DUP2 2F81 51 MLOAD 2F82 91 SWAP2 2F83 52 MSTORE 2F84 93 SWAP4 2F85 50 POP 2F86 63 PUSH4 0x3b4da69f 2F8B 92 SWAP3 2F8C 50 POP 2F8D 60 PUSH1 0x44 2F8F 80 DUP1 2F90 83 DUP4 2F91 01 ADD 2F92 92 SWAP3 2F93 60 PUSH1 0x00 2F95 92 SWAP3 2F96 91 SWAP2 2F97 90 SWAP1 2F98 82 DUP3 2F99 90 SWAP1 2F9A 03 SUB 2F9B 01 ADD 2F9C 81 DUP2 2F9D 83 DUP4 2F9E 87 DUP8 2F9F 80 DUP1 2FA0 3B EXTCODESIZE 2FA1 15 ISZERO 2FA2 80 DUP1 2FA3 15 ISZERO 2FA4 61 PUSH2 0x2fac 2FA7 57 *JUMPI 2FA8 60 PUSH1 0x00 2FAA 80 DUP1 2FAB FD *REVERT 2FAC 5B JUMPDEST 2FAD 50 POP 2FAE 5A GAS 2FAF F1 CALL 2FB0 15 ISZERO 2FB1 80 DUP1 2FB2 15 ISZERO 2FB3 61 PUSH2 0x2fc0 2FB6 57 *JUMPI 2FB7 3D RETURNDATASIZE 2FB8 60 PUSH1 0x00 2FBA 80 DUP1 2FBB 3E RETURNDATACOPY 2FBC 3D RETURNDATASIZE 2FBD 60 PUSH1 0x00 2FBF FD *REVERT 2FC0 5B JUMPDEST 2FC1 50 POP 2FC2 50 POP 2FC3 50 POP 2FC4 50 POP 2FC5 60 PUSH1 0x00 2FC7 80 DUP1 2FC8 51 MLOAD 2FC9 60 PUSH1 0x20 2FCB 61 PUSH2 0x4418 2FCE 83 DUP4 2FCF 39 CODECOPY 2FD0 81 DUP2 2FD1 51 MLOAD 2FD2 91 SWAP2 2FD3 52 MSTORE 2FD4 60 PUSH1 0x01 2FD6 60 PUSH1 0x01 2FD8 60 PUSH1 0xa0 2FDA 1B SHL 2FDB 03 SUB 2FDC 16 AND 2FDD 63 PUSH4 0x45e6bdcd 2FE2 86 DUP7 2FE3 60 PUSH1 0x00 2FE5 61 PUSH2 0x3068 2FE8 86 DUP7 2FE9 87 DUP8 2FEA 60 PUSH1 0x01 2FEC 60 PUSH1 0x01 2FEE 60 PUSH1 0xa0 2FF0 1B SHL 2FF1 03 SUB 2FF2 16 AND 2FF3 63 PUSH4 0x6c25b346 2FF8 8A DUP11 2FF9 60 PUSH1 0x40 2FFB 51 MLOAD 2FFC 82 DUP3 2FFD 63 PUSH4 0xffffffff 3002 16 AND 3003 60 PUSH1 0xe0 3005 1B SHL 3006 81 DUP2 3007 52 MSTORE 3008 60 PUSH1 0x04 300A 01 ADD 300B 80 DUP1 300C 82 DUP3 300D 60 PUSH1 0x01 300F 60 PUSH1 0x01 3011 60 PUSH1 0xa0 3013 1B SHL 3014 03 SUB 3015 16 AND 3016 81 DUP2 3017 52 MSTORE 3018 60 PUSH1 0x20 301A 01 ADD 301B 91 SWAP2 301C 50 POP 301D 50 POP 301E 60 PUSH1 0x20 3020 60 PUSH1 0x40 3022 51 MLOAD 3023 80 DUP1 3024 83 DUP4 3025 03 SUB 3026 81 DUP2 3027 86 DUP7 3028 80 DUP1 3029 3B EXTCODESIZE 302A 15 ISZERO 302B 80 DUP1 302C 15 ISZERO 302D 61 PUSH2 0x3035 3030 57 *JUMPI 3031 60 PUSH1 0x00 3033 80 DUP1 3034 FD *REVERT 3035 5B JUMPDEST 3036 50 POP 3037 5A GAS 3038 FA STATICCALL 3039 15 ISZERO 303A 80 DUP1 303B 15 ISZERO 303C 61 PUSH2 0x3049 303F 57 *JUMPI 3040 3D RETURNDATASIZE 3041 60 PUSH1 0x00 3043 80 DUP1 3044 3E RETURNDATACOPY 3045 3D RETURNDATASIZE 3046 60 PUSH1 0x00 3048 FD *REVERT 3049 5B JUMPDEST 304A 50 POP 304B 50 POP 304C 50 POP 304D 50 POP 304E 60 PUSH1 0x40 3050 51 MLOAD 3051 3D RETURNDATASIZE 3052 60 PUSH1 0x20 3054 81 DUP2 3055 10 LT 3056 15 ISZERO 3057 61 PUSH2 0x305f 305A 57 *JUMPI 305B 60 PUSH1 0x00 305D 80 DUP1 305E FD *REVERT 305F 5B JUMPDEST 3060 50 POP 3061 51 MLOAD 3062 89 DUP10 3063 8B DUP12 3064 61 PUSH2 0x3f9a 3067 56 *JUMP 3068 5B JUMPDEST 3069 60 PUSH1 0x40 306B 51 MLOAD 306C 84 DUP5 306D 63 PUSH4 0xffffffff 3072 16 AND 3073 60 PUSH1 0xe0 3075 1B SHL 3076 81 DUP2 3077 52 MSTORE 3078 60 PUSH1 0x04 307A 01 ADD 307B 80 DUP1 307C 84 DUP5 307D 81 DUP2 307E 52 MSTORE 307F 60 PUSH1 0x20 3081 01 ADD 3082 83 DUP4 3083 81 DUP2 3084 52 MSTORE 3085 60 PUSH1 0x20 3087 01 ADD 3088 82 DUP3 3089 81 DUP2 308A 52 MSTORE 308B 60 PUSH1 0x20 308D 01 ADD 308E 93 SWAP4 308F 50 POP 3090 50 POP 3091 50 POP 3092 50 POP 3093 60 PUSH1 0x00 3095 60 PUSH1 0x40 3097 51 MLOAD 3098 80 DUP1 3099 83 DUP4 309A 03 SUB 309B 81 DUP2 309C 60 PUSH1 0x00 309E 87 DUP8 309F 80 DUP1 30A0 3B EXTCODESIZE 30A1 15 ISZERO 30A2 80 DUP1 30A3 15 ISZERO 30A4 61 PUSH2 0x30ac 30A7 57 *JUMPI 30A8 60 PUSH1 0x00 30AA 80 DUP1 30AB FD *REVERT 30AC 5B JUMPDEST 30AD 50 POP 30AE 5A GAS 30AF F1 CALL 30B0 15 ISZERO 30B1 80 DUP1 30B2 15 ISZERO 30B3 61 PUSH2 0x30c0 30B6 57 *JUMPI 30B7 3D RETURNDATASIZE 30B8 60 PUSH1 0x00 30BA 80 DUP1 30BB 3E RETURNDATACOPY 30BC 3D RETURNDATASIZE 30BD 60 PUSH1 0x00 30BF FD *REVERT 30C0 5B JUMPDEST 30C1 50 POP 30C2 50 POP 30C3 50 POP 30C4 50 POP 30C5 61 PUSH2 0x30ce 30C8 89 DUP10 30C9 87 DUP8 30CA 61 PUSH2 0x3b0e 30CD 56 *JUMP 30CE 5B JUMPDEST 30CF 60 PUSH1 0x40 30D1 51 MLOAD 30D2 80 DUP1 30D3 60 PUSH1 0x60 30D5 01 ADD 30D6 60 PUSH1 0x40 30D8 52 MSTORE 30D9 80 DUP1 30DA 60 PUSH1 0x33 30DC 81 DUP2 30DD 52 MSTORE 30DE 60 PUSH1 0x20 30E0 01 ADD 30E1 61 PUSH2 0x4391 30E4 60 PUSH1 0x33 30E6 91 SWAP2 30E7 39 CODECOPY 30E8 60 PUSH1 0x40 30EA 80 DUP1 30EB 51 MLOAD 30EC 60 PUSH1 0x20 30EE 81 DUP2 30EF 01 ADD 30F0 97 SWAP8 30F1 90 SWAP1 30F2 97 SWAP8 30F3 52 MSTORE 30F4 86 DUP7 30F5 81 DUP2 30F6 01 ADD 30F7 95 SWAP6 30F8 90 SWAP1 30F9 95 SWAP6 30FA 52 MSTORE 30FB 60 PUSH1 0x60 30FD 86 DUP7 30FE 01 ADD 30FF 96 SWAP7 3100 90 SWAP1 3101 96 SWAP7 3102 52 MSTORE 3103 50 POP 3104 50 POP 3105 50 POP 3106 60 PUSH1 0x80 3108 82 DUP3 3109 01 ADD 310A 96 SWAP7 310B 90 SWAP1 310C 96 SWAP7 310D 52 MSTORE 310E 60 PUSH1 0xa0 3110 80 DUP1 3111 82 DUP3 3112 01 ADD 3113 95 SWAP6 3114 90 SWAP1 3115 95 SWAP6 3116 52 MSTORE 3117 85 DUP6 3118 51 MLOAD 3119 80 DUP1 311A 82 DUP3 311B 03 SUB 311C 90 SWAP1 311D 95 SWAP6 311E 01 ADD 311F 85 DUP6 3120 52 MSTORE 3121 60 PUSH1 0xc0 3123 01 ADD 3124 90 SWAP1 3125 94 SWAP5 3126 52 MSTORE 3127 50 POP 3128 91 SWAP2 3129 94 SWAP5 312A 90 SWAP1 312B 93 SWAP4 312C 50 POP 312D 91 SWAP2 312E 50 POP 312F 50 POP 3130 56 *JUMP label_3131: // Incoming jump from 0x0424 // Inputs[2] // { // @313A stack[-2] // @313B stack[-3] // } 3131 5B JUMPDEST 3132 60 PUSH1 0x60 3134 80 DUP1 3135 60 PUSH1 0x00 3137 61 PUSH2 0x3140 313A 85 DUP6 313B 87 DUP8 313C 61 PUSH2 0x3a55 313F 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3132 stack[0] = 0x60 // @3134 stack[1] = 0x60 // @3135 stack[2] = 0x00 // @3137 stack[3] = 0x3140 // @313A stack[4] = stack[-2] // @313B stack[5] = stack[-3] // } // Block ends with call to 0x3a55, returns to 0x3140 label_3140: // Incoming return from call to 0x3A55 at 0x313F // Inputs[7] // { // @3141 stack[-1] // @3141 stack[-2] // @3148 memory[0x00:0x20] // @3151 memory[0x00:0x20] // @3164 memory[0x40:0x60] // @3178 memory[0x40:0x60] // @3181 address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 3140 5B JUMPDEST 3141 90 SWAP1 3142 50 POP 3143 60 PUSH1 0x00 3145 60 PUSH1 0x00 3147 80 DUP1 3148 51 MLOAD 3149 60 PUSH1 0x20 314B 61 PUSH2 0x4293 314E 83 DUP4 314F 39 CODECOPY 3150 81 DUP2 3151 51 MLOAD 3152 91 SWAP2 3153 52 MSTORE 3154 60 PUSH1 0x01 3156 60 PUSH1 0x01 3158 60 PUSH1 0xa0 315A 1B SHL 315B 03 SUB 315C 16 AND 315D 63 PUSH4 0x36569e77 3162 60 PUSH1 0x40 3164 51 MLOAD 3165 81 DUP2 3166 63 PUSH4 0xffffffff 316B 16 AND 316C 60 PUSH1 0xe0 316E 1B SHL 316F 81 DUP2 3170 52 MSTORE 3171 60 PUSH1 0x04 3173 01 ADD 3174 60 PUSH1 0x20 3176 60 PUSH1 0x40 3178 51 MLOAD 3179 80 DUP1 317A 83 DUP4 317B 03 SUB 317C 81 DUP2 317D 60 PUSH1 0x00 317F 87 DUP8 3180 80 DUP1 3181 3B EXTCODESIZE 3182 15 ISZERO 3183 80 DUP1 3184 15 ISZERO 3185 61 PUSH2 0x318d 3188 57 *JUMPI // Stack delta = +10 // Outputs[15] // { // @3141 stack[-2] = stack[-1] // @3143 stack[-1] = 0x00 // @314F memory[0x00:0x20] = code[0x4293:0x42b3] // @3153 memory[0x00:0x20] = memory[0x00:0x20] // @315C stack[0] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @315D stack[1] = 0x36569e77 // @3170 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x36569e77) << 0xe0 // @3173 stack[2] = 0x04 + memory[0x40:0x60] // @3174 stack[3] = 0x20 // @3178 stack[4] = memory[0x40:0x60] // @317B stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @317C stack[6] = memory[0x40:0x60] // @317D stack[7] = 0x00 // @317F stack[8] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @3182 stack[9] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x318d, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_3189: // Incoming jump from 0x3188, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @318C memory[0x00:0x00] } 3189 60 PUSH1 0x00 318B 80 DUP1 318C FD *REVERT // Stack delta = +0 // Outputs[1] { @318C revert(memory[0x00:0x00]); } // Block terminates label_318D: // Incoming jump from 0x3188, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[9] // { // @318F msg.gas // @3190 stack[-6] // @3190 stack[-4] // @3190 stack[-7] // @3190 stack[-3] // @3190 stack[-5] // @3190 memory[stack[-4]:stack[-4] + stack[-5]] // @3190 stack[-2] // @3190 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 318D 5B JUMPDEST 318E 50 POP 318F 5A GAS 3190 F1 CALL 3191 15 ISZERO 3192 80 DUP1 3193 15 ISZERO 3194 61 PUSH2 0x31a1 3197 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @3190 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3191 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x31a1, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3198: // Incoming jump from 0x3197, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3198 returndata.length // @319C returndata[0x00:0x00 + returndata.length] // @319D returndata.length // @31A0 memory[0x00:0x00 + returndata.length] // } 3198 3D RETURNDATASIZE 3199 60 PUSH1 0x00 319B 80 DUP1 319C 3E RETURNDATACOPY 319D 3D RETURNDATASIZE 319E 60 PUSH1 0x00 31A0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @319C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @31A0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_31A1: // Incoming jump from 0x3197, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @31A8 memory[0x40:0x60] // @31A9 returndata.length // } 31A1 5B JUMPDEST 31A2 50 POP 31A3 50 POP 31A4 50 POP 31A5 50 POP 31A6 60 PUSH1 0x40 31A8 51 MLOAD 31A9 3D RETURNDATASIZE 31AA 60 PUSH1 0x20 31AC 81 DUP2 31AD 10 LT 31AE 15 ISZERO 31AF 61 PUSH2 0x31b7 31B2 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @31A8 stack[-4] = memory[0x40:0x60] // @31A9 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x31b7, if !(returndata.length < 0x20) label_31B3: // Incoming jump from 0x31B2, if not !(returndata.length < 0x20) // Inputs[1] { @31B6 memory[0x00:0x00] } 31B3 60 PUSH1 0x00 31B5 80 DUP1 31B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @31B6 revert(memory[0x00:0x00]); } // Block terminates label_31B7: // Incoming jump from 0x31B2, if !(returndata.length < 0x20) // Inputs[6] // { // @31B9 memory[stack[-2]:stack[-2] + 0x20] // @31B9 stack[-2] // @31BD memory[0x40:0x60] // @31C9 memory[0x40:0x60] // @31CB stack[-3] // @31FF address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // } 31B7 5B JUMPDEST 31B8 50 POP 31B9 51 MLOAD 31BA 60 PUSH1 0x40 31BC 80 DUP1 31BD 51 MLOAD 31BE 63 PUSH4 0x4fb3c665 31C3 60 PUSH1 0xe1 31C5 1B SHL 31C6 81 DUP2 31C7 52 MSTORE 31C8 90 SWAP1 31C9 51 MLOAD 31CA 91 SWAP2 31CB 92 SWAP3 31CC 50 POP 31CD 60 PUSH1 0x00 31CF 91 SWAP2 31D0 73 PUSH20 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 31E5 91 SWAP2 31E6 63 PUSH4 0x9f678cca 31EB 91 SWAP2 31EC 60 PUSH1 0x04 31EE 80 DUP1 31EF 83 DUP4 31F0 01 ADD 31F1 92 SWAP3 31F2 60 PUSH1 0x20 31F4 92 SWAP3 31F5 91 SWAP2 31F6 90 SWAP1 31F7 82 DUP3 31F8 90 SWAP1 31F9 03 SUB 31FA 01 ADD 31FB 81 DUP2 31FC 87 DUP8 31FD 87 DUP8 31FE 80 DUP1 31FF 3B EXTCODESIZE 3200 15 ISZERO 3201 80 DUP1 3202 15 ISZERO 3203 61 PUSH2 0x320b 3206 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @31C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4fb3c665 << 0xe1 // @31CB stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @31CF stack[-2] = 0x00 // @31E5 stack[-1] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @31EB stack[0] = 0x9f678cca // @31F1 stack[1] = memory[0x40:0x60] + 0x04 // @31F4 stack[2] = 0x20 // @31F5 stack[3] = memory[0x40:0x60] // @31FA stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @31FB stack[5] = memory[0x40:0x60] // @31FC stack[6] = 0x00 // @31FD stack[7] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @3200 stack[8] = !address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // } // Block ends with conditional jump to 0x320b, if !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length label_3207: // Incoming jump from 0x3206, if not !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // Inputs[1] { @320A memory[0x00:0x00] } 3207 60 PUSH1 0x00 3209 80 DUP1 320A FD *REVERT // Stack delta = +0 // Outputs[1] { @320A revert(memory[0x00:0x00]); } // Block terminates label_320B: // Incoming jump from 0x3206, if !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // Inputs[9] // { // @320D msg.gas // @320E stack[-6] // @320E address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @320E stack[-5] // @320E stack[-3] // @320E stack[-2] // @320E memory[stack[-4]:stack[-4] + stack[-5]] // @320E stack[-4] // @320E stack[-7] // } 320B 5B JUMPDEST 320C 50 POP 320D 5A GAS 320E F1 CALL 320F 15 ISZERO 3210 80 DUP1 3211 15 ISZERO 3212 61 PUSH2 0x321f 3215 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @320E memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @320F stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x321f, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3216: // Incoming jump from 0x3215, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3216 returndata.length // @321A returndata[0x00:0x00 + returndata.length] // @321B returndata.length // @321E memory[0x00:0x00 + returndata.length] // } 3216 3D RETURNDATASIZE 3217 60 PUSH1 0x00 3219 80 DUP1 321A 3E RETURNDATACOPY 321B 3D RETURNDATASIZE 321C 60 PUSH1 0x00 321E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @321A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @321E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_321F: // Incoming jump from 0x3215, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @3226 memory[0x40:0x60] // @3227 returndata.length // } 321F 5B JUMPDEST 3220 50 POP 3221 50 POP 3222 50 POP 3223 50 POP 3224 60 PUSH1 0x40 3226 51 MLOAD 3227 3D RETURNDATASIZE 3228 60 PUSH1 0x20 322A 81 DUP2 322B 10 LT 322C 15 ISZERO 322D 61 PUSH2 0x3235 3230 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3226 stack[-4] = memory[0x40:0x60] // @3227 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3235, if !(returndata.length < 0x20) label_3231: // Incoming jump from 0x3230, if not !(returndata.length < 0x20) // Inputs[1] { @3234 memory[0x00:0x00] } 3231 60 PUSH1 0x00 3233 80 DUP1 3234 FD *REVERT // Stack delta = +0 // Outputs[1] { @3234 revert(memory[0x00:0x00]); } // Block terminates label_3235: // Incoming jump from 0x3230, if !(returndata.length < 0x20) // Inputs[4] // { // @3237 memory[stack[-2]:stack[-2] + 0x20] // @3237 stack[-2] // @3238 stack[-3] // @323F stack[-5] // } 3235 5B JUMPDEST 3236 50 POP 3237 51 MLOAD 3238 90 SWAP1 3239 50 POP 323A 60 PUSH1 0x00 323C 60 PUSH1 0x00 323E 19 NOT 323F 84 DUP5 3240 14 EQ 3241 15 ISZERO 3242 61 PUSH2 0x32e9 3245 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @3238 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @323A stack[-2] = 0x00 // } // Block ends with conditional jump to 0x32e9, if !(stack[-5] == ~0x00) label_3246: // Incoming jump from 0x3245, if not !(stack[-5] == ~0x00) // Inputs[4] // { // @3249 memory[0x40:0x60] // @3254 address(this) // @325B memory[0x40:0x60] // @328A address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // } 3246 60 PUSH1 0x40 3248 80 DUP1 3249 51 MLOAD 324A 63 PUSH4 0x05f5d643 324F 60 PUSH1 0xe1 3251 1B SHL 3252 81 DUP2 3253 52 MSTORE 3254 30 ADDRESS 3255 60 PUSH1 0x04 3257 82 DUP3 3258 01 ADD 3259 52 MSTORE 325A 90 SWAP1 325B 51 MLOAD 325C 73 PUSH20 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 3271 91 SWAP2 3272 63 PUSH4 0x0bebac86 3277 91 SWAP2 3278 60 PUSH1 0x24 327A 80 DUP1 327B 83 DUP4 327C 01 ADD 327D 92 SWAP3 327E 60 PUSH1 0x20 3280 92 SWAP3 3281 91 SWAP2 3282 90 SWAP1 3283 82 DUP3 3284 90 SWAP1 3285 03 SUB 3286 01 ADD 3287 81 DUP2 3288 86 DUP7 3289 80 DUP1 328A 3B EXTCODESIZE 328B 15 ISZERO 328C 80 DUP1 328D 15 ISZERO 328E 61 PUSH2 0x3296 3291 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @3253 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x05f5d643 << 0xe1 // @3259 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @3271 stack[0] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @3277 stack[1] = 0x0bebac86 // @327D stack[2] = memory[0x40:0x60] + 0x24 // @3280 stack[3] = 0x20 // @3281 stack[4] = memory[0x40:0x60] // @3286 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @3287 stack[6] = memory[0x40:0x60] // @3288 stack[7] = 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 // @328B stack[8] = !address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // } // Block ends with conditional jump to 0x3296, if !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length label_3292: // Incoming jump from 0x3291, if not !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // Inputs[1] { @3295 memory[0x00:0x00] } 3292 60 PUSH1 0x00 3294 80 DUP1 3295 FD *REVERT // Stack delta = +0 // Outputs[1] { @3295 revert(memory[0x00:0x00]); } // Block terminates label_3296: // Incoming jump from 0x3291, if !!address(0x197e90f9fad81970ba7976f33cbd77088e5d7cf7).code.length // Inputs[8] // { // @3298 msg.gas // @3299 stack[-5] // @3299 memory[stack[-3]:stack[-3] + stack[-4]] // @3299 stack[-6] // @3299 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3299 stack[-4] // @3299 stack[-2] // @3299 stack[-3] // } 3296 5B JUMPDEST 3297 50 POP 3298 5A GAS 3299 FA STATICCALL 329A 15 ISZERO 329B 80 DUP1 329C 15 ISZERO 329D 61 PUSH2 0x32aa 32A0 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3299 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @329A stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x32aa, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_32A1: // Incoming jump from 0x32A0, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @32A1 returndata.length // @32A5 returndata[0x00:0x00 + returndata.length] // @32A6 returndata.length // @32A9 memory[0x00:0x00 + returndata.length] // } 32A1 3D RETURNDATASIZE 32A2 60 PUSH1 0x00 32A4 80 DUP1 32A5 3E RETURNDATACOPY 32A6 3D RETURNDATASIZE 32A7 60 PUSH1 0x00 32A9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @32A5 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @32A9 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_32AA: // Incoming jump from 0x32A0, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @32B1 memory[0x40:0x60] // @32B2 returndata.length // } 32AA 5B JUMPDEST 32AB 50 POP 32AC 50 POP 32AD 50 POP 32AE 50 POP 32AF 60 PUSH1 0x40 32B1 51 MLOAD 32B2 3D RETURNDATASIZE 32B3 60 PUSH1 0x20 32B5 81 DUP2 32B6 10 LT 32B7 15 ISZERO 32B8 61 PUSH2 0x32c0 32BB 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @32B1 stack[-4] = memory[0x40:0x60] // @32B2 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x32c0, if !(returndata.length < 0x20) label_32BC: // Incoming jump from 0x32BB, if not !(returndata.length < 0x20) // Inputs[1] { @32BF memory[0x00:0x00] } 32BC 60 PUSH1 0x00 32BE 80 DUP1 32BF FD *REVERT // Stack delta = +0 // Outputs[1] { @32BF revert(memory[0x00:0x00]); } // Block terminates label_32C0: // Incoming jump from 0x32BB, if !(returndata.length < 0x20) // Inputs[4] // { // @32C2 stack[-2] // @32C2 memory[stack[-2]:stack[-2] + 0x20] // @32C3 stack[-3] // @32D4 stack[-4] // } 32C0 5B JUMPDEST 32C1 50 POP 32C2 51 MLOAD 32C3 90 SWAP1 32C4 50 POP 32C5 67 PUSH8 0x6765c793fa10079d 32CE 60 PUSH1 0x1b 32D0 1B SHL 32D1 61 PUSH2 0x32da 32D4 83 DUP4 32D5 83 DUP4 32D6 61 PUSH2 0x3da8 32D9 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @32C3 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @32D0 stack[-2] = 0x6765c793fa10079d << 0x1b // @32D1 stack[-1] = 0x32da // @32D4 stack[0] = stack[-4] // @32D5 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x3da8 32DA 5B JUMPDEST 32DB 81 DUP2 32DC 61 PUSH2 0x32e1 32DF 57 *JUMPI 32E0 FE *ASSERT 32E1 5B JUMPDEST 32E2 04 DIV 32E3 93 SWAP4 32E4 50 POP 32E5 61 PUSH2 0x330a 32E8 56 *JUMP label_32E9: // Incoming jump from 0x3245, if !(stack[-5] == ~0x00) // Inputs[2] // { // @32EA stack[-2] // @32EE stack[-4] // } 32E9 5B JUMPDEST 32EA 81 DUP2 32EB 61 PUSH2 0x32ff 32EE 85 DUP6 32EF 67 PUSH8 0x6765c793fa10079d 32F8 60 PUSH1 0x1b 32FA 1B SHL 32FB 61 PUSH2 0x3da8 32FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @32EA stack[0] = stack[-2] // @32EB stack[1] = 0x32ff // @32EE stack[2] = stack[-4] // @32FA stack[3] = 0x6765c793fa10079d << 0x1b // } // Block ends with unconditional jump to 0x3da8 32FF 5B JUMPDEST 3300 81 DUP2 3301 61 PUSH2 0x3306 3304 57 *JUMPI 3305 FE *ASSERT 3306 5B JUMPDEST 3307 04 DIV 3308 90 SWAP1 3309 50 POP 330A 5B JUMPDEST 330B 73 PUSH20 0x197e90f9fad81970ba7976f33cbd77088e5d7cf7 3320 60 PUSH1 0x01 3322 60 PUSH1 0x01 3324 60 PUSH1 0xa0 3326 1B SHL 3327 03 SUB 3328 16 AND 3329 63 PUSH4 0x7f8661a1 332E 82 DUP3 332F 60 PUSH1 0x40 3331 51 MLOAD 3332 82 DUP3 3333 63 PUSH4 0xffffffff 3338 16 AND 3339 60 PUSH1 0xe0 333B 1B SHL 333C 81 DUP2 333D 52 MSTORE 333E 60 PUSH1 0x04 3340 01 ADD 3341 80 DUP1 3342 82 DUP3 3343 81 DUP2 3344 52 MSTORE 3345 60 PUSH1 0x20 3347 01 ADD 3348 91 SWAP2 3349 50 POP 334A 50 POP 334B 60 PUSH1 0x00 334D 60 PUSH1 0x40 334F 51 MLOAD 3350 80 DUP1 3351 83 DUP4 3352 03 SUB 3353 81 DUP2 3354 60 PUSH1 0x00 3356 87 DUP8 3357 80 DUP1 3358 3B EXTCODESIZE 3359 15 ISZERO 335A 80 DUP1 335B 15 ISZERO 335C 61 PUSH2 0x3364 335F 57 *JUMPI 3360 60 PUSH1 0x00 3362 80 DUP1 3363 FD *REVERT 3364 5B JUMPDEST 3365 50 POP 3366 5A GAS 3367 F1 CALL 3368 15 ISZERO 3369 80 DUP1 336A 15 ISZERO 336B 61 PUSH2 0x3378 336E 57 *JUMPI 336F 3D RETURNDATASIZE 3370 60 PUSH1 0x00 3372 80 DUP1 3373 3E RETURNDATACOPY 3374 3D RETURNDATASIZE 3375 60 PUSH1 0x00 3377 FD *REVERT 3378 5B JUMPDEST 3379 50 POP 337A 50 POP 337B 50 POP 337C 50 POP 337D 60 PUSH1 0x00 337F 83 DUP4 3380 60 PUSH1 0x01 3382 60 PUSH1 0x01 3384 60 PUSH1 0xa0 3386 1B SHL 3387 03 SUB 3388 16 AND 3389 63 PUSH4 0x6c25b346 338E 30 ADDRESS 338F 60 PUSH1 0x40 3391 51 MLOAD 3392 82 DUP3 3393 63 PUSH4 0xffffffff 3398 16 AND 3399 60 PUSH1 0xe0 339B 1B SHL 339C 81 DUP2 339D 52 MSTORE 339E 60 PUSH1 0x04 33A0 01 ADD 33A1 80 DUP1 33A2 82 DUP3 33A3 60 PUSH1 0x01 33A5 60 PUSH1 0x01 33A7 60 PUSH1 0xa0 33A9 1B SHL 33AA 03 SUB 33AB 16 AND 33AC 81 DUP2 33AD 52 MSTORE 33AE 60 PUSH1 0x20 33B0 01 ADD 33B1 91 SWAP2 33B2 50 POP 33B3 50 POP 33B4 60 PUSH1 0x20 33B6 60 PUSH1 0x40 33B8 51 MLOAD 33B9 80 DUP1 33BA 83 DUP4 33BB 03 SUB 33BC 81 DUP2 33BD 86 DUP7 33BE 80 DUP1 33BF 3B EXTCODESIZE 33C0 15 ISZERO 33C1 80 DUP1 33C2 15 ISZERO 33C3 61 PUSH2 0x33cb 33C6 57 *JUMPI 33C7 60 PUSH1 0x00 33C9 80 DUP1 33CA FD *REVERT 33CB 5B JUMPDEST 33CC 50 POP 33CD 5A GAS 33CE FA STATICCALL 33CF 15 ISZERO 33D0 80 DUP1 33D1 15 ISZERO 33D2 61 PUSH2 0x33df 33D5 57 *JUMPI 33D6 3D RETURNDATASIZE 33D7 60 PUSH1 0x00 33D9 80 DUP1 33DA 3E RETURNDATACOPY 33DB 3D RETURNDATASIZE 33DC 60 PUSH1 0x00 33DE FD *REVERT 33DF 5B JUMPDEST 33E0 50 POP 33E1 50 POP 33E2 50 POP 33E3 50 POP 33E4 60 PUSH1 0x40 33E6 51 MLOAD 33E7 3D RETURNDATASIZE 33E8 60 PUSH1 0x20 33EA 81 DUP2 33EB 10 LT 33EC 15 ISZERO 33ED 61 PUSH2 0x33f5 33F0 57 *JUMPI 33F1 60 PUSH1 0x00 33F3 80 DUP1 33F4 FD *REVERT 33F5 5B JUMPDEST 33F6 50 POP 33F7 51 MLOAD 33F8 60 PUSH1 0x40 33FA 80 DUP1 33FB 51 MLOAD 33FC 63 PUSH4 0x4538c4eb 3401 60 PUSH1 0xe0 3403 1B SHL 3404 81 DUP2 3405 52 MSTORE 3406 30 ADDRESS 3407 60 PUSH1 0x04 3409 82 DUP3 340A 01 ADD 340B 52 MSTORE 340C 60 PUSH1 0x00 340E 80 DUP1 340F 51 MLOAD 3410 60 PUSH1 0x20 3412 61 PUSH2 0x4293 3415 83 DUP4 3416 39 CODECOPY 3417 81 DUP2 3418 51 MLOAD 3419 91 SWAP2 341A 52 MSTORE 341B 60 PUSH1 0x24 341D 82 DUP3 341E 01 ADD 341F 52 MSTORE 3420 90 SWAP1 3421 51 MLOAD 3422 91 SWAP2 3423 92 SWAP3 3424 50 POP 3425 60 PUSH1 0x01 3427 60 PUSH1 0x01 3429 60 PUSH1 0xa0 342B 1B SHL 342C 03 SUB 342D 86 DUP7 342E 16 AND 342F 91 SWAP2 3430 63 PUSH4 0x4538c4eb 3435 91 SWAP2 3436 60 PUSH1 0x44 3438 80 DUP1 3439 82 DUP3 343A 01 ADD 343B 92 SWAP3 343C 60 PUSH1 0x20 343E 92 SWAP3 343F 90 SWAP1 3440 91 SWAP2 3441 90 SWAP1 3442 82 DUP3 3443 90 SWAP1 3444 03 SUB 3445 01 ADD 3446 81 DUP2 3447 86 DUP7 3448 80 DUP1 3449 3B EXTCODESIZE 344A 15 ISZERO 344B 80 DUP1 344C 15 ISZERO 344D 61 PUSH2 0x3455 3450 57 *JUMPI 3451 60 PUSH1 0x00 3453 80 DUP1 3454 FD *REVERT 3455 5B JUMPDEST 3456 50 POP 3457 5A GAS 3458 FA STATICCALL 3459 15 ISZERO 345A 80 DUP1 345B 15 ISZERO 345C 61 PUSH2 0x3469 345F 57 *JUMPI 3460 3D RETURNDATASIZE 3461 60 PUSH1 0x00 3463 80 DUP1 3464 3E RETURNDATACOPY 3465 3D RETURNDATASIZE 3466 60 PUSH1 0x00 3468 FD *REVERT 3469 5B JUMPDEST 346A 50 POP 346B 50 POP 346C 50 POP 346D 50 POP 346E 60 PUSH1 0x40 3470 51 MLOAD 3471 3D RETURNDATASIZE 3472 60 PUSH1 0x20 3474 81 DUP2 3475 10 LT 3476 15 ISZERO 3477 61 PUSH2 0x347f 347A 57 *JUMPI 347B 60 PUSH1 0x00 347D 80 DUP1 347E FD *REVERT 347F 5B JUMPDEST 3480 50 POP 3481 51 MLOAD 3482 61 PUSH2 0x34f3 3485 57 *JUMPI 3486 60 PUSH1 0x40 3488 80 DUP1 3489 51 MLOAD 348A 63 PUSH4 0x28ec8bf1 348F 60 PUSH1 0xe2 3491 1B SHL 3492 81 DUP2 3493 52 MSTORE 3494 60 PUSH1 0x00 3496 80 DUP1 3497 51 MLOAD 3498 60 PUSH1 0x20 349A 61 PUSH2 0x4293 349D 83 DUP4 349E 39 CODECOPY 349F 81 DUP2 34A0 51 MLOAD 34A1 91 SWAP2 34A2 52 MSTORE 34A3 60 PUSH1 0x04 34A5 82 DUP3 34A6 01 ADD 34A7 52 MSTORE 34A8 90 SWAP1 34A9 51 MLOAD 34AA 60 PUSH1 0x01 34AC 60 PUSH1 0x01 34AE 60 PUSH1 0xa0 34B0 1B SHL 34B1 03 SUB 34B2 86 DUP7 34B3 16 AND 34B4 91 SWAP2 34B5 63 PUSH4 0xa3b22fc4 34BA 91 SWAP2 34BB 60 PUSH1 0x24 34BD 80 DUP1 34BE 83 DUP4 34BF 01 ADD 34C0 92 SWAP3 34C1 60 PUSH1 0x00 34C3 92 SWAP3 34C4 91 SWAP2 34C5 90 SWAP1 34C6 82 DUP3 34C7 90 SWAP1 34C8 03 SUB 34C9 01 ADD 34CA 81 DUP2 34CB 83 DUP4 34CC 87 DUP8 34CD 80 DUP1 34CE 3B EXTCODESIZE 34CF 15 ISZERO 34D0 80 DUP1 34D1 15 ISZERO 34D2 61 PUSH2 0x34da 34D5 57 *JUMPI 34D6 60 PUSH1 0x00 34D8 80 DUP1 34D9 FD *REVERT 34DA 5B JUMPDEST 34DB 50 POP 34DC 5A GAS 34DD F1 CALL 34DE 15 ISZERO 34DF 80 DUP1 34E0 15 ISZERO 34E1 61 PUSH2 0x34ee 34E4 57 *JUMPI 34E5 3D RETURNDATASIZE 34E6 60 PUSH1 0x00 34E8 80 DUP1 34E9 3E RETURNDATACOPY 34EA 3D RETURNDATASIZE 34EB 60 PUSH1 0x00 34ED FD *REVERT 34EE 5B JUMPDEST 34EF 50 POP 34F0 50 POP 34F1 50 POP 34F2 50 POP 34F3 5B JUMPDEST 34F4 60 PUSH1 0x00 34F6 80 DUP1 34F7 51 MLOAD 34F8 60 PUSH1 0x20 34FA 61 PUSH2 0x4293 34FD 83 DUP4 34FE 39 CODECOPY 34FF 81 DUP2 3500 51 MLOAD 3501 91 SWAP2 3502 52 MSTORE 3503 63 PUSH4 0xef693bed 3508 30 ADDRESS 3509 61 PUSH2 0x351d 350C 88 DUP9 350D 67 PUSH8 0x6765c793fa10079d 3516 60 PUSH1 0x1b 3518 1B SHL 3519 61 PUSH2 0x3da8 351C 56 *JUMP 351D 5B JUMPDEST 351E 84 DUP5 351F 10 LT 3520 15 ISZERO 3521 61 PUSH2 0x3537 3524 57 *JUMPI 3525 67 PUSH8 0x6765c793fa10079d 352E 60 PUSH1 0x1b 3530 1B SHL 3531 84 DUP5 3532 04 DIV 3533 61 PUSH2 0x3539 3536 56 *JUMP 3537 5B JUMPDEST 3538 87 DUP8 3539 5B JUMPDEST 353A 60 PUSH1 0x40 353C 51 MLOAD 353D 83 DUP4 353E 63 PUSH4 0xffffffff 3543 16 AND 3544 60 PUSH1 0xe0 3546 1B SHL 3547 81 DUP2 3548 52 MSTORE 3549 60 PUSH1 0x04 354B 01 ADD 354C 80 DUP1 354D 83 DUP4 354E 60 PUSH1 0x01 3550 60 PUSH1 0x01 3552 60 PUSH1 0xa0 3554 1B SHL 3555 03 SUB 3556 16 AND 3557 81 DUP2 3558 52 MSTORE 3559 60 PUSH1 0x20 355B 01 ADD 355C 82 DUP3 355D 81 DUP2 355E 52 MSTORE 355F 60 PUSH1 0x20 3561 01 ADD 3562 92 SWAP3 3563 50 POP 3564 50 POP 3565 50 POP 3566 60 PUSH1 0x00 3568 60 PUSH1 0x40 356A 51 MLOAD 356B 80 DUP1 356C 83 DUP4 356D 03 SUB 356E 81 DUP2 356F 60 PUSH1 0x00 3571 87 DUP8 3572 80 DUP1 3573 3B EXTCODESIZE 3574 15 ISZERO 3575 80 DUP1 3576 15 ISZERO 3577 61 PUSH2 0x357f 357A 57 *JUMPI 357B 60 PUSH1 0x00 357D 80 DUP1 357E FD *REVERT 357F 5B JUMPDEST 3580 50 POP 3581 5A GAS 3582 F1 CALL 3583 15 ISZERO 3584 80 DUP1 3585 15 ISZERO 3586 61 PUSH2 0x3593 3589 57 *JUMPI 358A 3D RETURNDATASIZE 358B 60 PUSH1 0x00 358D 80 DUP1 358E 3E RETURNDATACOPY 358F 3D RETURNDATASIZE 3590 60 PUSH1 0x00 3592 FD *REVERT 3593 5B JUMPDEST 3594 50 POP 3595 50 POP 3596 50 POP 3597 50 POP 3598 61 PUSH2 0x35a1 359B 88 DUP9 359C 86 DUP7 359D 61 PUSH2 0x3b0e 35A0 56 *JUMP 35A1 5B JUMPDEST 35A2 60 PUSH1 0x40 35A4 51 MLOAD 35A5 80 DUP1 35A6 60 PUSH1 0x60 35A8 01 ADD 35A9 60 PUSH1 0x40 35AB 52 MSTORE 35AC 80 DUP1 35AD 60 PUSH1 0x27 35AF 81 DUP2 35B0 52 MSTORE 35B1 60 PUSH1 0x20 35B3 01 ADD 35B4 61 PUSH2 0x42b3 35B7 60 PUSH1 0x27 35B9 91 SWAP2 35BA 39 CODECOPY 35BB 96 SWAP7 35BC 50 POP 35BD 84 DUP5 35BE 89 DUP10 35BF 89 DUP10 35C0 60 PUSH1 0x40 35C2 51 MLOAD 35C3 60 PUSH1 0x20 35C5 01 ADD 35C6 80 DUP1 35C7 84 DUP5 35C8 81 DUP2 35C9 52 MSTORE 35CA 60 PUSH1 0x20 35CC 01 ADD 35CD 83 DUP4 35CE 81 DUP2 35CF 52 MSTORE 35D0 60 PUSH1 0x20 35D2 01 ADD 35D3 82 DUP3 35D4 81 DUP2 35D5 52 MSTORE 35D6 60 PUSH1 0x20 35D8 01 ADD 35D9 93 SWAP4 35DA 50 POP 35DB 50 POP 35DC 50 POP 35DD 50 POP 35DE 60 PUSH1 0x40 35E0 51 MLOAD 35E1 60 PUSH1 0x20 35E3 81 DUP2 35E4 83 DUP4 35E5 03 SUB 35E6 03 SUB 35E7 81 DUP2 35E8 52 MSTORE 35E9 90 SWAP1 35EA 60 PUSH1 0x40 35EC 52 MSTORE 35ED 95 SWAP6 35EE 50 POP 35EF 50 POP 35F0 50 POP 35F1 50 POP 35F2 50 POP 35F3 50 POP 35F4 93 SWAP4 35F5 50 POP 35F6 93 SWAP4 35F7 91 SWAP2 35F8 50 POP 35F9 50 POP 35FA 56 *JUMP label_35FB: // Incoming jump from 0x0494 // Inputs[4] // { // @3604 stack[-2] // @3605 stack[-1] // @3616 memory[0x40:0x60] // @362D msg.data[stack[-2]:stack[-2] + stack[-1]] // } 35FB 5B JUMPDEST 35FC 60 PUSH1 0x60 35FE 80 DUP1 35FF 60 PUSH1 0x00 3601 61 PUSH2 0x363f 3604 85 DUP6 3605 85 DUP6 3606 80 DUP1 3607 80 DUP1 3608 60 PUSH1 0x1f 360A 01 ADD 360B 60 PUSH1 0x20 360D 80 DUP1 360E 91 SWAP2 360F 04 DIV 3610 02 MUL 3611 60 PUSH1 0x20 3613 01 ADD 3614 60 PUSH1 0x40 3616 51 MLOAD 3617 90 SWAP1 3618 81 DUP2 3619 01 ADD 361A 60 PUSH1 0x40 361C 52 MSTORE 361D 80 DUP1 361E 93 SWAP4 361F 92 SWAP3 3620 91 SWAP2 3621 90 SWAP1 3622 81 DUP2 3623 81 DUP2 3624 52 MSTORE 3625 60 PUSH1 0x20 3627 01 ADD 3628 83 DUP4 3629 83 DUP4 362A 80 DUP1 362B 82 DUP3 362C 84 DUP5 362D 37 CALLDATACOPY 362E 60 PUSH1 0x00 3630 92 SWAP3 3631 01 ADD 3632 91 SWAP2 3633 90 SWAP1 3634 91 SWAP2 3635 52 MSTORE 3636 50 POP 3637 61 PUSH2 0x40c7 363A 92 SWAP3 363B 50 POP 363C 50 POP 363D 50 POP 363E 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @35FC stack[0] = 0x60 // @35FE stack[1] = 0x60 // @35FF stack[2] = 0x00 // @3601 stack[3] = 0x363f // @361C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @361E stack[4] = memory[0x40:0x60] // @3624 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @362D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @3635 memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // } // Block ends with call to 0x40c7, returns to 0x363F label_363F: // Incoming return from call to 0x40C7 at 0x363E // Inputs[5] // { // @3640 stack[-1] // @3640 stack[-2] // @3673 memory[0x40:0x60] // @3691 memory[0x40:0x60] // @3698 address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } 363F 5B JUMPDEST 3640 90 SWAP1 3641 50 POP 3642 60 PUSH1 0x00 3644 60 PUSH1 0x01 3646 60 PUSH1 0x01 3648 60 PUSH1 0xa0 364A 1B SHL 364B 03 SUB 364C 16 AND 364D 73 PUSH20 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 3662 60 PUSH1 0x01 3664 60 PUSH1 0x01 3666 60 PUSH1 0xa0 3668 1B SHL 3669 03 SUB 366A 16 AND 366B 63 PUSH4 0x4445d799 3670 83 DUP4 3671 60 PUSH1 0x40 3673 51 MLOAD 3674 82 DUP3 3675 63 PUSH4 0xffffffff 367A 16 AND 367B 60 PUSH1 0xe0 367D 1B SHL 367E 81 DUP2 367F 52 MSTORE 3680 60 PUSH1 0x04 3682 01 ADD 3683 80 DUP1 3684 82 DUP3 3685 81 DUP2 3686 52 MSTORE 3687 60 PUSH1 0x20 3689 01 ADD 368A 91 SWAP2 368B 50 POP 368C 50 POP 368D 60 PUSH1 0x20 368F 60 PUSH1 0x40 3691 51 MLOAD 3692 80 DUP1 3693 83 DUP4 3694 03 SUB 3695 81 DUP2 3696 86 DUP7 3697 80 DUP1 3698 3B EXTCODESIZE 3699 15 ISZERO 369A 80 DUP1 369B 15 ISZERO 369C 61 PUSH2 0x36a4 369F 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @3640 stack[-2] = stack[-1] // @364C stack[-1] = (0x01 << 0xa0) - 0x01 & 0x00 // @366A stack[0] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @366B stack[1] = 0x4445d799 // @367F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x4445d799) << 0xe0 // @3686 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @368A stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @368D stack[3] = 0x20 // @3691 stack[4] = memory[0x40:0x60] // @3694 stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3695 stack[6] = memory[0x40:0x60] // @3696 stack[7] = (0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88 // @3699 stack[8] = !address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // } // Block ends with conditional jump to 0x36a4, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length label_36A0: // Incoming jump from 0x369F, if not !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[1] { @36A3 memory[0x00:0x00] } 36A0 60 PUSH1 0x00 36A2 80 DUP1 36A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @36A3 revert(memory[0x00:0x00]); } // Block terminates label_36A4: // Incoming jump from 0x369F, if !!address((0x01 << 0xa0) - 0x01 & 0xe81f70cc7c0d46e12d70efc60607f16bbd617e88).code.length // Inputs[8] // { // @36A6 msg.gas // @36A7 memory[stack[-3]:stack[-3] + stack[-4]] // @36A7 stack[-4] // @36A7 stack[-2] // @36A7 stack[-3] // @36A7 stack[-5] // @36A7 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @36A7 stack[-6] // } 36A4 5B JUMPDEST 36A5 50 POP 36A6 5A GAS 36A7 FA STATICCALL 36A8 15 ISZERO 36A9 80 DUP1 36AA 15 ISZERO 36AB 61 PUSH2 0x36b8 36AE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @36A7 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @36A8 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x36b8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_36AF: // Incoming jump from 0x36AE, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @36AF returndata.length // @36B3 returndata[0x00:0x00 + returndata.length] // @36B4 returndata.length // @36B7 memory[0x00:0x00 + returndata.length] // } 36AF 3D RETURNDATASIZE 36B0 60 PUSH1 0x00 36B2 80 DUP1 36B3 3E RETURNDATACOPY 36B4 3D RETURNDATASIZE 36B5 60 PUSH1 0x00 36B7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @36B3 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @36B7 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_36B8: // Incoming jump from 0x36AE, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @36BF memory[0x40:0x60] // @36C0 returndata.length // } 36B8 5B JUMPDEST 36B9 50 POP 36BA 50 POP 36BB 50 POP 36BC 50 POP 36BD 60 PUSH1 0x40 36BF 51 MLOAD 36C0 3D RETURNDATASIZE 36C1 60 PUSH1 0x20 36C3 81 DUP2 36C4 10 LT 36C5 15 ISZERO 36C6 61 PUSH2 0x36ce 36C9 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @36BF stack[-4] = memory[0x40:0x60] // @36C0 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x36ce, if !(returndata.length < 0x20) label_36CA: // Incoming jump from 0x36C9, if not !(returndata.length < 0x20) // Inputs[1] { @36CD memory[0x00:0x00] } 36CA 60 PUSH1 0x00 36CC 80 DUP1 36CD FD *REVERT // Stack delta = +0 // Outputs[1] { @36CD revert(memory[0x00:0x00]); } // Block terminates label_36CE: // Incoming jump from 0x36C9, if !(returndata.length < 0x20) // Inputs[3] // { // @36D0 stack[-2] // @36D0 memory[stack[-2]:stack[-2] + 0x20] // @36DA stack[-3] // } 36CE 5B JUMPDEST 36CF 50 POP 36D0 51 MLOAD 36D1 60 PUSH1 0x01 36D3 60 PUSH1 0x01 36D5 60 PUSH1 0xa0 36D7 1B SHL 36D8 03 SUB 36D9 16 AND 36DA 14 EQ 36DB 15 ISZERO 36DC 61 PUSH2 0x371d 36DF 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x371d, if !((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3]) label_36E0: // Incoming jump from 0x36DF, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3]) // Inputs[3] // { // @36E3 memory[0x40:0x60] // @3713 memory[0x40:0x60] // @371C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 36E0 60 PUSH1 0x40 36E2 80 DUP1 36E3 51 MLOAD 36E4 62 PUSH3 0x461bcd 36E8 60 PUSH1 0xe5 36EA 1B SHL 36EB 81 DUP2 36EC 52 MSTORE 36ED 60 PUSH1 0x20 36EF 60 PUSH1 0x04 36F1 82 DUP3 36F2 01 ADD 36F3 52 MSTORE 36F4 60 PUSH1 0x0e 36F6 60 PUSH1 0x24 36F8 82 DUP3 36F9 01 ADD 36FA 52 MSTORE 36FB 6D PUSH14 0x77726f6e672d636f6c2d74797065 370A 60 PUSH1 0x90 370C 1B SHL 370D 60 PUSH1 0x44 370F 82 DUP3 3710 01 ADD 3711 52 MSTORE 3712 90 SWAP1 3713 51 MLOAD 3714 90 SWAP1 3715 81 DUP2 3716 90 SWAP1 3717 03 SUB 3718 60 PUSH1 0x64 371A 01 ADD 371B 90 SWAP1 371C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @36EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @36F3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @36FA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @3711 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x77726f6e672d636f6c2d74797065 << 0x90 // @371C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_371D: // Incoming jump from 0x36DF, if !((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3]) // Inputs[7] // { // @3721 memory[0x40:0x60] // @3730 stack[-1] // @3733 address(this) // @373A memory[0x40:0x60] // @3741 memory[0x00:0x20] // @374A memory[0x00:0x20] // @3768 address(memory[0x00:0x20]).code.length // } 371D 5B JUMPDEST 371E 60 PUSH1 0x40 3720 80 DUP1 3721 51 MLOAD 3722 63 PUSH4 0x6090dec5 3727 60 PUSH1 0xe0 3729 1B SHL 372A 81 DUP2 372B 52 MSTORE 372C 60 PUSH1 0x04 372E 81 DUP2 372F 01 ADD 3730 83 DUP4 3731 90 SWAP1 3732 52 MSTORE 3733 30 ADDRESS 3734 60 PUSH1 0x24 3736 82 DUP3 3737 01 ADD 3738 52 MSTORE 3739 90 SWAP1 373A 51 MLOAD 373B 60 PUSH1 0x00 373D 91 SWAP2 373E 60 PUSH1 0x00 3740 80 DUP1 3741 51 MLOAD 3742 60 PUSH1 0x20 3744 61 PUSH2 0x4418 3747 83 DUP4 3748 39 CODECOPY 3749 81 DUP2 374A 51 MLOAD 374B 91 SWAP2 374C 52 MSTORE 374D 91 SWAP2 374E 63 PUSH4 0x6090dec5 3753 91 SWAP2 3754 60 PUSH1 0x44 3756 80 DUP1 3757 82 DUP3 3758 01 ADD 3759 92 SWAP3 375A 60 PUSH1 0x20 375C 92 SWAP3 375D 90 SWAP1 375E 91 SWAP2 375F 90 SWAP1 3760 82 DUP3 3761 90 SWAP1 3762 03 SUB 3763 01 ADD 3764 81 DUP2 3765 87 DUP8 3766 87 DUP8 3767 80 DUP1 3768 3B EXTCODESIZE 3769 15 ISZERO 376A 80 DUP1 376B 15 ISZERO 376C 61 PUSH2 0x3774 376F 57 *JUMPI // Stack delta = +11 // Outputs[16] // { // @372B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6090dec5 << 0xe0 // @3732 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] // @3738 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = address(this) // @373D stack[0] = 0x00 // @3748 memory[0x00:0x20] = code[0x4418:0x4438] // @374C memory[0x00:0x20] = memory[0x00:0x20] // @374D stack[1] = memory[0x00:0x20] // @3753 stack[2] = 0x6090dec5 // @3759 stack[3] = memory[0x40:0x60] + 0x44 // @375C stack[4] = 0x20 // @375E stack[5] = memory[0x40:0x60] // @3763 stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @3764 stack[7] = memory[0x40:0x60] // @3765 stack[8] = 0x00 // @3766 stack[9] = memory[0x00:0x20] // @3769 stack[10] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x3774, if !!address(memory[0x00:0x20]).code.length label_3770: // Incoming jump from 0x376F, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @3773 memory[0x00:0x00] } 3770 60 PUSH1 0x00 3772 80 DUP1 3773 FD *REVERT // Stack delta = +0 // Outputs[1] { @3773 revert(memory[0x00:0x00]); } // Block terminates label_3774: // Incoming jump from 0x376F, if !!address(memory[0x00:0x20]).code.length // Inputs[9] // { // @3776 msg.gas // @3777 stack[-4] // @3777 stack[-5] // @3777 stack[-7] // @3777 stack[-6] // @3777 memory[stack[-4]:stack[-4] + stack[-5]] // @3777 stack[-3] // @3777 stack[-2] // @3777 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 3774 5B JUMPDEST 3775 50 POP 3776 5A GAS 3777 F1 CALL 3778 15 ISZERO 3779 80 DUP1 377A 15 ISZERO 377B 61 PUSH2 0x3788 377E 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @3777 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3778 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x3788, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_377F: // Incoming jump from 0x377E, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @377F returndata.length // @3783 returndata[0x00:0x00 + returndata.length] // @3784 returndata.length // @3787 memory[0x00:0x00 + returndata.length] // } 377F 3D RETURNDATASIZE 3780 60 PUSH1 0x00 3782 80 DUP1 3783 3E RETURNDATACOPY 3784 3D RETURNDATASIZE 3785 60 PUSH1 0x00 3787 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3783 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3787 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3788: // Incoming jump from 0x377E, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @378F memory[0x40:0x60] // @3790 returndata.length // } 3788 5B JUMPDEST 3789 50 POP 378A 50 POP 378B 50 POP 378C 50 POP 378D 60 PUSH1 0x40 378F 51 MLOAD 3790 3D RETURNDATASIZE 3791 60 PUSH1 0x20 3793 81 DUP2 3794 10 LT 3795 15 ISZERO 3796 61 PUSH2 0x379e 3799 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @378F stack[-4] = memory[0x40:0x60] // @3790 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x379e, if !(returndata.length < 0x20) label_379A: // Incoming jump from 0x3799, if not !(returndata.length < 0x20) // Inputs[1] { @379D memory[0x00:0x00] } 379A 60 PUSH1 0x00 379C 80 DUP1 379D FD *REVERT // Stack delta = +0 // Outputs[1] { @379D revert(memory[0x00:0x00]); } // Block terminates label_379E: // Incoming jump from 0x3799, if !(returndata.length < 0x20) // Inputs[10] // { // @37A0 memory[stack[-2]:stack[-2] + 0x20] // @37A0 stack[-2] // @37A4 memory[0x40:0x60] // @37D9 memory[0x40:0x60] // @37E4 stack[-4] // @37E9 memory[0x40:0x60] // @37F9 stack[-9] // @37FB stack[-8] // @37FD stack[-3] // @37FE stack[-7] // } 379E 5B JUMPDEST 379F 50 POP 37A0 51 MLOAD 37A1 60 PUSH1 0x40 37A3 80 DUP1 37A4 51 MLOAD 37A5 80 DUP1 37A6 82 DUP3 37A7 01 ADD 37A8 82 DUP3 37A9 52 MSTORE 37AA 60 PUSH1 0x18 37AC 81 DUP2 37AD 52 MSTORE 37AE 7F PUSH32 0x4c6f674f70656e2875696e743235362c62797465733332290000000000000000 37CF 60 PUSH1 0x20 37D1 82 DUP3 37D2 81 DUP2 37D3 01 ADD 37D4 91 SWAP2 37D5 90 SWAP1 37D6 91 SWAP2 37D7 52 MSTORE 37D8 82 DUP3 37D9 51 MLOAD 37DA 90 SWAP1 37DB 81 DUP2 37DC 01 ADD 37DD 93 SWAP4 37DE 90 SWAP1 37DF 93 SWAP4 37E0 52 MSTORE 37E1 82 DUP3 37E2 82 DUP3 37E3 01 ADD 37E4 94 SWAP5 37E5 90 SWAP1 37E6 94 SWAP5 37E7 52 MSTORE 37E8 80 DUP1 37E9 51 MLOAD 37EA 80 DUP1 37EB 83 DUP4 37EC 03 SUB 37ED 82 DUP3 37EE 01 ADD 37EF 81 DUP2 37F0 52 MSTORE 37F1 60 PUSH1 0x60 37F3 90 SWAP1 37F4 92 SWAP3 37F5 01 ADD 37F6 90 SWAP1 37F7 52 MSTORE 37F8 91 SWAP2 37F9 96 SWAP7 37FA 91 SWAP2 37FB 95 SWAP6 37FC 50 POP 37FD 90 SWAP1 37FE 93 SWAP4 37FF 50 POP 3800 50 POP 3801 50 POP 3802 50 POP 3803 56 *JUMP // Stack delta = -7 // Outputs[9] // { // @37A9 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @37AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x18 // @37D7 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x4c6f674f70656e2875696e743235362c62797465733332290000000000000000 // @37E0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @37E7 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-4] // @37F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x40 + (memory[0x40:0x60] - memory[0x40:0x60]) // @37F7 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @37F9 stack[-9] = memory[0x40:0x60] // @37FB stack[-8] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-9] label_3804: // Incoming call from 0x271B, returns to 0x271C // Incoming call from 0x0F0A, returns to 0x0F0B // Incoming call from 0x1F14, returns to 0x1F15 // Incoming call from 0x1952, returns to 0x1953 // Incoming call from 0x04CB, returns to 0x04CC // Incoming call from 0x07FE, returns to 0x07FF // Incoming call from 0x0B8A, returns to 0x0B8B // Incoming call from 0x2D6F, returns to 0x2D70 // Inputs[1] { @3807 stack[-1] } 3804 5B JUMPDEST 3805 60 PUSH1 0x00 3807 81 DUP2 3808 61 PUSH2 0x3948 380B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3805 stack[0] = 0x00 } // Block ends with conditional jump to 0x3948, if stack[-1] label_380C: // Incoming jump from 0x380B, if not stack[-1] // Inputs[6] // { // @380F memory[0x40:0x60] // @381A address(this) // @3821 memory[0x40:0x60] // @3828 memory[0x00:0x20] // @3831 memory[0x00:0x20] // @384E address(memory[0x00:0x20]).code.length // } 380C 60 PUSH1 0x40 380E 80 DUP1 380F 51 MLOAD 3810 63 PUSH4 0x02ec2f6d 3815 60 PUSH1 0xe1 3817 1B SHL 3818 81 DUP2 3819 52 MSTORE 381A 30 ADDRESS 381B 60 PUSH1 0x04 381D 82 DUP3 381E 01 ADD 381F 52 MSTORE 3820 90 SWAP1 3821 51 MLOAD 3822 60 PUSH1 0x00 3824 91 SWAP2 3825 60 PUSH1 0x00 3827 80 DUP1 3828 51 MLOAD 3829 60 PUSH1 0x20 382B 61 PUSH2 0x4418 382E 83 DUP4 382F 39 CODECOPY 3830 81 DUP2 3831 51 MLOAD 3832 91 SWAP2 3833 52 MSTORE 3834 91 SWAP2 3835 63 PUSH4 0x05d85eda 383A 91 SWAP2 383B 60 PUSH1 0x24 383D 80 DUP1 383E 82 DUP3 383F 01 ADD 3840 92 SWAP3 3841 60 PUSH1 0x20 3843 92 SWAP3 3844 90 SWAP1 3845 91 SWAP2 3846 90 SWAP1 3847 82 DUP3 3848 90 SWAP1 3849 03 SUB 384A 01 ADD 384B 81 DUP2 384C 86 DUP7 384D 80 DUP1 384E 3B EXTCODESIZE 384F 15 ISZERO 3850 80 DUP1 3851 15 ISZERO 3852 61 PUSH2 0x385a 3855 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @3819 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02ec2f6d << 0xe1 // @381F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @3824 stack[0] = 0x00 // @382F memory[0x00:0x20] = code[0x4418:0x4438] // @3833 memory[0x00:0x20] = memory[0x00:0x20] // @3834 stack[1] = memory[0x00:0x20] // @383A stack[2] = 0x05d85eda // @3840 stack[3] = memory[0x40:0x60] + 0x24 // @3843 stack[4] = 0x20 // @3845 stack[5] = memory[0x40:0x60] // @384A stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @384B stack[7] = memory[0x40:0x60] // @384C stack[8] = memory[0x00:0x20] // @384F stack[9] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x385a, if !!address(memory[0x00:0x20]).code.length label_3856: // Incoming jump from 0x3855, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @3859 memory[0x00:0x00] } 3856 60 PUSH1 0x00 3858 80 DUP1 3859 FD *REVERT // Stack delta = +0 // Outputs[1] { @3859 revert(memory[0x00:0x00]); } // Block terminates label_385A: // Incoming jump from 0x3855, if !!address(memory[0x00:0x20]).code.length // Inputs[8] // { // @385C msg.gas // @385D stack[-6] // @385D stack[-3] // @385D stack[-4] // @385D memory[stack[-3]:stack[-3] + stack[-4]] // @385D stack[-5] // @385D address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @385D stack[-2] // } 385A 5B JUMPDEST 385B 50 POP 385C 5A GAS 385D FA STATICCALL 385E 15 ISZERO 385F 80 DUP1 3860 15 ISZERO 3861 61 PUSH2 0x386e 3864 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @385D memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @385E stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x386e, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3865: // Incoming jump from 0x3864, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3865 returndata.length // @3869 returndata[0x00:0x00 + returndata.length] // @386A returndata.length // @386D memory[0x00:0x00 + returndata.length] // } 3865 3D RETURNDATASIZE 3866 60 PUSH1 0x00 3868 80 DUP1 3869 3E RETURNDATACOPY 386A 3D RETURNDATASIZE 386B 60 PUSH1 0x00 386D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3869 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @386D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_386E: // Incoming jump from 0x3864, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3875 memory[0x40:0x60] // @3876 returndata.length // } 386E 5B JUMPDEST 386F 50 POP 3870 50 POP 3871 50 POP 3872 50 POP 3873 60 PUSH1 0x40 3875 51 MLOAD 3876 3D RETURNDATASIZE 3877 60 PUSH1 0x20 3879 81 DUP2 387A 10 LT 387B 15 ISZERO 387C 61 PUSH2 0x3884 387F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3875 stack[-4] = memory[0x40:0x60] // @3876 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3884, if !(returndata.length < 0x20) label_3880: // Incoming jump from 0x387F, if not !(returndata.length < 0x20) // Inputs[1] { @3883 memory[0x00:0x00] } 3880 60 PUSH1 0x00 3882 80 DUP1 3883 FD *REVERT // Stack delta = +0 // Outputs[1] { @3883 revert(memory[0x00:0x00]); } // Block terminates label_3884: // Incoming jump from 0x387F, if !(returndata.length < 0x20) // Inputs[3] // { // @3886 memory[stack[-2]:stack[-2] + 0x20] // @3886 stack[-2] // @3887 stack[-3] // } 3884 5B JUMPDEST 3885 50 POP 3886 51 MLOAD 3887 11 GT 3888 61 PUSH2 0x38ca 388B 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x38ca, if memory[stack[-2]:stack[-2] + 0x20] > stack[-3] label_388C: // Incoming jump from 0x388B, if not memory[stack[-2]:stack[-2] + 0x20] > stack[-3] // Inputs[3] // { // @388F memory[0x40:0x60] // @38C0 memory[0x40:0x60] // @38C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 388C 60 PUSH1 0x40 388E 80 DUP1 388F 51 MLOAD 3890 62 PUSH3 0x461bcd 3894 60 PUSH1 0xe5 3896 1B SHL 3897 81 DUP2 3898 52 MSTORE 3899 60 PUSH1 0x20 389B 60 PUSH1 0x04 389D 82 DUP3 389E 01 ADD 389F 52 MSTORE 38A0 60 PUSH1 0x0f 38A2 60 PUSH1 0x24 38A4 82 DUP3 38A5 01 ADD 38A6 52 MSTORE 38A7 6E PUSH15 0x1b9bcb5d985d5b1d0b5bdc195b9959 38B7 60 PUSH1 0x8a 38B9 1B SHL 38BA 60 PUSH1 0x44 38BC 82 DUP3 38BD 01 ADD 38BE 52 MSTORE 38BF 90 SWAP1 38C0 51 MLOAD 38C1 90 SWAP1 38C2 81 DUP2 38C3 90 SWAP1 38C4 03 SUB 38C5 60 PUSH1 0x64 38C7 01 ADD 38C8 90 SWAP1 38C9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3898 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @389F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @38A6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @38BE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b9bcb5d985d5b1d0b5bdc195b9959 << 0x8a // @38C9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_38CA: // Incoming jump from 0x388B, if memory[stack[-2]:stack[-2] + 0x20] > stack[-3] // Inputs[6] // { // @38CE memory[0x40:0x60] // @38D9 address(this) // @38E0 memory[0x40:0x60] // @38E4 memory[0x00:0x20] // @38ED memory[0x00:0x20] // @3909 address(memory[0x00:0x20]).code.length // } 38CA 5B JUMPDEST 38CB 60 PUSH1 0x40 38CD 80 DUP1 38CE 51 MLOAD 38CF 63 PUSH4 0x9a816f7d 38D4 60 PUSH1 0xe0 38D6 1B SHL 38D7 81 DUP2 38D8 52 MSTORE 38D9 30 ADDRESS 38DA 60 PUSH1 0x04 38DC 82 DUP3 38DD 01 ADD 38DE 52 MSTORE 38DF 90 SWAP1 38E0 51 MLOAD 38E1 60 PUSH1 0x00 38E3 80 DUP1 38E4 51 MLOAD 38E5 60 PUSH1 0x20 38E7 61 PUSH2 0x4418 38EA 83 DUP4 38EB 39 CODECOPY 38EC 81 DUP2 38ED 51 MLOAD 38EE 91 SWAP2 38EF 52 MSTORE 38F0 91 SWAP2 38F1 63 PUSH4 0x9a816f7d 38F6 91 SWAP2 38F7 60 PUSH1 0x24 38F9 80 DUP1 38FA 83 DUP4 38FB 01 ADD 38FC 92 SWAP3 38FD 60 PUSH1 0x20 38FF 92 SWAP3 3900 91 SWAP2 3901 90 SWAP1 3902 82 DUP3 3903 90 SWAP1 3904 03 SUB 3905 01 ADD 3906 81 DUP2 3907 86 DUP7 3908 80 DUP1 3909 3B EXTCODESIZE 390A 15 ISZERO 390B 80 DUP1 390C 15 ISZERO 390D 61 PUSH2 0x3915 3910 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @38D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x9a816f7d << 0xe0 // @38DE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @38EB memory[0x00:0x20] = code[0x4418:0x4438] // @38EF memory[0x00:0x20] = memory[0x00:0x20] // @38F0 stack[0] = memory[0x00:0x20] // @38F6 stack[1] = 0x9a816f7d // @38FC stack[2] = memory[0x40:0x60] + 0x24 // @38FF stack[3] = 0x20 // @3900 stack[4] = memory[0x40:0x60] // @3905 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @3906 stack[6] = memory[0x40:0x60] // @3907 stack[7] = memory[0x00:0x20] // @390A stack[8] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x3915, if !!address(memory[0x00:0x20]).code.length label_3911: // Incoming jump from 0x3910, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @3914 memory[0x00:0x00] } 3911 60 PUSH1 0x00 3913 80 DUP1 3914 FD *REVERT // Stack delta = +0 // Outputs[1] { @3914 revert(memory[0x00:0x00]); } // Block terminates label_3915: // Incoming jump from 0x3910, if !!address(memory[0x00:0x20]).code.length // Inputs[8] // { // @3917 msg.gas // @3918 stack[-6] // @3918 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3918 memory[stack[-3]:stack[-3] + stack[-4]] // @3918 stack[-3] // @3918 stack[-2] // @3918 stack[-5] // @3918 stack[-4] // } 3915 5B JUMPDEST 3916 50 POP 3917 5A GAS 3918 FA STATICCALL 3919 15 ISZERO 391A 80 DUP1 391B 15 ISZERO 391C 61 PUSH2 0x3929 391F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3918 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3919 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3929, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3920: // Incoming jump from 0x391F, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3920 returndata.length // @3924 returndata[0x00:0x00 + returndata.length] // @3925 returndata.length // @3928 memory[0x00:0x00 + returndata.length] // } 3920 3D RETURNDATASIZE 3921 60 PUSH1 0x00 3923 80 DUP1 3924 3E RETURNDATACOPY 3925 3D RETURNDATASIZE 3926 60 PUSH1 0x00 3928 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3924 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3928 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3929: // Incoming jump from 0x391F, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3930 memory[0x40:0x60] // @3931 returndata.length // } 3929 5B JUMPDEST 392A 50 POP 392B 50 POP 392C 50 POP 392D 50 POP 392E 60 PUSH1 0x40 3930 51 MLOAD 3931 3D RETURNDATASIZE 3932 60 PUSH1 0x20 3934 81 DUP2 3935 10 LT 3936 15 ISZERO 3937 61 PUSH2 0x393f 393A 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3930 stack[-4] = memory[0x40:0x60] // @3931 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x393f, if !(returndata.length < 0x20) label_393B: // Incoming jump from 0x393A, if not !(returndata.length < 0x20) // Inputs[1] { @393E memory[0x00:0x00] } 393B 60 PUSH1 0x00 393D 80 DUP1 393E FD *REVERT // Stack delta = +0 // Outputs[1] { @393E revert(memory[0x00:0x00]); } // Block terminates label_393F: // Incoming jump from 0x393A, if !(returndata.length < 0x20) // Inputs[3] // { // @3941 memory[stack[-2]:stack[-2] + 0x20] // @3941 stack[-2] // @3942 stack[-3] // } 393F 5B JUMPDEST 3940 50 POP 3941 51 MLOAD 3942 90 SWAP1 3943 50 POP 3944 61 PUSH2 0x394b 3947 56 *JUMP // Stack delta = -2 // Outputs[1] { @3942 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x394b label_3948: // Incoming jump from 0x380B, if stack[-1] // Inputs[2] // { // @394A stack[-2] // @394C stack[-3] // } 3948 5B JUMPDEST 3949 50 POP 394A 80 DUP1 394B 5B JUMPDEST 394C 91 SWAP2 394D 90 SWAP1 394E 50 POP 394F 56 *JUMP // Stack delta = -2 // Outputs[1] { @394C stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_3950: // Incoming call from 0x2728, returns to 0x2729 // Incoming call from 0x1960, returns to 0x1961 // Incoming call from 0x28E5, returns to 0x28E6 // Incoming call from 0x0B98, returns to 0x0B99 // Incoming call from 0x04D9, returns to 0x04DA // Incoming call from 0x080C, returns to 0x080D // Incoming call from 0x1F25, returns to 0x1F26 // Incoming call from 0x0F18, returns to 0x0F19 // Incoming call from 0x2D7D, returns to 0x2D7E // Inputs[6] // { // @3957 memory[0x00:0x20] // @3960 memory[0x00:0x20] // @3971 stack[-1] // @3974 memory[0x40:0x60] // @3992 memory[0x40:0x60] // @3999 address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } 3950 5B JUMPDEST 3951 60 PUSH1 0x00 3953 80 DUP1 3954 60 PUSH1 0x00 3956 80 DUP1 3957 51 MLOAD 3958 60 PUSH1 0x20 395A 61 PUSH2 0x4418 395D 83 DUP4 395E 39 CODECOPY 395F 81 DUP2 3960 51 MLOAD 3961 91 SWAP2 3962 52 MSTORE 3963 60 PUSH1 0x01 3965 60 PUSH1 0x01 3967 60 PUSH1 0xa0 3969 1B SHL 396A 03 SUB 396B 16 AND 396C 63 PUSH4 0x2c2cb9fd 3971 84 DUP5 3972 60 PUSH1 0x40 3974 51 MLOAD 3975 82 DUP3 3976 63 PUSH4 0xffffffff 397B 16 AND 397C 60 PUSH1 0xe0 397E 1B SHL 397F 81 DUP2 3980 52 MSTORE 3981 60 PUSH1 0x04 3983 01 ADD 3984 80 DUP1 3985 82 DUP3 3986 81 DUP2 3987 52 MSTORE 3988 60 PUSH1 0x20 398A 01 ADD 398B 91 SWAP2 398C 50 POP 398D 50 POP 398E 60 PUSH1 0x20 3990 60 PUSH1 0x40 3992 51 MLOAD 3993 80 DUP1 3994 83 DUP4 3995 03 SUB 3996 81 DUP2 3997 86 DUP7 3998 80 DUP1 3999 3B EXTCODESIZE 399A 15 ISZERO 399B 80 DUP1 399C 15 ISZERO 399D 61 PUSH2 0x39a5 39A0 57 *JUMPI // Stack delta = +11 // Outputs[15] // { // @3951 stack[0] = 0x00 // @3953 stack[1] = 0x00 // @395E memory[0x00:0x20] = code[0x4418:0x4438] // @3962 memory[0x00:0x20] = memory[0x00:0x20] // @396B stack[2] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @396C stack[3] = 0x2c2cb9fd // @3980 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2c2cb9fd) << 0xe0 // @3987 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @398B stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @398E stack[5] = 0x20 // @3992 stack[6] = memory[0x40:0x60] // @3995 stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3996 stack[8] = memory[0x40:0x60] // @3997 stack[9] = (0x01 << 0xa0) - 0x01 & memory[0x00:0x20] // @399A stack[10] = !address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x39a5, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length label_39A1: // Incoming jump from 0x39A0, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[1] { @39A4 memory[0x00:0x00] } 39A1 60 PUSH1 0x00 39A3 80 DUP1 39A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @39A4 revert(memory[0x00:0x00]); } // Block terminates label_39A5: // Incoming jump from 0x39A0, if !!address((0x01 << 0xa0) - 0x01 & memory[0x00:0x20]).code.length // Inputs[8] // { // @39A7 msg.gas // @39A8 stack[-6] // @39A8 stack[-3] // @39A8 stack[-4] // @39A8 memory[stack[-3]:stack[-3] + stack[-4]] // @39A8 stack[-5] // @39A8 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @39A8 stack[-2] // } 39A5 5B JUMPDEST 39A6 50 POP 39A7 5A GAS 39A8 FA STATICCALL 39A9 15 ISZERO 39AA 80 DUP1 39AB 15 ISZERO 39AC 61 PUSH2 0x39b9 39AF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @39A8 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @39A9 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x39b9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_39B0: // Incoming jump from 0x39AF, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @39B0 returndata.length // @39B4 returndata[0x00:0x00 + returndata.length] // @39B5 returndata.length // @39B8 memory[0x00:0x00 + returndata.length] // } 39B0 3D RETURNDATASIZE 39B1 60 PUSH1 0x00 39B3 80 DUP1 39B4 3E RETURNDATACOPY 39B5 3D RETURNDATASIZE 39B6 60 PUSH1 0x00 39B8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @39B4 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @39B8 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_39B9: // Incoming jump from 0x39AF, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @39C0 memory[0x40:0x60] // @39C1 returndata.length // } 39B9 5B JUMPDEST 39BA 50 POP 39BB 50 POP 39BC 50 POP 39BD 50 POP 39BE 60 PUSH1 0x40 39C0 51 MLOAD 39C1 3D RETURNDATASIZE 39C2 60 PUSH1 0x20 39C4 81 DUP2 39C5 10 LT 39C6 15 ISZERO 39C7 61 PUSH2 0x39cf 39CA 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @39C0 stack[-4] = memory[0x40:0x60] // @39C1 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x39cf, if !(returndata.length < 0x20) label_39CB: // Incoming jump from 0x39CA, if not !(returndata.length < 0x20) // Inputs[1] { @39CE memory[0x00:0x00] } 39CB 60 PUSH1 0x00 39CD 80 DUP1 39CE FD *REVERT // Stack delta = +0 // Outputs[1] { @39CE revert(memory[0x00:0x00]); } // Block terminates label_39CF: // Incoming jump from 0x39CA, if !(returndata.length < 0x20) // Inputs[9] // { // @39D1 stack[-2] // @39D1 memory[stack[-2]:stack[-2] + 0x20] // @39D5 memory[0x40:0x60] // @39E4 stack[-5] // @39E8 memory[0x40:0x60] // @39EA stack[-4] // @39EF memory[0x00:0x20] // @39F8 memory[0x00:0x20] // @3A15 address(memory[0x00:0x20]).code.length // } 39CF 5B JUMPDEST 39D0 50 POP 39D1 51 MLOAD 39D2 60 PUSH1 0x40 39D4 80 DUP1 39D5 51 MLOAD 39D6 63 PUSH4 0x2726b073 39DB 60 PUSH1 0xe0 39DD 1B SHL 39DE 81 DUP2 39DF 52 MSTORE 39E0 60 PUSH1 0x04 39E2 81 DUP2 39E3 01 ADD 39E4 86 DUP7 39E5 90 SWAP1 39E6 52 MSTORE 39E7 90 SWAP1 39E8 51 MLOAD 39E9 91 SWAP2 39EA 93 SWAP4 39EB 50 POP 39EC 60 PUSH1 0x00 39EE 80 DUP1 39EF 51 MLOAD 39F0 60 PUSH1 0x20 39F2 61 PUSH2 0x4418 39F5 83 DUP4 39F6 39 CODECOPY 39F7 81 DUP2 39F8 51 MLOAD 39F9 91 SWAP2 39FA 52 MSTORE 39FB 91 SWAP2 39FC 63 PUSH4 0x2726b073 3A01 91 SWAP2 3A02 60 PUSH1 0x24 3A04 80 DUP1 3A05 82 DUP3 3A06 01 ADD 3A07 92 SWAP3 3A08 60 PUSH1 0x20 3A0A 92 SWAP3 3A0B 90 SWAP1 3A0C 91 SWAP2 3A0D 90 SWAP1 3A0E 82 DUP3 3A0F 90 SWAP1 3A10 03 SUB 3A11 01 ADD 3A12 81 DUP2 3A13 86 DUP7 3A14 80 DUP1 3A15 3B EXTCODESIZE 3A16 15 ISZERO 3A17 80 DUP1 3A18 15 ISZERO 3A19 61 PUSH2 0x3a21 3A1C 57 *JUMPI // Stack delta = +7 // Outputs[14] // { // @39DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2726b073 << 0xe0 // @39E6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-5] // @39EA stack[-4] = memory[stack[-2]:stack[-2] + 0x20] // @39F6 memory[0x00:0x20] = code[0x4418:0x4438] // @39FA memory[0x00:0x20] = memory[0x00:0x20] // @39FB stack[-2] = memory[0x00:0x20] // @3A01 stack[-1] = 0x2726b073 // @3A07 stack[0] = memory[0x40:0x60] + 0x24 // @3A0A stack[1] = 0x20 // @3A0C stack[2] = memory[0x40:0x60] // @3A11 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @3A12 stack[4] = memory[0x40:0x60] // @3A13 stack[5] = memory[0x00:0x20] // @3A16 stack[6] = !address(memory[0x00:0x20]).code.length // } // Block ends with conditional jump to 0x3a21, if !!address(memory[0x00:0x20]).code.length label_3A1D: // Incoming jump from 0x3A1C, if not !!address(memory[0x00:0x20]).code.length // Inputs[1] { @3A20 memory[0x00:0x00] } 3A1D 60 PUSH1 0x00 3A1F 80 DUP1 3A20 FD *REVERT // Stack delta = +0 // Outputs[1] { @3A20 revert(memory[0x00:0x00]); } // Block terminates label_3A21: // Incoming jump from 0x3A1C, if !!address(memory[0x00:0x20]).code.length // Inputs[8] // { // @3A23 msg.gas // @3A24 stack[-3] // @3A24 stack[-4] // @3A24 stack[-2] // @3A24 stack[-6] // @3A24 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3A24 memory[stack[-3]:stack[-3] + stack[-4]] // @3A24 stack[-5] // } 3A21 5B JUMPDEST 3A22 50 POP 3A23 5A GAS 3A24 FA STATICCALL 3A25 15 ISZERO 3A26 80 DUP1 3A27 15 ISZERO 3A28 61 PUSH2 0x3a35 3A2B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3A24 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3A25 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3a35, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3A2C: // Incoming jump from 0x3A2B, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3A2C returndata.length // @3A30 returndata[0x00:0x00 + returndata.length] // @3A31 returndata.length // @3A34 memory[0x00:0x00 + returndata.length] // } 3A2C 3D RETURNDATASIZE 3A2D 60 PUSH1 0x00 3A2F 80 DUP1 3A30 3E RETURNDATACOPY 3A31 3D RETURNDATASIZE 3A32 60 PUSH1 0x00 3A34 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3A30 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3A34 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3A35: // Incoming jump from 0x3A2B, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3A3C memory[0x40:0x60] // @3A3D returndata.length // } 3A35 5B JUMPDEST 3A36 50 POP 3A37 50 POP 3A38 50 POP 3A39 50 POP 3A3A 60 PUSH1 0x40 3A3C 51 MLOAD 3A3D 3D RETURNDATASIZE 3A3E 60 PUSH1 0x20 3A40 81 DUP2 3A41 10 LT 3A42 15 ISZERO 3A43 61 PUSH2 0x3a4b 3A46 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3A3C stack[-4] = memory[0x40:0x60] // @3A3D stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3a4b, if !(returndata.length < 0x20) label_3A47: // Incoming jump from 0x3A46, if not !(returndata.length < 0x20) // Inputs[1] { @3A4A memory[0x00:0x00] } 3A47 60 PUSH1 0x00 3A49 80 DUP1 3A4A FD *REVERT // Stack delta = +0 // Outputs[1] { @3A4A revert(memory[0x00:0x00]); } // Block terminates label_3A4B: // Incoming jump from 0x3A46, if !(returndata.length < 0x20) // Inputs[5] // { // @3A4D stack[-2] // @3A4D memory[stack[-2]:stack[-2] + 0x20] // @3A4E stack[-4] // @3A4F stack[-6] // @3A51 stack[-5] // } 3A4B 5B JUMPDEST 3A4C 50 POP 3A4D 51 MLOAD 3A4E 91 SWAP2 3A4F 93 SWAP4 3A50 91 SWAP2 3A51 92 SWAP3 3A52 50 POP 3A53 50 POP 3A54 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3A4F stack[-6] = stack[-4] // @3A51 stack[-5] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_3A55: // Incoming call from 0x0B7D, returns to 0x0B7E // Incoming call from 0x0EFD, returns to 0x0EFE // Incoming call from 0x1945, returns to 0x1946 // Incoming call from 0x1405, returns to 0x1406 // Incoming call from 0x313F, returns to 0x3140 // Incoming call from 0x1F09, returns to 0x1F0A // Incoming call from 0x07F1, returns to 0x07F2 // Incoming call from 0x2D62, returns to 0x2D63 // Incoming call from 0x1EFB, returns to 0x1EFC // Incoming call from 0x28D7, returns to 0x28D8 // Inputs[1] { @3A58 stack[-2] } 3A55 5B JUMPDEST 3A56 60 PUSH1 0x00 3A58 82 DUP3 3A59 15 ISZERO 3A5A 61 PUSH2 0x3ae8 3A5D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A56 stack[0] = 0x00 } // Block ends with conditional jump to 0x3ae8, if !stack[-2] label_3A5E: // Incoming jump from 0x3A5D, if not !stack[-2] // Inputs[4] // { // @3A81 stack[-3] // @3A84 memory[0x40:0x60] // @3AA2 memory[0x40:0x60] // @3AAB address((0x01 << 0xa0) - 0x01 & 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length // } 3A5E 73 PUSH20 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f 3A73 60 PUSH1 0x01 3A75 60 PUSH1 0x01 3A77 60 PUSH1 0xa0 3A79 1B SHL 3A7A 03 SUB 3A7B 16 AND 3A7C 63 PUSH4 0xa9c70eaa 3A81 84 DUP5 3A82 60 PUSH1 0x40 3A84 51 MLOAD 3A85 82 DUP3 3A86 63 PUSH4 0xffffffff 3A8B 16 AND 3A8C 60 PUSH1 0xe0 3A8E 1B SHL 3A8F 81 DUP2 3A90 52 MSTORE 3A91 60 PUSH1 0x04 3A93 01 ADD 3A94 80 DUP1 3A95 82 DUP3 3A96 81 DUP2 3A97 52 MSTORE 3A98 60 PUSH1 0x20 3A9A 01 ADD 3A9B 91 SWAP2 3A9C 50 POP 3A9D 50 POP 3A9E 60 PUSH1 0x20 3AA0 60 PUSH1 0x40 3AA2 51 MLOAD 3AA3 80 DUP1 3AA4 83 DUP4 3AA5 03 SUB 3AA6 81 DUP2 3AA7 60 PUSH1 0x00 3AA9 87 DUP8 3AAA 80 DUP1 3AAB 3B EXTCODESIZE 3AAC 15 ISZERO 3AAD 80 DUP1 3AAE 15 ISZERO 3AAF 61 PUSH2 0x3ab7 3AB2 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @3A7B stack[0] = (0x01 << 0xa0) - 0x01 & 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f // @3A7C stack[1] = 0xa9c70eaa // @3A90 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xa9c70eaa) << 0xe0 // @3A97 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-3] // @3A9B stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @3A9E stack[3] = 0x20 // @3AA2 stack[4] = memory[0x40:0x60] // @3AA5 stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3AA6 stack[6] = memory[0x40:0x60] // @3AA7 stack[7] = 0x00 // @3AA9 stack[8] = (0x01 << 0xa0) - 0x01 & 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f // @3AAC stack[9] = !address((0x01 << 0xa0) - 0x01 & 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length // } // Block ends with conditional jump to 0x3ab7, if !!address((0x01 << 0xa0) - 0x01 & 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length label_3AB3: // Incoming jump from 0x3AB2, if not !!address((0x01 << 0xa0) - 0x01 & 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length // Inputs[1] { @3AB6 memory[0x00:0x00] } 3AB3 60 PUSH1 0x00 3AB5 80 DUP1 3AB6 FD *REVERT // Stack delta = +0 // Outputs[1] { @3AB6 revert(memory[0x00:0x00]); } // Block terminates label_3AB7: // Incoming jump from 0x3AB2, if !!address((0x01 << 0xa0) - 0x01 & 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length // Inputs[9] // { // @3AB9 msg.gas // @3ABA stack[-3] // @3ABA stack[-6] // @3ABA stack[-7] // @3ABA memory[stack[-4]:stack[-4] + stack[-5]] // @3ABA stack[-4] // @3ABA stack[-2] // @3ABA address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3ABA stack[-5] // } 3AB7 5B JUMPDEST 3AB8 50 POP 3AB9 5A GAS 3ABA F1 CALL 3ABB 15 ISZERO 3ABC 80 DUP1 3ABD 15 ISZERO 3ABE 61 PUSH2 0x3acb 3AC1 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @3ABA memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3ABB stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x3acb, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3AC2: // Incoming jump from 0x3AC1, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3AC2 returndata.length // @3AC6 returndata[0x00:0x00 + returndata.length] // @3AC7 returndata.length // @3ACA memory[0x00:0x00 + returndata.length] // } 3AC2 3D RETURNDATASIZE 3AC3 60 PUSH1 0x00 3AC5 80 DUP1 3AC6 3E RETURNDATACOPY 3AC7 3D RETURNDATASIZE 3AC8 60 PUSH1 0x00 3ACA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3AC6 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3ACA revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3ACB: // Incoming jump from 0x3AC1, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @3AD2 memory[0x40:0x60] // @3AD3 returndata.length // } 3ACB 5B JUMPDEST 3ACC 50 POP 3ACD 50 POP 3ACE 50 POP 3ACF 50 POP 3AD0 60 PUSH1 0x40 3AD2 51 MLOAD 3AD3 3D RETURNDATASIZE 3AD4 60 PUSH1 0x20 3AD6 81 DUP2 3AD7 10 LT 3AD8 15 ISZERO 3AD9 61 PUSH2 0x3ae1 3ADC 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3AD2 stack[-4] = memory[0x40:0x60] // @3AD3 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3ae1, if !(returndata.length < 0x20) label_3ADD: // Incoming jump from 0x3ADC, if not !(returndata.length < 0x20) // Inputs[1] { @3AE0 memory[0x00:0x00] } 3ADD 60 PUSH1 0x00 3ADF 80 DUP1 3AE0 FD *REVERT // Stack delta = +0 // Outputs[1] { @3AE0 revert(memory[0x00:0x00]); } // Block terminates label_3AE1: // Incoming jump from 0x3ADC, if !(returndata.length < 0x20) // Inputs[2] // { // @3AE3 stack[-2] // @3AE3 memory[stack[-2]:stack[-2] + 0x20] // } 3AE1 5B JUMPDEST 3AE2 50 POP 3AE3 51 MLOAD 3AE4 61 PUSH2 0x3aea 3AE7 56 *JUMP // Stack delta = -1 // Outputs[1] { @3AE3 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x3aea label_3AE8: // Incoming jump from 0x3A5D, if !stack[-2] // Inputs[3] // { // @3AE9 stack[-2] // @3AEB stack[-4] // @3AEC stack[-3] // } 3AE8 5B JUMPDEST 3AE9 81 DUP2 3AEA 5B JUMPDEST 3AEB 93 SWAP4 3AEC 92 SWAP3 3AED 50 POP 3AEE 50 POP 3AEF 50 POP 3AF0 56 *JUMP // Stack delta = -3 // Outputs[1] { @3AEB stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_3AF1: // Incoming jump from 0x093A // Inputs[1] { @3AF7 stack[-1] } 3AF1 5B JUMPDEST 3AF2 60 PUSH1 0x00 3AF4 61 PUSH2 0x3b08 3AF7 82 DUP3 3AF8 67 PUSH8 0x6765c793fa10079d 3B01 60 PUSH1 0x1b 3B03 1B SHL 3B04 61 PUSH2 0x3da8 3B07 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3AF2 stack[0] = 0x00 // @3AF4 stack[1] = 0x3b08 // @3AF7 stack[2] = stack[-1] // @3B03 stack[3] = 0x6765c793fa10079d << 0x1b // } // Block ends with unconditional jump to 0x3da8 label_3B08: // Incoming jump from 0x4131 // Incoming jump from 0x3D47 // Inputs[3] // { // @3B09 stack[-1] // @3B09 stack[-4] // @3B0A stack[-3] // } 3B08 5B JUMPDEST 3B09 92 SWAP3 3B0A 91 SWAP2 3B0B 50 POP 3B0C 50 POP 3B0D 56 *JUMP // Stack delta = -3 // Outputs[1] { @3B09 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_3B0E: // Incoming call from 0x2CED, returns to 0x2CEE // Incoming call from 0x1E7E, returns to 0x1E7F // Incoming call from 0x1E7E, returns to 0x1E7F // Inputs[1] { @3B0F stack[-2] } 3B0E 5B JUMPDEST 3B0F 81 DUP2 3B10 15 ISZERO 3B11 61 PUSH2 0x3b87 3B14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3b87, if !stack[-2] label_3B15: // Incoming jump from 0x3B14, if not !stack[-2] // Inputs[5] // { // @3B18 memory[0x40:0x60] // @3B27 stack[-2] // @3B2E stack[-1] // @3B32 memory[0x40:0x60] // @3B62 address(0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length // } 3B15 60 PUSH1 0x40 3B17 80 DUP1 3B18 51 MLOAD 3B19 63 PUSH4 0x1878f251 3B1E 60 PUSH1 0xe2 3B20 1B SHL 3B21 81 DUP2 3B22 52 MSTORE 3B23 60 PUSH1 0x04 3B25 81 DUP2 3B26 01 ADD 3B27 84 DUP5 3B28 90 SWAP1 3B29 52 MSTORE 3B2A 60 PUSH1 0x24 3B2C 81 DUP2 3B2D 01 ADD 3B2E 83 DUP4 3B2F 90 SWAP1 3B30 52 MSTORE 3B31 90 SWAP1 3B32 51 MLOAD 3B33 73 PUSH20 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f 3B48 91 SWAP2 3B49 63 PUSH4 0x61e3c944 3B4E 91 SWAP2 3B4F 60 PUSH1 0x44 3B51 80 DUP1 3B52 83 DUP4 3B53 01 ADD 3B54 92 SWAP3 3B55 60 PUSH1 0x00 3B57 92 SWAP3 3B58 91 SWAP2 3B59 90 SWAP1 3B5A 82 DUP3 3B5B 90 SWAP1 3B5C 03 SUB 3B5D 01 ADD 3B5E 81 DUP2 3B5F 83 DUP4 3B60 87 DUP8 3B61 80 DUP1 3B62 3B EXTCODESIZE 3B63 15 ISZERO 3B64 80 DUP1 3B65 15 ISZERO 3B66 61 PUSH2 0x3b6e 3B69 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @3B22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1878f251 << 0xe2 // @3B29 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-2] // @3B30 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] // @3B48 stack[0] = 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f // @3B4E stack[1] = 0x61e3c944 // @3B54 stack[2] = memory[0x40:0x60] + 0x44 // @3B57 stack[3] = 0x00 // @3B58 stack[4] = memory[0x40:0x60] // @3B5D stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @3B5E stack[6] = memory[0x40:0x60] // @3B5F stack[7] = 0x00 // @3B60 stack[8] = 0x8a5419cfc711b2343c17a6abf4b2bafabb06957f // @3B63 stack[9] = !address(0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length // } // Block ends with conditional jump to 0x3b6e, if !!address(0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length label_3B6A: // Incoming jump from 0x3B69, if not !!address(0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length // Inputs[1] { @3B6D memory[0x00:0x00] } 3B6A 60 PUSH1 0x00 3B6C 80 DUP1 3B6D FD *REVERT // Stack delta = +0 // Outputs[1] { @3B6D revert(memory[0x00:0x00]); } // Block terminates label_3B6E: // Incoming jump from 0x3B69, if !!address(0x8a5419cfc711b2343c17a6abf4b2bafabb06957f).code.length // Inputs[9] // { // @3B70 msg.gas // @3B71 stack[-2] // @3B71 stack[-7] // @3B71 stack[-4] // @3B71 stack[-6] // @3B71 memory[stack[-4]:stack[-4] + stack[-5]] // @3B71 stack[-3] // @3B71 stack[-5] // @3B71 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 3B6E 5B JUMPDEST 3B6F 50 POP 3B70 5A GAS 3B71 F1 CALL 3B72 15 ISZERO 3B73 80 DUP1 3B74 15 ISZERO 3B75 61 PUSH2 0x3b82 3B78 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @3B71 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3B72 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x3b82, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3B79: // Incoming jump from 0x3B78, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3B79 returndata.length // @3B7D returndata[0x00:0x00 + returndata.length] // @3B7E returndata.length // @3B81 memory[0x00:0x00 + returndata.length] // } 3B79 3D RETURNDATASIZE 3B7A 60 PUSH1 0x00 3B7C 80 DUP1 3B7D 3E RETURNDATACOPY 3B7E 3D RETURNDATASIZE 3B7F 60 PUSH1 0x00 3B81 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3B7D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3B81 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3B82: // Incoming jump from 0x3B78, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 3B82 5B JUMPDEST 3B83 50 POP 3B84 50 POP 3B85 50 POP 3B86 50 POP // Stack delta = -4 // Block continues label_3B87: // Incoming jump from 0x3B86 // Incoming jump from 0x3B14, if !stack[-2] // Inputs[1] { @3B8A stack[-3] } 3B87 5B JUMPDEST 3B88 50 POP 3B89 50 POP 3B8A 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_3B8B: // Incoming jump from 0x0C36 // Inputs[4] // { // @3BB2 stack[-2] // @3BB5 memory[0x40:0x60] // @3BD3 memory[0x40:0x60] // @3BDC address((0x01 << 0xa0) - 0x01 & 0x19c0976f590d67707e62397c87829d896dc0f1f1).code.length // } 3B8B 5B JUMPDEST 3B8C 60 PUSH1 0x00 3B8E 80 DUP1 3B8F 73 PUSH20 0x19c0976f590d67707e62397c87829d896dc0f1f1 3BA4 60 PUSH1 0x01 3BA6 60 PUSH1 0x01 3BA8 60 PUSH1 0xa0 3BAA 1B SHL 3BAB 03 SUB 3BAC 16 AND 3BAD 63 PUSH4 0x44e2a5a8 3BB2 85 DUP6 3BB3 60 PUSH1 0x40 3BB5 51 MLOAD 3BB6 82 DUP3 3BB7 63 PUSH4 0xffffffff 3BBC 16 AND 3BBD 60 PUSH1 0xe0 3BBF 1B SHL 3BC0 81 DUP2 3BC1 52 MSTORE 3BC2 60 PUSH1 0x04 3BC4 01 ADD 3BC5 80 DUP1 3BC6 82 DUP3 3BC7 81 DUP2 3BC8 52 MSTORE 3BC9 60 PUSH1 0x20 3BCB 01 ADD 3BCC 91 SWAP2 3BCD 50 POP 3BCE 50 POP 3BCF 60 PUSH1 0x20 3BD1 60 PUSH1 0x40 3BD3 51 MLOAD 3BD4 80 DUP1 3BD5 83 DUP4 3BD6 03 SUB 3BD7 81 DUP2 3BD8 60 PUSH1 0x00 3BDA 87 DUP8 3BDB 80 DUP1 3BDC 3B EXTCODESIZE 3BDD 15 ISZERO 3BDE 80 DUP1 3BDF 15 ISZERO 3BE0 61 PUSH2 0x3be8 3BE3 57 *JUMPI // Stack delta = +12 // Outputs[14] // { // @3B8C stack[0] = 0x00 // @3B8E stack[1] = 0x00 // @3BAC stack[2] = (0x01 << 0xa0) - 0x01 & 0x19c0976f590d67707e62397c87829d896dc0f1f1 // @3BAD stack[3] = 0x44e2a5a8 // @3BC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x44e2a5a8) << 0xe0 // @3BC8 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @3BCC stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @3BCF stack[5] = 0x20 // @3BD3 stack[6] = memory[0x40:0x60] // @3BD6 stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3BD7 stack[8] = memory[0x40:0x60] // @3BD8 stack[9] = 0x00 // @3BDA stack[10] = (0x01 << 0xa0) - 0x01 & 0x19c0976f590d67707e62397c87829d896dc0f1f1 // @3BDD stack[11] = !address((0x01 << 0xa0) - 0x01 & 0x19c0976f590d67707e62397c87829d896dc0f1f1).code.length // } // Block ends with conditional jump to 0x3be8, if !!address((0x01 << 0xa0) - 0x01 & 0x19c0976f590d67707e62397c87829d896dc0f1f1).code.length label_3BE4: // Incoming jump from 0x3BE3, if not !!address((0x01 << 0xa0) - 0x01 & 0x19c0976f590d67707e62397c87829d896dc0f1f1).code.length // Inputs[1] { @3BE7 memory[0x00:0x00] } 3BE4 60 PUSH1 0x00 3BE6 80 DUP1 3BE7 FD *REVERT // Stack delta = +0 // Outputs[1] { @3BE7 revert(memory[0x00:0x00]); } // Block terminates label_3BE8: // Incoming jump from 0x3BE3, if !!address((0x01 << 0xa0) - 0x01 & 0x19c0976f590d67707e62397c87829d896dc0f1f1).code.length // Inputs[9] // { // @3BEA msg.gas // @3BEB stack[-4] // @3BEB stack[-5] // @3BEB stack[-7] // @3BEB stack[-6] // @3BEB memory[stack[-4]:stack[-4] + stack[-5]] // @3BEB stack[-3] // @3BEB stack[-2] // @3BEB address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 3BE8 5B JUMPDEST 3BE9 50 POP 3BEA 5A GAS 3BEB F1 CALL 3BEC 15 ISZERO 3BED 80 DUP1 3BEE 15 ISZERO 3BEF 61 PUSH2 0x3bfc 3BF2 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @3BEB memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3BEC stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x3bfc, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3BF3: // Incoming jump from 0x3BF2, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3BF3 returndata.length // @3BF7 returndata[0x00:0x00 + returndata.length] // @3BF8 returndata.length // @3BFB memory[0x00:0x00 + returndata.length] // } 3BF3 3D RETURNDATASIZE 3BF4 60 PUSH1 0x00 3BF6 80 DUP1 3BF7 3E RETURNDATACOPY 3BF8 3D RETURNDATASIZE 3BF9 60 PUSH1 0x00 3BFB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3BF7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3BFB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3BFC: // Incoming jump from 0x3BF2, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @3C03 memory[0x40:0x60] // @3C04 returndata.length // } 3BFC 5B JUMPDEST 3BFD 50 POP 3BFE 50 POP 3BFF 50 POP 3C00 50 POP 3C01 60 PUSH1 0x40 3C03 51 MLOAD 3C04 3D RETURNDATASIZE 3C05 60 PUSH1 0x20 3C07 81 DUP2 3C08 10 LT 3C09 15 ISZERO 3C0A 61 PUSH2 0x3c12 3C0D 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3C03 stack[-4] = memory[0x40:0x60] // @3C04 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3c12, if !(returndata.length < 0x20) label_3C0E: // Incoming jump from 0x3C0D, if not !(returndata.length < 0x20) // Inputs[1] { @3C11 memory[0x00:0x00] } 3C0E 60 PUSH1 0x00 3C10 80 DUP1 3C11 FD *REVERT // Stack delta = +0 // Outputs[1] { @3C11 revert(memory[0x00:0x00]); } // Block terminates label_3C12: // Incoming jump from 0x3C0D, if !(returndata.length < 0x20) // Inputs[8] // { // @3C14 memory[stack[-2]:stack[-2] + 0x20] // @3C14 stack[-2] // @3C18 memory[0x40:0x60] // @3C2B stack[-7] // @3C34 memory[0x40:0x60] // @3C36 stack[-3] // @3C3C stack[-8] // @3C58 address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 3C12 5B JUMPDEST 3C13 50 POP 3C14 51 MLOAD 3C15 60 PUSH1 0x40 3C17 80 DUP1 3C18 51 MLOAD 3C19 63 PUSH4 0x3612d9a3 3C1E 60 PUSH1 0xe1 3C20 1B SHL 3C21 81 DUP2 3C22 52 MSTORE 3C23 60 PUSH1 0x01 3C25 60 PUSH1 0x01 3C27 60 PUSH1 0xa0 3C29 1B SHL 3C2A 03 SUB 3C2B 88 DUP9 3C2C 81 DUP2 3C2D 16 AND 3C2E 60 PUSH1 0x04 3C30 83 DUP4 3C31 01 ADD 3C32 52 MSTORE 3C33 91 SWAP2 3C34 51 MLOAD 3C35 92 SWAP3 3C36 93 SWAP4 3C37 50 POP 3C38 60 PUSH1 0x00 3C3A 92 SWAP3 3C3B 91 SWAP2 3C3C 89 DUP10 3C3D 16 AND 3C3E 91 SWAP2 3C3F 63 PUSH4 0x6c25b346 3C44 91 SWAP2 3C45 60 PUSH1 0x24 3C47 80 DUP1 3C48 82 DUP3 3C49 01 ADD 3C4A 92 SWAP3 3C4B 60 PUSH1 0x20 3C4D 92 SWAP3 3C4E 90 SWAP1 3C4F 91 SWAP2 3C50 90 SWAP1 3C51 82 DUP3 3C52 90 SWAP1 3C53 03 SUB 3C54 01 ADD 3C55 81 DUP2 3C56 86 DUP7 3C57 80 DUP1 3C58 3B EXTCODESIZE 3C59 15 ISZERO 3C5A 80 DUP1 3C5B 15 ISZERO 3C5C 61 PUSH2 0x3c64 3C5F 57 *JUMPI // Stack delta = +8 // Outputs[13] // { // @3C22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3612d9a3 << 0xe1 // @3C32 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-7] // @3C36 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @3C3A stack[-2] = 0x00 // @3C3E stack[-1] = stack[-8] & (0x01 << 0xa0) - 0x01 // @3C44 stack[0] = 0x6c25b346 // @3C4A stack[1] = memory[0x40:0x60] + 0x24 // @3C4D stack[2] = 0x20 // @3C4F stack[3] = memory[0x40:0x60] // @3C54 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @3C55 stack[5] = memory[0x40:0x60] // @3C56 stack[6] = stack[-8] & (0x01 << 0xa0) - 0x01 // @3C59 stack[7] = !address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x3c64, if !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_3C60: // Incoming jump from 0x3C5F, if not !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @3C63 memory[0x00:0x00] } 3C60 60 PUSH1 0x00 3C62 80 DUP1 3C63 FD *REVERT // Stack delta = +0 // Outputs[1] { @3C63 revert(memory[0x00:0x00]); } // Block terminates label_3C64: // Incoming jump from 0x3C5F, if !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @3C66 msg.gas // @3C67 stack[-6] // @3C67 stack[-5] // @3C67 stack[-2] // @3C67 memory[stack[-3]:stack[-3] + stack[-4]] // @3C67 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3C67 stack[-4] // @3C67 stack[-3] // } 3C64 5B JUMPDEST 3C65 50 POP 3C66 5A GAS 3C67 FA STATICCALL 3C68 15 ISZERO 3C69 80 DUP1 3C6A 15 ISZERO 3C6B 61 PUSH2 0x3c78 3C6E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3C67 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3C68 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3c78, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3C6F: // Incoming jump from 0x3C6E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3C6F returndata.length // @3C73 returndata[0x00:0x00 + returndata.length] // @3C74 returndata.length // @3C77 memory[0x00:0x00 + returndata.length] // } 3C6F 3D RETURNDATASIZE 3C70 60 PUSH1 0x00 3C72 80 DUP1 3C73 3E RETURNDATACOPY 3C74 3D RETURNDATASIZE 3C75 60 PUSH1 0x00 3C77 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3C73 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3C77 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3C78: // Incoming jump from 0x3C6E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3C7F memory[0x40:0x60] // @3C80 returndata.length // } 3C78 5B JUMPDEST 3C79 50 POP 3C7A 50 POP 3C7B 50 POP 3C7C 50 POP 3C7D 60 PUSH1 0x40 3C7F 51 MLOAD 3C80 3D RETURNDATASIZE 3C81 60 PUSH1 0x20 3C83 81 DUP2 3C84 10 LT 3C85 15 ISZERO 3C86 61 PUSH2 0x3c8e 3C89 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3C7F stack[-4] = memory[0x40:0x60] // @3C80 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3c8e, if !(returndata.length < 0x20) label_3C8A: // Incoming jump from 0x3C89, if not !(returndata.length < 0x20) // Inputs[1] { @3C8D memory[0x00:0x00] } 3C8A 60 PUSH1 0x00 3C8C 80 DUP1 3C8D FD *REVERT // Stack delta = +0 // Outputs[1] { @3C8D revert(memory[0x00:0x00]); } // Block terminates label_3C8E: // Incoming jump from 0x3C89, if !(returndata.length < 0x20) // Inputs[4] // { // @3C90 stack[-2] // @3C90 memory[stack[-2]:stack[-2] + 0x20] // @3C91 stack[-3] // @3C96 stack[-6] // } 3C8E 5B JUMPDEST 3C8F 50 POP 3C90 51 MLOAD 3C91 90 SWAP1 3C92 50 POP 3C93 61 PUSH2 0x3ca7 3C96 84 DUP5 3C97 67 PUSH8 0x6765c793fa10079d 3CA0 60 PUSH1 0x1b 3CA2 1B SHL 3CA3 61 PUSH2 0x3da8 3CA6 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @3C91 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @3C93 stack[-2] = 0x3ca7 // @3C96 stack[-1] = stack[-6] // @3CA2 stack[0] = 0x6765c793fa10079d << 0x1b // } // Block ends with unconditional jump to 0x3da8 3CA7 5B JUMPDEST 3CA8 81 DUP2 3CA9 10 LT 3CAA 15 ISZERO 3CAB 61 PUSH2 0x3d11 3CAE 57 *JUMPI 3CAF 61 PUSH2 0x3cdd 3CB2 82 DUP3 3CB3 61 PUSH2 0x3cd0 3CB6 61 PUSH2 0x3cca 3CB9 87 DUP8 3CBA 67 PUSH8 0x6765c793fa10079d 3CC3 60 PUSH1 0x1b 3CC5 1B SHL 3CC6 61 PUSH2 0x3da8 3CC9 56 *JUMP 3CCA 5B JUMPDEST 3CCB 84 DUP5 3CCC 61 PUSH2 0x4117 3CCF 56 *JUMP 3CD0 5B JUMPDEST 3CD1 81 DUP2 3CD2 61 PUSH2 0x3cd7 3CD5 57 *JUMPI 3CD6 FE *ASSERT 3CD7 5B JUMPDEST 3CD8 04 DIV 3CD9 61 PUSH2 0x3d62 3CDC 56 *JUMP 3CDD 5B JUMPDEST 3CDE 92 SWAP3 3CDF 50 POP 3CE0 61 PUSH2 0x3cf4 3CE3 84 DUP5 3CE4 67 PUSH8 0x6765c793fa10079d 3CED 60 PUSH1 0x1b 3CEF 1B SHL 3CF0 61 PUSH2 0x3da8 3CF3 56 *JUMP 3CF4 5B JUMPDEST 3CF5 61 PUSH2 0x3cfe 3CF8 84 DUP5 3CF9 84 DUP5 3CFA 61 PUSH2 0x3da8 3CFD 56 *JUMP 3CFE 5B JUMPDEST 3CFF 10 LT 3D00 61 PUSH2 0x3d09 3D03 57 *JUMPI 3D04 82 DUP3 3D05 61 PUSH2 0x3d0e 3D08 56 *JUMP 3D09 5B JUMPDEST 3D0A 82 DUP3 3D0B 60 PUSH1 0x01 3D0D 01 ADD 3D0E 5B JUMPDEST 3D0F 92 SWAP3 3D10 50 POP 3D11 5B JUMPDEST 3D12 50 POP 3D13 50 POP 3D14 94 SWAP5 3D15 93 SWAP4 3D16 50 POP 3D17 50 POP 3D18 50 POP 3D19 50 POP 3D1A 56 *JUMP label_3D1B: // Incoming call from 0x1023, returns to 0x1024 // Incoming call from 0x20C7, returns to 0x20C8 // Incoming call from 0x2C7F, returns to 0x2C80 // Incoming call from 0x1D3F, returns to 0x1D40 // Inputs[1] { @3D26 stack[-1] } 3D1B 5B JUMPDEST 3D1C 60 PUSH1 0x00 3D1E 60 PUSH1 0x01 3D20 60 PUSH1 0x01 3D22 60 PUSH1 0xa0 3D24 1B SHL 3D25 03 SUB 3D26 82 DUP3 3D27 16 AND 3D28 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 3D3D 14 EQ 3D3E 61 PUSH2 0x3d48 3D41 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3D1C stack[0] = 0x00 } // Block ends with conditional jump to 0x3d48, if 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 == stack[-1] & (0x01 << 0xa0) - 0x01 label_3D42: // Incoming jump from 0x3D41, if not 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 == stack[-1] & (0x01 << 0xa0) - 0x01 3D42 60 PUSH1 0x00 3D44 61 PUSH2 0x3b08 3D47 56 *JUMP // Stack delta = +1 // Outputs[1] { @3D42 stack[0] = 0x00 } // Block ends with unconditional jump to 0x3b08 label_3D48: // Incoming jump from 0x3D41, if 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @3D4C stack[-3] // @3D4D stack[-2] // } 3D48 5B JUMPDEST 3D49 50 POP 3D4A 60 PUSH1 0x01 3D4C 91 SWAP2 3D4D 90 SWAP1 3D4E 50 POP 3D4F 56 *JUMP // Stack delta = -2 // Outputs[1] { @3D4C stack[-3] = 0x01 } // Block ends with unconditional jump to stack[-3] label_3D50: // Incoming jump from 0x234F // Incoming jump from 0x12F5 // Incoming jump from 0x2B2E // Incoming jump from 0x1BD7 // Inputs[2] // { // @3D56 stack[-1] // @3D57 stack[-2] // } 3D50 5B JUMPDEST 3D51 60 PUSH1 0x00 3D53 61 PUSH2 0x3aea 3D56 82 DUP3 3D57 84 DUP5 3D58 60 PUSH1 0x12 3D5A 03 SUB 3D5B 60 PUSH1 0x0a 3D5D 0A EXP 3D5E 61 PUSH2 0x3da8 3D61 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3D51 stack[0] = 0x00 // @3D53 stack[1] = 0x3aea // @3D56 stack[2] = stack[-1] // @3D5D stack[3] = 0x0a ** (0x12 - stack[-2]) // } // Block ends with unconditional jump to 0x3da8 label_3D62: // Incoming call from 0x1BF8, returns to 0x1BF9 // Inputs[1] { @3D63 stack[-1] } 3D62 5B JUMPDEST 3D63 80 DUP1 3D64 60 PUSH1 0x00 3D66 81 DUP2 3D67 12 SLT 3D68 15 ISZERO 3D69 61 PUSH2 0x394b 3D6C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3D63 stack[0] = stack[-1] } // Block ends with conditional jump to 0x394b, if !(stack[-1] i< 0x00) label_3D6D: // Incoming jump from 0x3D6C, if not !(stack[-1] i< 0x00) // Inputs[3] // { // @3D70 memory[0x40:0x60] // @3D9E memory[0x40:0x60] // @3DA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3D6D 60 PUSH1 0x40 3D6F 80 DUP1 3D70 51 MLOAD 3D71 62 PUSH3 0x461bcd 3D75 60 PUSH1 0xe5 3D77 1B SHL 3D78 81 DUP2 3D79 52 MSTORE 3D7A 60 PUSH1 0x20 3D7C 60 PUSH1 0x04 3D7E 82 DUP3 3D7F 01 ADD 3D80 52 MSTORE 3D81 60 PUSH1 0x0c 3D83 60 PUSH1 0x24 3D85 82 DUP3 3D86 01 ADD 3D87 52 MSTORE 3D88 6B PUSH12 0x696e742d6f766572666c6f77 3D95 60 PUSH1 0xa0 3D97 1B SHL 3D98 60 PUSH1 0x44 3D9A 82 DUP3 3D9B 01 ADD 3D9C 52 MSTORE 3D9D 90 SWAP1 3D9E 51 MLOAD 3D9F 90 SWAP1 3DA0 81 DUP2 3DA1 90 SWAP1 3DA2 03 SUB 3DA3 60 PUSH1 0x64 3DA5 01 ADD 3DA6 90 SWAP1 3DA7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3D79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3D80 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3D87 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @3D9C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x696e742d6f766572666c6f77 << 0xa0 // @3DA7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3DA8: // Incoming jump from 0x3B07 // Incoming jump from 0x3F4F // Incoming jump from 0x3D61 // Incoming jump from 0x32FE // Incoming jump from 0x3CA6 // Incoming jump from 0x1883 // Incoming jump from 0x32D9 // Inputs[2] // { // @3DAE stack[-2] // @3DAF stack[-1] // } 3DA8 5B JUMPDEST 3DA9 60 PUSH1 0x00 3DAB 61 PUSH2 0x3aea 3DAE 83 DUP4 3DAF 83 DUP4 3DB0 61 PUSH2 0x4123 3DB3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3DA9 stack[0] = 0x00 // @3DAB stack[1] = 0x3aea // @3DAE stack[2] = stack[-2] // @3DAF stack[3] = stack[-1] // } // Block ends with call to 0x4123, returns to 0x3AEA label_3DB4: // Incoming jump from 0x1B60 // Inputs[2] // { // @3DB7 stack[-2] // @3DBE stack[-1] // } 3DB4 5B JUMPDEST 3DB5 60 PUSH1 0x00 3DB7 82 DUP3 3DB8 60 PUSH1 0x12 3DBA 03 SUB 3DBB 60 PUSH1 0x0a 3DBD 0A EXP 3DBE 82 DUP3 3DBF 81 DUP2 3DC0 61 PUSH2 0x3dc5 3DC3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3DB5 stack[0] = 0x00 // @3DBD stack[1] = 0x0a ** (0x12 - stack[-2]) // @3DBE stack[2] = stack[-1] // } // Block ends with conditional jump to 0x3dc5, if 0x0a ** (0x12 - stack[-2]) label_3DC4: // Incoming jump from 0x3DC3, if not 0x0a ** (0x12 - stack[-2]) 3DC4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3DC4 assert(); } // Block terminates label_3DC5: // Incoming jump from 0x3DC3, if 0x0a ** (0x12 - stack[-2]) // Inputs[4] // { // @3DC6 stack[-2] // @3DC6 stack[-1] // @3DC7 stack[-6] // @3DC8 stack[-5] // } 3DC5 5B JUMPDEST 3DC6 04 DIV 3DC7 93 SWAP4 3DC8 92 SWAP3 3DC9 50 POP 3DCA 50 POP 3DCB 50 POP 3DCC 56 *JUMP // Stack delta = -5 // Outputs[1] { @3DC7 stack[-6] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-6] label_3DCD: // Incoming jump from 0x2E05 // Inputs[5] // { // @3DD1 stack[-3] // @3DE0 stack[-2] // @3DE3 memory[0x40:0x60] // @3E01 memory[0x40:0x60] // @3E08 address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // } 3DCD 5B JUMPDEST 3DCE 60 PUSH1 0x00 3DD0 80 DUP1 3DD1 84 DUP5 3DD2 60 PUSH1 0x01 3DD4 60 PUSH1 0x01 3DD6 60 PUSH1 0xa0 3DD8 1B SHL 3DD9 03 SUB 3DDA 16 AND 3DDB 63 PUSH4 0xd9638d36 3DE0 85 DUP6 3DE1 60 PUSH1 0x40 3DE3 51 MLOAD 3DE4 82 DUP3 3DE5 63 PUSH4 0xffffffff 3DEA 16 AND 3DEB 60 PUSH1 0xe0 3DED 1B SHL 3DEE 81 DUP2 3DEF 52 MSTORE 3DF0 60 PUSH1 0x04 3DF2 01 ADD 3DF3 80 DUP1 3DF4 82 DUP3 3DF5 81 DUP2 3DF6 52 MSTORE 3DF7 60 PUSH1 0x20 3DF9 01 ADD 3DFA 91 SWAP2 3DFB 50 POP 3DFC 50 POP 3DFD 60 PUSH1 0xa0 3DFF 60 PUSH1 0x40 3E01 51 MLOAD 3E02 80 DUP1 3E03 83 DUP4 3E04 03 SUB 3E05 81 DUP2 3E06 86 DUP7 3E07 80 DUP1 3E08 3B EXTCODESIZE 3E09 15 ISZERO 3E0A 80 DUP1 3E0B 15 ISZERO 3E0C 61 PUSH2 0x3e14 3E0F 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @3DCE stack[0] = 0x00 // @3DD0 stack[1] = 0x00 // @3DDA stack[2] = (0x01 << 0xa0) - 0x01 & stack[-3] // @3DDB stack[3] = 0xd9638d36 // @3DEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd9638d36) << 0xe0 // @3DF6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @3DFA stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @3DFD stack[5] = 0xa0 // @3E01 stack[6] = memory[0x40:0x60] // @3E04 stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3E05 stack[8] = memory[0x40:0x60] // @3E06 stack[9] = (0x01 << 0xa0) - 0x01 & stack[-3] // @3E09 stack[10] = !address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // } // Block ends with conditional jump to 0x3e14, if !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length label_3E10: // Incoming jump from 0x3E0F, if not !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // Inputs[1] { @3E13 memory[0x00:0x00] } 3E10 60 PUSH1 0x00 3E12 80 DUP1 3E13 FD *REVERT // Stack delta = +0 // Outputs[1] { @3E13 revert(memory[0x00:0x00]); } // Block terminates label_3E14: // Incoming jump from 0x3E0F, if !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // Inputs[8] // { // @3E16 msg.gas // @3E17 stack[-6] // @3E17 memory[stack[-3]:stack[-3] + stack[-4]] // @3E17 stack[-5] // @3E17 stack[-4] // @3E17 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3E17 stack[-3] // @3E17 stack[-2] // } 3E14 5B JUMPDEST 3E15 50 POP 3E16 5A GAS 3E17 FA STATICCALL 3E18 15 ISZERO 3E19 80 DUP1 3E1A 15 ISZERO 3E1B 61 PUSH2 0x3e28 3E1E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3E17 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3E18 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3e28, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3E1F: // Incoming jump from 0x3E1E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3E1F returndata.length // @3E23 returndata[0x00:0x00 + returndata.length] // @3E24 returndata.length // @3E27 memory[0x00:0x00 + returndata.length] // } 3E1F 3D RETURNDATASIZE 3E20 60 PUSH1 0x00 3E22 80 DUP1 3E23 3E RETURNDATACOPY 3E24 3D RETURNDATASIZE 3E25 60 PUSH1 0x00 3E27 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3E23 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3E27 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3E28: // Incoming jump from 0x3E1E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3E2F memory[0x40:0x60] // @3E30 returndata.length // } 3E28 5B JUMPDEST 3E29 50 POP 3E2A 50 POP 3E2B 50 POP 3E2C 50 POP 3E2D 60 PUSH1 0x40 3E2F 51 MLOAD 3E30 3D RETURNDATASIZE 3E31 60 PUSH1 0xa0 3E33 81 DUP2 3E34 10 LT 3E35 15 ISZERO 3E36 61 PUSH2 0x3e3e 3E39 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3E2F stack[-4] = memory[0x40:0x60] // @3E30 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3e3e, if !(returndata.length < 0xa0) label_3E3A: // Incoming jump from 0x3E39, if not !(returndata.length < 0xa0) // Inputs[1] { @3E3D memory[0x00:0x00] } 3E3A 60 PUSH1 0x00 3E3C 80 DUP1 3E3D FD *REVERT // Stack delta = +0 // Outputs[1] { @3E3D revert(memory[0x00:0x00]); } // Block terminates label_3E3E: // Incoming jump from 0x3E39, if !(returndata.length < 0xa0) // Inputs[9] // { // @3E42 stack[-2] // @3E43 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @3E47 memory[0x40:0x60] // @3E56 stack[-6] // @3E61 stack[-5] // @3E6A memory[0x40:0x60] // @3E6C stack[-3] // @3E72 stack[-7] // @3E89 address(stack[-7] & (0x01 << 0xa0) - 0x01).code.length // } 3E3E 5B JUMPDEST 3E3F 50 POP 3E40 60 PUSH1 0x20 3E42 01 ADD 3E43 51 MLOAD 3E44 60 PUSH1 0x40 3E46 80 DUP1 3E47 51 MLOAD 3E48 63 PUSH4 0x09092f97 3E4D 60 PUSH1 0xe2 3E4F 1B SHL 3E50 81 DUP2 3E51 52 MSTORE 3E52 60 PUSH1 0x04 3E54 81 DUP2 3E55 01 ADD 3E56 87 DUP8 3E57 90 SWAP1 3E58 52 MSTORE 3E59 60 PUSH1 0x01 3E5B 60 PUSH1 0x01 3E5D 60 PUSH1 0xa0 3E5F 1B SHL 3E60 03 SUB 3E61 86 DUP7 3E62 81 DUP2 3E63 16 AND 3E64 60 PUSH1 0x24 3E66 83 DUP4 3E67 01 ADD 3E68 52 MSTORE 3E69 82 DUP3 3E6A 51 MLOAD 3E6B 93 SWAP4 3E6C 94 SWAP5 3E6D 50 POP 3E6E 60 PUSH1 0x00 3E70 93 SWAP4 3E71 90 SWAP1 3E72 89 DUP10 3E73 16 AND 3E74 92 SWAP3 3E75 63 PUSH4 0x2424be5c 3E7A 92 SWAP3 3E7B 60 PUSH1 0x44 3E7D 80 DUP1 3E7E 82 DUP3 3E7F 01 ADD 3E80 93 SWAP4 3E81 91 SWAP2 3E82 82 DUP3 3E83 90 SWAP1 3E84 03 SUB 3E85 01 ADD 3E86 81 DUP2 3E87 86 DUP7 3E88 80 DUP1 3E89 3B EXTCODESIZE 3E8A 15 ISZERO 3E8B 80 DUP1 3E8C 15 ISZERO 3E8D 61 PUSH2 0x3e95 3E90 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @3E51 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x09092f97 << 0xe2 // @3E58 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-6] // @3E68 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @3E6C stack[-3] = memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @3E70 stack[-2] = 0x00 // @3E74 stack[2] = 0x40 // @3E74 stack[-1] = stack[-7] & (0x01 << 0xa0) - 0x01 // @3E7A stack[0] = 0x2424be5c // @3E80 stack[1] = memory[0x40:0x60] + 0x44 // @3E81 stack[3] = memory[0x40:0x60] // @3E85 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @3E86 stack[5] = memory[0x40:0x60] // @3E87 stack[6] = stack[-7] & (0x01 << 0xa0) - 0x01 // @3E8A stack[7] = !address(stack[-7] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x3e95, if !!address(stack[-7] & (0x01 << 0xa0) - 0x01).code.length label_3E91: // Incoming jump from 0x3E90, if not !!address(stack[-7] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @3E94 memory[0x00:0x00] } 3E91 60 PUSH1 0x00 3E93 80 DUP1 3E94 FD *REVERT // Stack delta = +0 // Outputs[1] { @3E94 revert(memory[0x00:0x00]); } // Block terminates label_3E95: // Incoming jump from 0x3E90, if !!address(stack[-7] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @3E97 msg.gas // @3E98 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3E98 stack[-2] // @3E98 stack[-5] // @3E98 stack[-4] // @3E98 stack[-3] // @3E98 stack[-6] // @3E98 memory[stack[-3]:stack[-3] + stack[-4]] // } 3E95 5B JUMPDEST 3E96 50 POP 3E97 5A GAS 3E98 FA STATICCALL 3E99 15 ISZERO 3E9A 80 DUP1 3E9B 15 ISZERO 3E9C 61 PUSH2 0x3ea9 3E9F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3E98 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3E99 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3ea9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3EA0: // Incoming jump from 0x3E9F, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3EA0 returndata.length // @3EA4 returndata[0x00:0x00 + returndata.length] // @3EA5 returndata.length // @3EA8 memory[0x00:0x00 + returndata.length] // } 3EA0 3D RETURNDATASIZE 3EA1 60 PUSH1 0x00 3EA3 80 DUP1 3EA4 3E RETURNDATACOPY 3EA5 3D RETURNDATASIZE 3EA6 60 PUSH1 0x00 3EA8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3EA4 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3EA8 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3EA9: // Incoming jump from 0x3E9F, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3EB0 memory[0x40:0x60] // @3EB1 returndata.length // } 3EA9 5B JUMPDEST 3EAA 50 POP 3EAB 50 POP 3EAC 50 POP 3EAD 50 POP 3EAE 60 PUSH1 0x40 3EB0 51 MLOAD 3EB1 3D RETURNDATASIZE 3EB2 60 PUSH1 0x40 3EB4 81 DUP2 3EB5 10 LT 3EB6 15 ISZERO 3EB7 61 PUSH2 0x3ebf 3EBA 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3EB0 stack[-4] = memory[0x40:0x60] // @3EB1 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3ebf, if !(returndata.length < 0x40) label_3EBB: // Incoming jump from 0x3EBA, if not !(returndata.length < 0x40) // Inputs[1] { @3EBE memory[0x00:0x00] } 3EBB 60 PUSH1 0x00 3EBD 80 DUP1 3EBE FD *REVERT // Stack delta = +0 // Outputs[1] { @3EBE revert(memory[0x00:0x00]); } // Block terminates label_3EBF: // Incoming jump from 0x3EBA, if !(returndata.length < 0x40) // Inputs[8] // { // @3EC3 stack[-2] // @3EC6 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @3ECA memory[0x40:0x60] // @3EDD stack[-6] // @3EE6 memory[0x40:0x60] // @3EE8 stack[-3] // @3EEE stack[-8] // @3F07 address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 3EBF 5B JUMPDEST 3EC0 50 POP 3EC1 60 PUSH1 0x20 3EC3 90 SWAP1 3EC4 81 DUP2 3EC5 01 ADD 3EC6 51 MLOAD 3EC7 60 PUSH1 0x40 3EC9 80 DUP1 3ECA 51 MLOAD 3ECB 63 PUSH4 0x3612d9a3 3ED0 60 PUSH1 0xe1 3ED2 1B SHL 3ED3 81 DUP2 3ED4 52 MSTORE 3ED5 60 PUSH1 0x01 3ED7 60 PUSH1 0x01 3ED9 60 PUSH1 0xa0 3EDB 1B SHL 3EDC 03 SUB 3EDD 88 DUP9 3EDE 81 DUP2 3EDF 16 AND 3EE0 60 PUSH1 0x04 3EE2 83 DUP4 3EE3 01 ADD 3EE4 52 MSTORE 3EE5 91 SWAP2 3EE6 51 MLOAD 3EE7 92 SWAP3 3EE8 94 SWAP5 3EE9 50 POP 3EEA 60 PUSH1 0x00 3EEC 93 SWAP4 3EED 91 SWAP2 3EEE 8A DUP11 3EEF 16 AND 3EF0 92 SWAP3 3EF1 63 PUSH4 0x6c25b346 3EF6 92 SWAP3 3EF7 60 PUSH1 0x24 3EF9 80 DUP1 3EFA 84 DUP5 3EFB 01 ADD 3EFC 93 SWAP4 3EFD 91 SWAP2 3EFE 92 SWAP3 3EFF 91 SWAP2 3F00 82 DUP3 3F01 90 SWAP1 3F02 03 SUB 3F03 01 ADD 3F04 81 DUP2 3F05 86 DUP7 3F06 80 DUP1 3F07 3B EXTCODESIZE 3F08 15 ISZERO 3F09 80 DUP1 3F0A 15 ISZERO 3F0B 61 PUSH2 0x3f13 3F0E 57 *JUMPI // Stack delta = +8 // Outputs[13] // { // @3ED4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3612d9a3 << 0xe1 // @3EE4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @3EE8 stack[-3] = memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @3EEC stack[-2] = 0x00 // @3EF0 stack[-1] = stack[-8] & (0x01 << 0xa0) - 0x01 // @3EF6 stack[0] = 0x6c25b346 // @3EFC stack[1] = memory[0x40:0x60] + 0x24 // @3EFE stack[2] = 0x20 // @3EFF stack[3] = memory[0x40:0x60] // @3F03 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @3F04 stack[5] = memory[0x40:0x60] // @3F05 stack[6] = stack[-8] & (0x01 << 0xa0) - 0x01 // @3F08 stack[7] = !address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x3f13, if !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_3F0F: // Incoming jump from 0x3F0E, if not !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @3F12 memory[0x00:0x00] } 3F0F 60 PUSH1 0x00 3F11 80 DUP1 3F12 FD *REVERT // Stack delta = +0 // Outputs[1] { @3F12 revert(memory[0x00:0x00]); } // Block terminates label_3F13: // Incoming jump from 0x3F0E, if !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @3F15 msg.gas // @3F16 stack[-6] // @3F16 stack[-5] // @3F16 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3F16 stack[-2] // @3F16 stack[-3] // @3F16 stack[-4] // @3F16 memory[stack[-3]:stack[-3] + stack[-4]] // } 3F13 5B JUMPDEST 3F14 50 POP 3F15 5A GAS 3F16 FA STATICCALL 3F17 15 ISZERO 3F18 80 DUP1 3F19 15 ISZERO 3F1A 61 PUSH2 0x3f27 3F1D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3F16 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3F17 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3f27, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3F1E: // Incoming jump from 0x3F1D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3F1E returndata.length // @3F22 returndata[0x00:0x00 + returndata.length] // @3F23 returndata.length // @3F26 memory[0x00:0x00 + returndata.length] // } 3F1E 3D RETURNDATASIZE 3F1F 60 PUSH1 0x00 3F21 80 DUP1 3F22 3E RETURNDATACOPY 3F23 3D RETURNDATASIZE 3F24 60 PUSH1 0x00 3F26 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3F22 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3F26 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3F27: // Incoming jump from 0x3F1D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3F2E memory[0x40:0x60] // @3F2F returndata.length // } 3F27 5B JUMPDEST 3F28 50 POP 3F29 50 POP 3F2A 50 POP 3F2B 50 POP 3F2C 60 PUSH1 0x40 3F2E 51 MLOAD 3F2F 3D RETURNDATASIZE 3F30 60 PUSH1 0x20 3F32 81 DUP2 3F33 10 LT 3F34 15 ISZERO 3F35 61 PUSH2 0x3f3d 3F38 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3F2E stack[-4] = memory[0x40:0x60] // @3F2F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3f3d, if !(returndata.length < 0x20) label_3F39: // Incoming jump from 0x3F38, if not !(returndata.length < 0x20) // Inputs[1] { @3F3C memory[0x00:0x00] } 3F39 60 PUSH1 0x00 3F3B 80 DUP1 3F3C FD *REVERT // Stack delta = +0 // Outputs[1] { @3F3C revert(memory[0x00:0x00]); } // Block terminates label_3F3D: // Incoming jump from 0x3F38, if !(returndata.length < 0x20) // Inputs[5] // { // @3F3F memory[stack[-2]:stack[-2] + 0x20] // @3F3F stack[-2] // @3F40 stack[-3] // @3F4A stack[-4] // @3F4B stack[-5] // } 3F3D 5B JUMPDEST 3F3E 50 POP 3F3F 51 MLOAD 3F40 90 SWAP1 3F41 50 POP 3F42 60 PUSH1 0x00 3F44 61 PUSH2 0x3f56 3F47 61 PUSH2 0x3f50 3F4A 84 DUP5 3F4B 86 DUP7 3F4C 61 PUSH2 0x3da8 3F4F 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @3F40 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @3F42 stack[-2] = 0x00 // @3F44 stack[-1] = 0x3f56 // @3F47 stack[0] = 0x3f50 // @3F4A stack[1] = stack[-4] // @3F4B stack[2] = stack[-5] // } // Block ends with unconditional jump to 0x3da8 3F50 5B JUMPDEST 3F51 83 DUP4 3F52 61 PUSH2 0x4117 3F55 56 *JUMP 3F56 5B JUMPDEST 3F57 90 SWAP1 3F58 50 POP 3F59 67 PUSH8 0x6765c793fa10079d 3F62 60 PUSH1 0x1b 3F64 1B SHL 3F65 81 DUP2 3F66 04 DIV 3F67 94 SWAP5 3F68 50 POP 3F69 80 DUP1 3F6A 61 PUSH2 0x3f7e 3F6D 86 DUP7 3F6E 67 PUSH8 0x6765c793fa10079d 3F77 60 PUSH1 0x1b 3F79 1B SHL 3F7A 61 PUSH2 0x3da8 3F7D 56 *JUMP 3F7E 5B JUMPDEST 3F7F 10 LT 3F80 61 PUSH2 0x3f89 3F83 57 *JUMPI 3F84 84 DUP5 3F85 61 PUSH2 0x3f8e 3F88 56 *JUMP 3F89 5B JUMPDEST 3F8A 84 DUP5 3F8B 60 PUSH1 0x01 3F8D 01 ADD 3F8E 5B JUMPDEST 3F8F 98 SWAP9 3F90 97 SWAP8 3F91 50 POP 3F92 50 POP 3F93 50 POP 3F94 50 POP 3F95 50 POP 3F96 50 POP 3F97 50 POP 3F98 50 POP 3F99 56 *JUMP 3F9A 5B JUMPDEST 3F9B 60 PUSH1 0x00 3F9D 80 DUP1 3F9E 85 DUP6 3F9F 60 PUSH1 0x01 3FA1 60 PUSH1 0x01 3FA3 60 PUSH1 0xa0 3FA5 1B SHL 3FA6 03 SUB 3FA7 16 AND 3FA8 63 PUSH4 0xd9638d36 3FAD 84 DUP5 3FAE 60 PUSH1 0x40 3FB0 51 MLOAD 3FB1 82 DUP3 3FB2 63 PUSH4 0xffffffff 3FB7 16 AND 3FB8 60 PUSH1 0xe0 3FBA 1B SHL 3FBB 81 DUP2 3FBC 52 MSTORE 3FBD 60 PUSH1 0x04 3FBF 01 ADD 3FC0 80 DUP1 3FC1 82 DUP3 3FC2 81 DUP2 3FC3 52 MSTORE 3FC4 60 PUSH1 0x20 3FC6 01 ADD 3FC7 91 SWAP2 3FC8 50 POP 3FC9 50 POP 3FCA 60 PUSH1 0xa0 3FCC 60 PUSH1 0x40 3FCE 51 MLOAD 3FCF 80 DUP1 3FD0 83 DUP4 3FD1 03 SUB 3FD2 81 DUP2 3FD3 86 DUP7 3FD4 80 DUP1 3FD5 3B EXTCODESIZE 3FD6 15 ISZERO 3FD7 80 DUP1 3FD8 15 ISZERO 3FD9 61 PUSH2 0x3fe1 3FDC 57 *JUMPI 3FDD 60 PUSH1 0x00 3FDF 80 DUP1 3FE0 FD *REVERT 3FE1 5B JUMPDEST 3FE2 50 POP 3FE3 5A GAS 3FE4 FA STATICCALL 3FE5 15 ISZERO 3FE6 80 DUP1 3FE7 15 ISZERO 3FE8 61 PUSH2 0x3ff5 3FEB 57 *JUMPI 3FEC 3D RETURNDATASIZE 3FED 60 PUSH1 0x00 3FEF 80 DUP1 3FF0 3E RETURNDATACOPY 3FF1 3D RETURNDATASIZE 3FF2 60 PUSH1 0x00 3FF4 FD *REVERT 3FF5 5B JUMPDEST 3FF6 50 POP 3FF7 50 POP 3FF8 50 POP 3FF9 50 POP 3FFA 60 PUSH1 0x40 3FFC 51 MLOAD 3FFD 3D RETURNDATASIZE 3FFE 60 PUSH1 0xa0 4000 81 DUP2 4001 10 LT 4002 15 ISZERO 4003 61 PUSH2 0x400b 4006 57 *JUMPI 4007 60 PUSH1 0x00 4009 80 DUP1 400A FD *REVERT 400B 5B JUMPDEST 400C 50 POP 400D 60 PUSH1 0x20 400F 01 ADD 4010 51 MLOAD 4011 60 PUSH1 0x40 4013 80 DUP1 4014 51 MLOAD 4015 63 PUSH4 0x09092f97 401A 60 PUSH1 0xe2 401C 1B SHL 401D 81 DUP2 401E 52 MSTORE 401F 60 PUSH1 0x04 4021 81 DUP2 4022 01 ADD 4023 86 DUP7 4024 90 SWAP1 4025 52 MSTORE 4026 60 PUSH1 0x01 4028 60 PUSH1 0x01 402A 60 PUSH1 0xa0 402C 1B SHL 402D 03 SUB 402E 87 DUP8 402F 81 DUP2 4030 16 AND 4031 60 PUSH1 0x24 4033 83 DUP4 4034 01 ADD 4035 52 MSTORE 4036 82 DUP3 4037 51 MLOAD 4038 93 SWAP4 4039 94 SWAP5 403A 50 POP 403B 60 PUSH1 0x00 403D 93 SWAP4 403E 90 SWAP1 403F 8A DUP11 4040 16 AND 4041 92 SWAP3 4042 63 PUSH4 0x2424be5c 4047 92 SWAP3 4048 60 PUSH1 0x44 404A 80 DUP1 404B 82 DUP3 404C 01 ADD 404D 93 SWAP4 404E 91 SWAP2 404F 82 DUP3 4050 90 SWAP1 4051 03 SUB 4052 01 ADD 4053 81 DUP2 4054 86 DUP7 4055 80 DUP1 4056 3B EXTCODESIZE 4057 15 ISZERO 4058 80 DUP1 4059 15 ISZERO 405A 61 PUSH2 0x4062 405D 57 *JUMPI 405E 60 PUSH1 0x00 4060 80 DUP1 4061 FD *REVERT 4062 5B JUMPDEST 4063 50 POP 4064 5A GAS 4065 FA STATICCALL 4066 15 ISZERO 4067 80 DUP1 4068 15 ISZERO 4069 61 PUSH2 0x4076 406C 57 *JUMPI 406D 3D RETURNDATASIZE 406E 60 PUSH1 0x00 4070 80 DUP1 4071 3E RETURNDATACOPY 4072 3D RETURNDATASIZE 4073 60 PUSH1 0x00 4075 FD *REVERT 4076 5B JUMPDEST 4077 50 POP 4078 50 POP 4079 50 POP 407A 50 POP 407B 60 PUSH1 0x40 407D 51 MLOAD 407E 3D RETURNDATASIZE 407F 60 PUSH1 0x40 4081 81 DUP2 4082 10 LT 4083 15 ISZERO 4084 61 PUSH2 0x408c 4087 57 *JUMPI 4088 60 PUSH1 0x00 408A 80 DUP1 408B FD *REVERT 408C 5B JUMPDEST 408D 50 POP 408E 60 PUSH1 0x20 4090 01 ADD 4091 51 MLOAD 4092 90 SWAP1 4093 50 POP 4094 61 PUSH2 0x409f 4097 82 DUP3 4098 87 DUP8 4099 81 DUP2 409A 61 PUSH2 0x3cd7 409D 57 *JUMPI 409E FE *ASSERT 409F 5B JUMPDEST 40A0 92 SWAP3 40A1 50 POP 40A2 80 DUP1 40A3 83 DUP4 40A4 11 GT 40A5 15 ISZERO 40A6 61 PUSH2 0x40ba 40A9 57 *JUMPI 40AA 61 PUSH2 0x40b2 40AD 81 DUP2 40AE 61 PUSH2 0x3d62 40B1 56 *JUMP 40B2 5B JUMPDEST 40B3 60 PUSH1 0x00 40B5 03 SUB 40B6 61 PUSH2 0x3d0e 40B9 56 *JUMP 40BA 5B JUMPDEST 40BB 50 POP 40BC 50 POP 40BD 60 PUSH1 0x00 40BF 03 SUB 40C0 94 SWAP5 40C1 93 SWAP4 40C2 50 POP 40C3 50 POP 40C4 50 POP 40C5 50 POP 40C6 56 *JUMP label_40C7: // Incoming call from 0x363E, returns to 0x363F // Inputs[2] // { // @40CA stack[-1] // @40CB memory[stack[-1]:stack[-1] + 0x20] // } 40C7 5B JUMPDEST 40C8 60 PUSH1 0x00 40CA 81 DUP2 40CB 51 MLOAD 40CC 60 PUSH1 0x00 40CE 14 EQ 40CF 15 ISZERO 40D0 61 PUSH2 0x410f 40D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @40C8 stack[0] = 0x00 } // Block ends with conditional jump to 0x410f, if !(0x00 == memory[stack[-1]:stack[-1] + 0x20]) label_40D4: // Incoming jump from 0x40D3, if not !(0x00 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @40D7 memory[0x40:0x60] // @4105 memory[0x40:0x60] // @410E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 40D4 60 PUSH1 0x40 40D6 80 DUP1 40D7 51 MLOAD 40D8 62 PUSH3 0x461bcd 40DC 60 PUSH1 0xe5 40DE 1B SHL 40DF 81 DUP2 40E0 52 MSTORE 40E1 60 PUSH1 0x20 40E3 60 PUSH1 0x04 40E5 82 DUP3 40E6 01 ADD 40E7 52 MSTORE 40E8 60 PUSH1 0x0c 40EA 60 PUSH1 0x24 40EC 82 DUP3 40ED 01 ADD 40EE 52 MSTORE 40EF 6B PUSH12 0x737472696e672d656d707479 40FC 60 PUSH1 0xa0 40FE 1B SHL 40FF 60 PUSH1 0x44 4101 82 DUP3 4102 01 ADD 4103 52 MSTORE 4104 90 SWAP1 4105 51 MLOAD 4106 90 SWAP1 4107 81 DUP2 4108 90 SWAP1 4109 03 SUB 410A 60 PUSH1 0x64 410C 01 ADD 410D 90 SWAP1 410E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @40E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @40E7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @40EE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @4103 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x737472696e672d656d707479 << 0xa0 // @410E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_410F: // Incoming jump from 0x40D3, if !(0x00 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @4113 stack[-2] // @4114 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @4115 stack[-3] // } 410F 5B JUMPDEST 4110 50 POP 4111 60 PUSH1 0x20 4113 01 ADD 4114 51 MLOAD 4115 90 SWAP1 4116 56 *JUMP // Stack delta = -2 // Outputs[1] { @4115 stack[-3] = memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-3] 4117 5B JUMPDEST 4118 60 PUSH1 0x00 411A 61 PUSH2 0x3aea 411D 83 DUP4 411E 83 DUP4 411F 61 PUSH2 0x417c 4122 56 *JUMP label_4123: // Incoming call from 0x3DB3, returns to 0x3AEA // Inputs[1] { @4126 stack[-2] } 4123 5B JUMPDEST 4124 60 PUSH1 0x00 4126 82 DUP3 4127 61 PUSH2 0x4132 412A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4124 stack[0] = 0x00 } // Block ends with conditional jump to 0x4132, if stack[-2] label_412B: // Incoming jump from 0x412A, if not stack[-2] 412B 50 POP 412C 60 PUSH1 0x00 412E 61 PUSH2 0x3b08 4131 56 *JUMP // Stack delta = +0 // Outputs[1] { @412C stack[-1] = 0x00 } // Block ends with unconditional jump to 0x3b08 label_4132: // Incoming jump from 0x412A, if stack[-2] // Inputs[2] // { // @4133 stack[-3] // @4134 stack[-2] // } 4132 5B JUMPDEST 4133 82 DUP3 4134 82 DUP3 4135 02 MUL 4136 82 DUP3 4137 84 DUP5 4138 82 DUP3 4139 81 DUP2 413A 61 PUSH2 0x413f 413D 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @4135 stack[0] = stack[-2] * stack[-3] // @4136 stack[1] = stack[-2] // @4137 stack[2] = stack[-3] // @4138 stack[3] = stack[-2] * stack[-3] // } // Block ends with conditional jump to 0x413f, if stack[-3] label_413E: // Incoming jump from 0x413D, if not stack[-3] 413E FE *ASSERT // Stack delta = +0 // Outputs[1] { @413E assert(); } // Block terminates label_413F: // Incoming jump from 0x413D, if stack[-3] // Inputs[3] // { // @4140 stack[-2] // @4140 stack[-1] // @4141 stack[-3] // } 413F 5B JUMPDEST 4140 04 DIV 4141 14 EQ 4142 61 PUSH2 0x3aea 4145 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x3aea, if stack[-1] / stack[-2] == stack[-3] label_4146: // Incoming jump from 0x4145, if not stack[-1] / stack[-2] == stack[-3] // Inputs[3] // { // @4148 memory[0x40:0x60] // @4176 memory[0x40:0x60] // @417B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 4146 60 PUSH1 0x40 4148 51 MLOAD 4149 62 PUSH3 0x461bcd 414D 60 PUSH1 0xe5 414F 1B SHL 4150 81 DUP2 4151 52 MSTORE 4152 60 PUSH1 0x04 4154 01 ADD 4155 80 DUP1 4156 80 DUP1 4157 60 PUSH1 0x20 4159 01 ADD 415A 82 DUP3 415B 81 DUP2 415C 03 SUB 415D 82 DUP3 415E 52 MSTORE 415F 60 PUSH1 0x21 4161 81 DUP2 4162 52 MSTORE 4163 60 PUSH1 0x20 4165 01 ADD 4166 80 DUP1 4167 61 PUSH2 0x433e 416A 60 PUSH1 0x21 416C 91 SWAP2 416D 39 CODECOPY 416E 60 PUSH1 0x40 4170 01 ADD 4171 91 SWAP2 4172 50 POP 4173 50 POP 4174 60 PUSH1 0x40 4176 51 MLOAD 4177 80 DUP1 4178 91 SWAP2 4179 03 SUB 417A 90 SWAP1 417B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4151 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @415E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @4162 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @416D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x433e:0x435f] // @417B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates 417C 5B JUMPDEST 417D 60 PUSH1 0x00 417F 82 DUP3 4180 82 DUP3 4181 11 GT 4182 15 ISZERO 4183 61 PUSH2 0x41d3 4186 57 *JUMPI 4187 60 PUSH1 0x40 4189 80 DUP1 418A 51 MLOAD 418B 62 PUSH3 0x461bcd 418F 60 PUSH1 0xe5 4191 1B SHL 4192 81 DUP2 4193 52 MSTORE 4194 60 PUSH1 0x20 4196 60 PUSH1 0x04 4198 82 DUP3 4199 01 ADD 419A 52 MSTORE 419B 60 PUSH1 0x1e 419D 60 PUSH1 0x24 419F 82 DUP3 41A0 01 ADD 41A1 52 MSTORE 41A2 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 41C3 60 PUSH1 0x44 41C5 82 DUP3 41C6 01 ADD 41C7 52 MSTORE 41C8 90 SWAP1 41C9 51 MLOAD 41CA 90 SWAP1 41CB 81 DUP2 41CC 90 SWAP1 41CD 03 SUB 41CE 60 PUSH1 0x64 41D0 01 ADD 41D1 90 SWAP1 41D2 FD *REVERT 41D3 5B JUMPDEST 41D4 50 POP 41D5 90 SWAP1 41D6 03 SUB 41D7 90 SWAP1 41D8 56 *JUMP label_41D9: // Incoming call from 0x1EEF, returns to 0x1EF0 // Inputs[2] // { // @41DD memory[0x40:0x60] // @4205 stack[-1] // } 41D9 5B JUMPDEST 41DA 60 PUSH1 0x40 41DC 80 DUP1 41DD 51 MLOAD 41DE 60 PUSH1 0xa0 41E0 81 DUP2 41E1 01 ADD 41E2 82 DUP3 41E3 52 MSTORE 41E4 60 PUSH1 0x00 41E6 80 DUP1 41E7 82 DUP3 41E8 52 MSTORE 41E9 60 PUSH1 0x20 41EB 82 DUP3 41EC 01 ADD 41ED 81 DUP2 41EE 90 SWAP1 41EF 52 MSTORE 41F0 91 SWAP2 41F1 81 DUP2 41F2 01 ADD 41F3 82 DUP3 41F4 90 SWAP1 41F5 52 MSTORE 41F6 60 PUSH1 0x60 41F8 81 DUP2 41F9 01 ADD 41FA 82 DUP3 41FB 90 SWAP1 41FC 52 MSTORE 41FD 60 PUSH1 0x80 41FF 81 DUP2 4200 01 ADD 4201 91 SWAP2 4202 90 SWAP1 4203 91 SWAP2 4204 52 MSTORE 4205 90 SWAP1 4206 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @41E3 memory[0x40:0x60] = memory[0x40:0x60] + 0xa0 // @41E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @41EF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @41F5 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @41FC memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @4204 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = 0x00 // @4205 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] 4207 FE *ASSERT 4208 4C 4C 4209 6F PUSH16 0x675472616e736665722875696e743235 421A 36 CALLDATASIZE 421B 2C 2C 421C 62 PUSH3 0x797465 4220 73 PUSH20 0x33322c61646472657373294c6f67457869744461 4235 69 PUSH10 0x2875696e743235362c62 4240 79 PUSH26 0x74657333322c75696e743235362c75696e743235362c75696e74 425B 32 ORIGIN 425C 35 CALLDATALOAD 425D 36 CALLDATASIZE 425E 29 29 425F 4C 4C 4260 6F PUSH16 0x6757697468647261772875696e743235 4271 36 CALLDATASIZE 4272 2C 2C 4273 62 PUSH3 0x797465 4277 73 PUSH20 0x33322c75696e743235362c75696e743235362c75 428C 69 PUSH10 0x6e743235362900000000 4297 00 *STOP 4298 00 *STOP 4299 00 *STOP 429A 00 *STOP 429B 00 *STOP 429C 00 *STOP 429D 00 *STOP 429E 00 *STOP 429F 97 SWAP8 42A0 59 MSIZE 42A1 A6 A6 42A2 AC AC 42A3 90 SWAP1 42A4 97 SWAP8 42A5 7B PUSH28 0x93b58547b4a71c78317f391a284c6f67576974686472617744616928 42C2 75 PUSH22 0x696e743235362c75696e743235362c75696e74323536 42D9 29 29 42DA 4C 4C 42DB 6F PUSH16 0x674465706f7369744461692875696e74 42EC 32 ORIGIN 42ED 35 CALLDATALOAD 42EE 36 CALLDATASIZE 42EF 2C 2C 42F0 75 PUSH22 0x696e743235362c75696e74323536294c6f6757697468 4307 64 PUSH5 0x7261774c69 430D 71 PUSH18 0x756964617465642875696e743235362c6279 4320 74 PUSH21 0x657333322c75696e743235362c75696e743235362c 4336 75 PUSH22 0x696e7432353629536166654d6174683a206d756c7469 434D 70 PUSH17 0x6c69636174696f6e206f766572666c6f77 435F 4C 4C 4360 6F PUSH16 0x67426f72726f772875696e743235362c 4371 62 PUSH3 0x797465 4375 73 PUSH20 0x33322c75696e743235362c75696e743235362c75 438A 69 PUSH10 0x6e74323536294c6f6750 4395 61 PUSH2 0x7962 4398 61 PUSH2 0x636b 439B 28 28 439C 75 PUSH22 0x696e743235362c627974657333322c75696e74323536 43B3 2C 2C 43B4 75 PUSH22 0x696e743235362c75696e74323536294c6f674465706f 43CB 73 PUSH20 0x6974416e64426f72726f772875696e743235362c 43E0 62 PUSH3 0x797465 43E4 73 PUSH20 0x33322c75696e743235362c75696e743235362c75 43F9 69 PUSH10 0x6e743235362c75696e74 4404 32 ORIGIN 4405 35 CALLDATALOAD 4406 36 CALLDATASIZE 4407 2C 2C 4408 75 PUSH22 0x696e743235362c75696e743235362900000000000000 441F 00 *STOP 4420 00 *STOP 4421 00 *STOP 4422 00 *STOP 4423 00 *STOP 4424 5E 5E 4425 F3 *RETURN 4426 0B SIGNEXTEND 4427 99 SWAP10 4428 86 DUP7 4429 34 CALLVALUE 442A 52 MSTORE 442B 49 49 442C BC BC 442D 32 ORIGIN 442E D8 D8 442F 92 SWAP3 4430 8B DUP12 4431 7E PUSH31 0xe64de9435e394c6f674465706f7369742875696e743235362c627974657333 4451 32 ORIGIN 4452 2C 2C 4453 75 PUSH22 0x696e743235362c75696e743235362c75696e74323536 446A 29 29 446B A2 LOG2 446C 64 PUSH5 0x6970667358 4472 22 22 4473 12 SLT 4474 20 SHA3 4475 CF CF 4476 68 PUSH9 0xe6b079340bae666f9c 4480 B6 B6 4481 09 MULMOD 4482 B5 B5 4483 A6 A6 4484 56 *JUMP 4485 BD BD 4486 41 COINBASE 4487 DD DD 4488 2C 2C 4489 CB CB 448A 3C EXTCODECOPY 448B B2 SWAP 448C 47 SELFBALANCE 448D 9C SWAP13 448E 8B DUP12 448F 05 SDIV 4490 B3 B3 4491 FE *ASSERT 4492 97 SWAP8 4493 55 SSTORE 4494 4A 4A 4495 64 PUSH5 0x736f6c6343 449B 00 *STOP 449C 07 SMOD 449D 06 MOD 449E 00 *STOP 449F 33 CALLER