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 0x005e 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x005e, 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 0x4f1ef286 0019 11 GT 001A 61 PUSH2 0x0043 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0043, if 0x4f1ef286 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x4f1ef286 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x4f1ef286 0024 14 EQ 0025 61 PUSH2 0x0174 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0174, if 0x4f1ef286 == stack[-1] label_0029: // Incoming jump from 0x0028, if not 0x4f1ef286 == stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0x8da5cb5b 002F 14 EQ 0030 61 PUSH2 0x0201 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0201, if 0x8da5cb5b == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xf2fde38b 003A 14 EQ 003B 61 PUSH2 0x023f 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023f, if 0xf2fde38b == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xf2fde38b == stack[-1] 003F 61 PUSH2 0x00ca 0042 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00ca label_0043: // Incoming jump from 0x001D, if 0x4f1ef286 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0044 stack[-1] } 0043 5B JUMPDEST 0044 80 DUP1 0045 63 PUSH4 0x01ffc9a7 004A 14 EQ 004B 61 PUSH2 0x00d4 004E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d4, if 0x01ffc9a7 == stack[-1] label_004F: // Incoming jump from 0x004E, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @004F stack[-1] } 004F 80 DUP1 0050 63 PUSH4 0x3659cfe6 0055 14 EQ 0056 61 PUSH2 0x0134 0059 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0134, if 0x3659cfe6 == stack[-1] label_005A: // Incoming jump from 0x0059, if not 0x3659cfe6 == stack[-1] 005A 61 PUSH2 0x00ca 005D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00ca label_005E: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @005F msg.data.length } 005E 5B JUMPDEST 005F 36 CALLDATASIZE 0060 61 PUSH2 0x00ca 0063 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ca, if msg.data.length label_0064: // Incoming jump from 0x0063, if not msg.data.length // Inputs[3] // { // @0067 memory[0x40:0x60] // @00C0 memory[0x40:0x60] // @00C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0064 60 PUSH1 0x40 0066 80 DUP1 0067 51 MLOAD 0068 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0089 81 DUP2 008A 52 MSTORE 008B 60 PUSH1 0x20 008D 60 PUSH1 0x04 008F 82 DUP3 0090 01 ADD 0091 52 MSTORE 0092 60 PUSH1 0x0e 0094 60 PUSH1 0x24 0096 82 DUP3 0097 01 ADD 0098 52 MSTORE 0099 7F PUSH32 0x45544845525f52454a4543544544000000000000000000000000000000000000 00BA 60 PUSH1 0x44 00BC 82 DUP3 00BD 01 ADD 00BE 52 MSTORE 00BF 90 SWAP1 00C0 51 MLOAD 00C1 90 SWAP1 00C2 81 DUP2 00C3 90 SWAP1 00C4 03 SUB 00C5 60 PUSH1 0x64 00C7 01 ADD 00C8 90 SWAP1 00C9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @008A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0091 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0098 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @00BE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45544845525f52454a4543544544000000000000000000000000000000000000 // @00C9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_00CA: // Incoming jump from 0x005D // Incoming jump from 0x0063, if msg.data.length // Incoming jump from 0x0042 00CA 5B JUMPDEST 00CB 61 PUSH2 0x00d2 00CE 61 PUSH2 0x027f 00D1 56 *JUMP // Stack delta = +1 // Outputs[1] { @00CB stack[0] = 0x00d2 } // Block ends with unconditional jump to 0x027f label_00D2: // Incoming return from call to 0x0157 at 0x0152 00D2 5B JUMPDEST 00D3 00 *STOP // Stack delta = +0 // Outputs[1] { @00D3 stop(); } // Block terminates label_00D4: // Incoming jump from 0x004E, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @00D5 msg.value } 00D4 5B JUMPDEST 00D5 34 CALLVALUE 00D6 80 DUP1 00D7 15 ISZERO 00D8 61 PUSH2 0x00e0 00DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00D5 stack[0] = msg.value } // Block ends with conditional jump to 0x00e0, if !msg.value label_00DC: // Incoming jump from 0x00DB, if not !msg.value // Inputs[1] { @00DF memory[0x00:0x00] } 00DC 60 PUSH1 0x00 00DE 80 DUP1 00DF FD *REVERT // Stack delta = +0 // Outputs[1] { @00DF revert(memory[0x00:0x00]); } // Block terminates label_00E0: // Incoming jump from 0x00DB, if !msg.value // Inputs[1] { @00E8 msg.data.length } 00E0 5B JUMPDEST 00E1 50 POP 00E2 61 PUSH2 0x0120 00E5 60 PUSH1 0x04 00E7 80 DUP1 00E8 36 CALLDATASIZE 00E9 03 SUB 00EA 60 PUSH1 0x20 00EC 81 DUP2 00ED 10 LT 00EE 15 ISZERO 00EF 61 PUSH2 0x00f7 00F2 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @00E2 stack[-1] = 0x0120 // @00E5 stack[0] = 0x04 // @00E9 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00f7, returns to 0x0120, if !(msg.data.length - 0x04 < 0x20) label_00F3: // Incoming jump from 0x00F2, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @00F6 memory[0x00:0x00] } 00F3 60 PUSH1 0x00 00F5 80 DUP1 00F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F6 revert(memory[0x00:0x00]); } // Block terminates label_00F7: // Incoming call from 0x00F2, returns to 0x0120, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @00F9 stack[-2] // @00F9 msg.data[stack[-2]:stack[-2] + 0x20] // } 00F7 5B JUMPDEST 00F8 50 POP 00F9 35 CALLDATALOAD 00FA 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 011B 16 AND 011C 61 PUSH2 0x02ca 011F 56 *JUMP // Stack delta = -1 // Outputs[1] { @011B stack[-2] = 0xffffffff00000000000000000000000000000000000000000000000000000000 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x02ca label_0120: // Incoming return from call to 0x00F7 at 0x00F2 // Inputs[4] // { // @0124 memory[0x40:0x60] // @0125 stack[-1] // @012A memory[0x40:0x60] // @0133 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0120 5B JUMPDEST 0121 60 PUSH1 0x40 0123 80 DUP1 0124 51 MLOAD 0125 91 SWAP2 0126 15 ISZERO 0127 15 ISZERO 0128 82 DUP3 0129 52 MSTORE 012A 51 MLOAD 012B 90 SWAP1 012C 81 DUP2 012D 90 SWAP1 012E 03 SUB 012F 60 PUSH1 0x20 0131 01 ADD 0132 90 SWAP1 0133 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0129 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0133 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0134: // Incoming jump from 0x0059, if 0x3659cfe6 == stack[-1] // Inputs[1] { @0135 msg.value } 0134 5B JUMPDEST 0135 34 CALLVALUE 0136 80 DUP1 0137 15 ISZERO 0138 61 PUSH2 0x0140 013B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0135 stack[0] = msg.value } // Block ends with conditional jump to 0x0140, if !msg.value label_013C: // Incoming jump from 0x013B, if not !msg.value // Inputs[1] { @013F memory[0x00:0x00] } 013C 60 PUSH1 0x00 013E 80 DUP1 013F FD *REVERT // Stack delta = +0 // Outputs[1] { @013F revert(memory[0x00:0x00]); } // Block terminates label_0140: // Incoming jump from 0x013B, if !msg.value // Inputs[1] { @0148 msg.data.length } 0140 5B JUMPDEST 0141 50 POP 0142 61 PUSH2 0x00d2 0145 60 PUSH1 0x04 0147 80 DUP1 0148 36 CALLDATASIZE 0149 03 SUB 014A 60 PUSH1 0x20 014C 81 DUP2 014D 10 LT 014E 15 ISZERO 014F 61 PUSH2 0x0157 0152 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0142 stack[-1] = 0x00d2 // @0145 stack[0] = 0x04 // @0149 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0157, returns to 0x00D2, if !(msg.data.length - 0x04 < 0x20) label_0153: // Incoming jump from 0x0152, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0156 memory[0x00:0x00] } 0153 60 PUSH1 0x00 0155 80 DUP1 0156 FD *REVERT // Stack delta = +0 // Outputs[1] { @0156 revert(memory[0x00:0x00]); } // Block terminates label_0157: // Incoming call from 0x0152, returns to 0x00D2, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0159 msg.data[stack[-2]:stack[-2] + 0x20] // @0159 stack[-2] // } 0157 5B JUMPDEST 0158 50 POP 0159 35 CALLDATALOAD 015A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 016F 16 AND 0170 61 PUSH2 0x048d 0173 56 *JUMP // Stack delta = -1 // Outputs[1] { @016F stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x048d label_0174: // Incoming jump from 0x0028, if 0x4f1ef286 == stack[-1] // Inputs[1] { @017B msg.data.length } 0174 5B JUMPDEST 0175 61 PUSH2 0x00d2 0178 60 PUSH1 0x04 017A 80 DUP1 017B 36 CALLDATASIZE 017C 03 SUB 017D 60 PUSH1 0x40 017F 81 DUP2 0180 10 LT 0181 15 ISZERO 0182 61 PUSH2 0x018a 0185 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0175 stack[0] = 0x00d2 // @0178 stack[1] = 0x04 // @017C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x018a, if !(msg.data.length - 0x04 < 0x40) label_0186: // Incoming jump from 0x0185, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0189 memory[0x00:0x00] } 0186 60 PUSH1 0x00 0188 80 DUP1 0189 FD *REVERT // Stack delta = +0 // Outputs[1] { @0189 revert(memory[0x00:0x00]); } // Block terminates label_018A: // Incoming jump from 0x0185, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @01A0 stack[-2] // @01A1 msg.data[stack[-2]:stack[-2] + 0x20] // @01A4 stack[-1] // @01B0 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 018A 5B JUMPDEST 018B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01A0 82 DUP3 01A1 35 CALLDATALOAD 01A2 16 AND 01A3 91 SWAP2 01A4 90 SWAP1 01A5 81 DUP2 01A6 01 ADD 01A7 90 SWAP1 01A8 60 PUSH1 0x40 01AA 81 DUP2 01AB 01 ADD 01AC 60 PUSH1 0x20 01AE 82 DUP3 01AF 01 ADD 01B0 35 CALLDATALOAD 01B1 64 PUSH5 0x0100000000 01B7 81 DUP2 01B8 11 GT 01B9 15 ISZERO 01BA 61 PUSH2 0x01c2 01BD 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @01A3 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // @01A7 stack[0] = stack[-2] // @01A7 stack[-1] = stack[-2] + stack[-1] // @01AB stack[1] = stack[-2] + 0x40 // @01B0 stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x01c2, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) label_01BE: // Incoming jump from 0x01BD, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[1] { @01C1 memory[0x00:0x00] } 01BE 60 PUSH1 0x00 01C0 80 DUP1 01C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C1 revert(memory[0x00:0x00]); } // Block terminates label_01C2: // Incoming jump from 0x01BD, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[3] // { // @01C3 stack[-3] // @01C4 stack[-1] // @01C5 stack[-4] // } 01C2 5B JUMPDEST 01C3 82 DUP3 01C4 01 ADD 01C5 83 DUP4 01C6 60 PUSH1 0x20 01C8 82 DUP3 01C9 01 ADD 01CA 11 GT 01CB 15 ISZERO 01CC 61 PUSH2 0x01d4 01CF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @01C4 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x01d4, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_01D0: // Incoming jump from 0x01CF, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @01D3 memory[0x00:0x00] } 01D0 60 PUSH1 0x00 01D2 80 DUP1 01D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D3 revert(memory[0x00:0x00]); } // Block terminates label_01D4: // Incoming jump from 0x01CF, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @01D5 stack[-1] // @01D6 msg.data[stack[-1]:stack[-1] + 0x20] // @01DB stack[-2] // @01DC stack[-4] // } 01D4 5B JUMPDEST 01D5 80 DUP1 01D6 35 CALLDATALOAD 01D7 90 SWAP1 01D8 60 PUSH1 0x20 01DA 01 ADD 01DB 91 SWAP2 01DC 84 DUP5 01DD 60 PUSH1 0x01 01DF 83 DUP4 01E0 02 MUL 01E1 84 DUP5 01E2 01 ADD 01E3 11 GT 01E4 64 PUSH5 0x0100000000 01EA 83 DUP4 01EB 11 GT 01EC 17 OR 01ED 15 ISZERO 01EE 61 PUSH2 0x01f6 01F1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @01D7 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @01DB stack[0] = stack[-2] // @01DB stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x01f6, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_01F2: // Incoming jump from 0x01F1, 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] { @01F5 memory[0x00:0x00] } 01F2 60 PUSH1 0x00 01F4 80 DUP1 01F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F5 revert(memory[0x00:0x00]); } // Block terminates label_01F6: // Incoming jump from 0x01F1, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @01F8 stack[-2] // @01F8 stack[-3] // @01F9 stack[-5] // @01FB stack[-4] // } 01F6 5B JUMPDEST 01F7 50 POP 01F8 90 SWAP1 01F9 92 SWAP3 01FA 50 POP 01FB 90 SWAP1 01FC 50 POP 01FD 61 PUSH2 0x054a 0200 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @01F9 stack[-5] = stack[-3] // @01FB stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x054a label_0201: // Incoming jump from 0x0033, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0202 msg.value } 0201 5B JUMPDEST 0202 34 CALLVALUE 0203 80 DUP1 0204 15 ISZERO 0205 61 PUSH2 0x020d 0208 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0202 stack[0] = msg.value } // Block ends with conditional jump to 0x020d, if !msg.value label_0209: // Incoming jump from 0x0208, if not !msg.value // Inputs[1] { @020C memory[0x00:0x00] } 0209 60 PUSH1 0x00 020B 80 DUP1 020C FD *REVERT // Stack delta = +0 // Outputs[1] { @020C revert(memory[0x00:0x00]); } // Block terminates label_020D: // Incoming jump from 0x0208, if !msg.value 020D 5B JUMPDEST 020E 50 POP 020F 61 PUSH2 0x0216 0212 61 PUSH2 0x0630 0215 56 *JUMP // Stack delta = +0 // Outputs[1] { @020F stack[-1] = 0x0216 } // Block ends with call to 0x0630, returns to 0x0216 label_0216: // Incoming return from call to 0x0630 at 0x0215 // Inputs[4] // { // @021A memory[0x40:0x60] // @0231 stack[-1] // @0235 memory[0x40:0x60] // @023E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0216 5B JUMPDEST 0217 60 PUSH1 0x40 0219 80 DUP1 021A 51 MLOAD 021B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0230 90 SWAP1 0231 92 SWAP3 0232 16 AND 0233 82 DUP3 0234 52 MSTORE 0235 51 MLOAD 0236 90 SWAP1 0237 81 DUP2 0238 90 SWAP1 0239 03 SUB 023A 60 PUSH1 0x20 023C 01 ADD 023D 90 SWAP1 023E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0234 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @023E return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_023F: // Incoming jump from 0x003E, if 0xf2fde38b == stack[-1] // Inputs[1] { @0240 msg.value } 023F 5B JUMPDEST 0240 34 CALLVALUE 0241 80 DUP1 0242 15 ISZERO 0243 61 PUSH2 0x024b 0246 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0240 stack[0] = msg.value } // Block ends with conditional jump to 0x024b, if !msg.value label_0247: // Incoming jump from 0x0246, if not !msg.value // Inputs[1] { @024A memory[0x00:0x00] } 0247 60 PUSH1 0x00 0249 80 DUP1 024A FD *REVERT // Stack delta = +0 // Outputs[1] { @024A revert(memory[0x00:0x00]); } // Block terminates label_024B: // Incoming jump from 0x0246, if !msg.value // Inputs[1] { @0253 msg.data.length } 024B 5B JUMPDEST 024C 50 POP 024D 61 PUSH2 0x00d2 0250 60 PUSH1 0x04 0252 80 DUP1 0253 36 CALLDATASIZE 0254 03 SUB 0255 60 PUSH1 0x20 0257 81 DUP2 0258 10 LT 0259 15 ISZERO 025A 61 PUSH2 0x0262 025D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @024D stack[-1] = 0x00d2 // @0250 stack[0] = 0x04 // @0254 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0262, if !(msg.data.length - 0x04 < 0x20) label_025E: // Incoming jump from 0x025D, if not !(msg.data.length - 0x04 < 0x20) // 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 < 0x20) // Inputs[2] // { // @0264 stack[-2] // @0264 msg.data[stack[-2]:stack[-2] + 0x20] // } 0262 5B JUMPDEST 0263 50 POP 0264 35 CALLDATALOAD 0265 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 027A 16 AND 027B 61 PUSH2 0x063f 027E 56 *JUMP // Stack delta = -1 // Outputs[1] { @027A stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x063f label_027F: // Incoming jump from 0x00D1 // Inputs[9] // { // @02A1 storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] // @02A4 msg.data.length // @02A7 msg.data[0x00:0x00 + msg.data.length] // @02AA msg.data.length // @02AD msg.gas // @02AE memory[0x00:0x00 + msg.data.length] // @02AE address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @02B1 returndata.length // @02B5 returndata[0x00:0x00 + returndata.length] // } 027F 5B JUMPDEST 0280 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 02A1 54 SLOAD 02A2 60 PUSH1 0x00 02A4 36 CALLDATASIZE 02A5 81 DUP2 02A6 82 DUP3 02A7 37 CALLDATACOPY 02A8 80 DUP1 02A9 81 DUP2 02AA 36 CALLDATASIZE 02AB 83 DUP4 02AC 85 DUP6 02AD 5A GAS 02AE F4 DELEGATECALL 02AF 91 SWAP2 02B0 50 POP 02B1 3D RETURNDATASIZE 02B2 80 DUP1 02B3 82 DUP3 02B4 83 DUP4 02B5 3E RETURNDATACOPY 02B6 82 DUP3 02B7 80 DUP1 02B8 15 ISZERO 02B9 61 PUSH2 0x02c0 02BC 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @02A2 stack[1] = 0x00 // @02A7 memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @02AE memory[0x00:0x00] = address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @02AF stack[0] = address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @02B1 stack[2] = returndata.length // @02B5 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @02B6 stack[3] = address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // } // Block ends with conditional jump to 0x02c0, if !address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) label_02BD: // Incoming jump from 0x02BC, if not !address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[3] // { // @02BD stack[-2] // @02BE stack[-3] // @02BF memory[stack[-3]:stack[-3] + stack[-2]] // } 02BD 81 DUP2 02BE 83 DUP4 02BF F3 *RETURN // Stack delta = +0 // Outputs[1] { @02BF return memory[stack[-3]:stack[-3] + stack[-2]]; } // Block terminates label_02C0: // Incoming jump from 0x02BC, if !address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[3] // { // @02C1 stack[-2] // @02C2 stack[-3] // @02C3 memory[stack[-3]:stack[-3] + stack[-2]] // } 02C0 5B JUMPDEST 02C1 81 DUP2 02C2 83 DUP4 02C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C3 revert(memory[stack[-3]:stack[-3] + stack[-2]]); } // Block terminates label_02C4: // Incoming jump from 0x0857, if stack[-3] // Incoming jump from 0x0857, if stack[-3] // Inputs[1] { @02C9 stack[-5] } 02C4 5B JUMPDEST 02C5 50 POP 02C6 50 POP 02C7 50 POP 02C8 50 POP 02C9 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_02CA: // Incoming jump from 0x011F // Inputs[1] { @030F stack[-1] } 02CA 5B JUMPDEST 02CB 60 PUSH1 0x00 02CD 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 02EE 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 030F 83 DUP4 0310 16 AND 0311 14 EQ 0312 80 DUP1 0313 61 PUSH2 0x035d 0316 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @02CB stack[0] = 0x00 // @0311 stack[1] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x035d, if stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 label_0317: // Incoming jump from 0x0316, if not stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 // Inputs[1] { @035A stack[-3] } 0317 50 POP 0318 7F PUSH32 0x7f5828d000000000000000000000000000000000000000000000000000000000 0339 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 035A 83 DUP4 035B 16 AND 035C 14 EQ 035D 5B JUMPDEST 035E 15 ISZERO 035F 61 PUSH2 0x036a 0362 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x036a, if !(stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x7f5828d000000000000000000000000000000000000000000000000000000000) label_0363: // Incoming jump from 0x0362, if not !(stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x7f5828d000000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x0362, if not !stack[-1] 0363 50 POP 0364 60 PUSH1 0x01 0366 61 PUSH2 0x0488 0369 56 *JUMP // Stack delta = +0 // Outputs[1] { @0364 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x0488 label_036A: // Incoming jump from 0x0362, if !(stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x7f5828d000000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x0362, if !stack[-1] // Inputs[1] { @038D stack[-2] } 036A 5B JUMPDEST 036B 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 038C 80 DUP1 038D 83 DUP4 038E 16 AND 038F 14 EQ 0390 15 ISZERO 0391 61 PUSH2 0x039c 0394 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039c, if !(stack[-2] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0xffffffff00000000000000000000000000000000000000000000000000000000) label_0395: // Incoming jump from 0x0394, if not !(stack[-2] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0xffffffff00000000000000000000000000000000000000000000000000000000) 0395 50 POP 0396 60 PUSH1 0x00 0398 61 PUSH2 0x0488 039B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0396 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x0488 label_039C: // Incoming jump from 0x0394, if !(stack[-2] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0xffffffff00000000000000000000000000000000000000000000000000000000) // Inputs[5] // { // @03BE storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] // @03C2 memory[0x40:0x60] // @0407 stack[-2] // @040F memory[0x40:0x60] // @0440 address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 039C 5B JUMPDEST 039D 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 03BE 54 SLOAD 03BF 60 PUSH1 0x40 03C1 80 DUP1 03C2 51 MLOAD 03C3 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 03E4 81 DUP2 03E5 52 MSTORE 03E6 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 0407 85 DUP6 0408 16 AND 0409 60 PUSH1 0x04 040B 82 DUP3 040C 01 ADD 040D 52 MSTORE 040E 90 SWAP1 040F 51 MLOAD 0410 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0425 83 DUP4 0426 16 AND 0427 91 SWAP2 0428 63 PUSH4 0x01ffc9a7 042D 91 SWAP2 042E 60 PUSH1 0x24 0430 80 DUP1 0431 83 DUP4 0432 01 ADD 0433 92 SWAP3 0434 60 PUSH1 0x20 0436 92 SWAP3 0437 91 SWAP2 0438 90 SWAP1 0439 82 DUP3 043A 90 SWAP1 043B 03 SUB 043C 01 ADD 043D 81 DUP2 043E 86 DUP7 043F 80 DUP1 0440 3B EXTCODESIZE 0441 15 ISZERO 0442 80 DUP1 0443 15 ISZERO 0444 61 PUSH2 0x044c 0447 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @03BE stack[0] = storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] // @03E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01ffc9a700000000000000000000000000000000000000000000000000000000 // @040D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-2] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // @0427 stack[1] = storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] & 0xffffffffffffffffffffffffffffffffffffffff // @042D stack[2] = 0x01ffc9a7 // @0433 stack[3] = memory[0x40:0x60] + 0x24 // @0436 stack[4] = 0x20 // @0437 stack[5] = memory[0x40:0x60] // @043C stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @043D stack[7] = memory[0x40:0x60] // @043E stack[8] = storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] & 0xffffffffffffffffffffffffffffffffffffffff // @0441 stack[9] = !address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x044c, if !!address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_0448: // Incoming jump from 0x0447, if not !!address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @044B memory[0x00:0x00] } 0448 60 PUSH1 0x00 044A 80 DUP1 044B FD *REVERT // Stack delta = +0 // Outputs[1] { @044B revert(memory[0x00:0x00]); } // Block terminates label_044C: // Incoming jump from 0x0447, if !!address(storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[9] // { // @044E msg.gas // @044F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @044F stack[-3] // @044F memory[stack[-3]:stack[-3] + stack[-4]] // @044F stack[-6] // @044F stack[-2] // @044F stack[-4] // @044F stack[-5] // @0450 stack[-9] // } 044C 5B JUMPDEST 044D 50 POP 044E 5A GAS 044F FA STATICCALL 0450 92 SWAP3 0451 50 POP 0452 50 POP 0453 50 POP 0454 80 DUP1 0455 15 ISZERO 0456 61 PUSH2 0x0471 0459 57 *JUMPI // Stack delta = -8 // Outputs[2] // { // @044F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0450 stack[-9] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0471, if !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_045A: // Incoming jump from 0x0459, if not !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @045D memory[0x40:0x60] // @045E returndata.length // } 045A 50 POP 045B 60 PUSH1 0x40 045D 51 MLOAD 045E 3D RETURNDATASIZE 045F 60 PUSH1 0x20 0461 81 DUP2 0462 10 LT 0463 15 ISZERO 0464 61 PUSH2 0x046c 0467 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @045D stack[-1] = memory[0x40:0x60] // @045E stack[0] = returndata.length // } // Block ends with conditional jump to 0x046c, if !(returndata.length < 0x20) label_0468: // Incoming jump from 0x0467, if not !(returndata.length < 0x20) // Inputs[1] { @046B memory[0x00:0x00] } 0468 60 PUSH1 0x00 046A 80 DUP1 046B FD *REVERT // Stack delta = +0 // Outputs[1] { @046B revert(memory[0x00:0x00]); } // Block terminates label_046C: // Incoming jump from 0x0467, if !(returndata.length < 0x20) // Inputs[2] // { // @046E stack[-2] // @046E memory[stack[-2]:stack[-2] + 0x20] // } 046C 5B JUMPDEST 046D 50 POP 046E 51 MLOAD 046F 60 PUSH1 0x01 // Stack delta = +0 // Outputs[2] // { // @046E stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @046F stack[-1] = 0x01 // } // Block continues label_0471: // Incoming jump from 0x0459, if !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Incoming jump from 0x046F // Inputs[1] { @0475 stack[-1] } 0471 5B JUMPDEST 0472 61 PUSH2 0x047f 0475 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x047f, if stack[-1] label_0476: // Incoming jump from 0x0475, if not stack[-1] // Inputs[1] { @0478 stack[-2] } 0476 60 PUSH1 0x00 0478 91 SWAP2 0479 50 POP 047A 50 POP 047B 61 PUSH2 0x0488 047E 56 *JUMP // Stack delta = -1 // Outputs[1] { @0478 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x0488 label_047F: // Incoming jump from 0x0475, if stack[-1] // Inputs[3] // { // @0480 stack[-3] // @0480 stack[-1] // @0485 stack[-2] // } 047F 5B JUMPDEST 0480 91 SWAP2 0481 50 POP 0482 61 PUSH2 0x0488 0485 90 SWAP1 0486 50 POP 0487 56 *JUMP // Stack delta = -2 // Outputs[1] { @0480 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0488 label_0488: // Incoming jump from 0x0487 // Incoming jump from 0x0369 // Incoming jump from 0x047E // Incoming jump from 0x039B // Inputs[3] // { // @0489 stack[-3] // @0489 stack[-1] // @048A stack[-2] // } 0488 5B JUMPDEST 0489 91 SWAP2 048A 90 SWAP1 048B 50 POP 048C 56 *JUMP // Stack delta = -2 // Outputs[1] { @0489 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_048D: // Incoming jump from 0x0173 048D 5B JUMPDEST 048E 61 PUSH2 0x0495 0491 61 PUSH2 0x06e9 0494 56 *JUMP // Stack delta = +1 // Outputs[1] { @048E stack[0] = 0x0495 } // Block ends with call to 0x06e9, returns to 0x0495 label_0495: // Incoming return from call to 0x06E9 at 0x0494 // Inputs[2] // { // @04AB stack[-1] // @04AC msg.sender // } 0495 5B JUMPDEST 0496 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04AB 16 AND 04AC 33 CALLER 04AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04C2 16 AND 04C3 14 EQ 04C4 61 PUSH2 0x052e 04C7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x052e, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_04C8: // Incoming jump from 0x04C7, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[3] // { // @04CB memory[0x40:0x60] // @0524 memory[0x40:0x60] // @052D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 04C8 60 PUSH1 0x40 04CA 80 DUP1 04CB 51 MLOAD 04CC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 04ED 81 DUP2 04EE 52 MSTORE 04EF 60 PUSH1 0x20 04F1 60 PUSH1 0x04 04F3 82 DUP3 04F4 01 ADD 04F5 52 MSTORE 04F6 60 PUSH1 0x0e 04F8 60 PUSH1 0x24 04FA 82 DUP3 04FB 01 ADD 04FC 52 MSTORE 04FD 7F PUSH32 0x4e4f545f415554484f52495a4544000000000000000000000000000000000000 051E 60 PUSH1 0x44 0520 82 DUP3 0521 01 ADD 0522 52 MSTORE 0523 90 SWAP1 0524 51 MLOAD 0525 90 SWAP1 0526 81 DUP2 0527 90 SWAP1 0528 03 SUB 0529 60 PUSH1 0x64 052B 01 ADD 052C 90 SWAP1 052D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @04EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @04F5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @04FC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0522 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e4f545f415554484f52495a4544000000000000000000000000000000000000 // @052D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_052E: // Incoming jump from 0x04C7, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @0532 stack[-1] // @0535 memory[0x40:0x60] // } 052E 5B JUMPDEST 052F 61 PUSH2 0x0547 0532 81 DUP2 0533 60 PUSH1 0x40 0535 51 MLOAD 0536 80 DUP1 0537 60 PUSH1 0x20 0539 01 ADD 053A 60 PUSH1 0x40 053C 52 MSTORE 053D 80 DUP1 053E 60 PUSH1 0x00 0540 81 DUP2 0541 52 MSTORE 0542 50 POP 0543 61 PUSH2 0x070e 0546 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @052F stack[0] = 0x0547 // @0532 stack[1] = stack[-1] // @0535 stack[2] = memory[0x40:0x60] // @053C memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0541 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x070e, returns to 0x0547 label_0547: // Incoming return from call to 0x070E at 0x0546 // Incoming return from call to 0x0862 at 0x06E8 // Inputs[1] { @0549 stack[-2] } 0547 5B JUMPDEST 0548 50 POP 0549 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_054A: // Incoming jump from 0x0200 054A 5B JUMPDEST 054B 61 PUSH2 0x0552 054E 61 PUSH2 0x06e9 0551 56 *JUMP // Stack delta = +1 // Outputs[1] { @054B stack[0] = 0x0552 } // Block ends with call to 0x06e9, returns to 0x0552 label_0552: // Incoming return from call to 0x06E9 at 0x0551 // Inputs[2] // { // @0568 stack[-1] // @0569 msg.sender // } 0552 5B JUMPDEST 0553 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0568 16 AND 0569 33 CALLER 056A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 057F 16 AND 0580 14 EQ 0581 61 PUSH2 0x05eb 0584 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05eb, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_0585: // Incoming jump from 0x0584, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[3] // { // @0588 memory[0x40:0x60] // @05E1 memory[0x40:0x60] // @05EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0585 60 PUSH1 0x40 0587 80 DUP1 0588 51 MLOAD 0589 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 05AA 81 DUP2 05AB 52 MSTORE 05AC 60 PUSH1 0x20 05AE 60 PUSH1 0x04 05B0 82 DUP3 05B1 01 ADD 05B2 52 MSTORE 05B3 60 PUSH1 0x0e 05B5 60 PUSH1 0x24 05B7 82 DUP3 05B8 01 ADD 05B9 52 MSTORE 05BA 7F PUSH32 0x4e4f545f415554484f52495a4544000000000000000000000000000000000000 05DB 60 PUSH1 0x44 05DD 82 DUP3 05DE 01 ADD 05DF 52 MSTORE 05E0 90 SWAP1 05E1 51 MLOAD 05E2 90 SWAP1 05E3 81 DUP2 05E4 90 SWAP1 05E5 03 SUB 05E6 60 PUSH1 0x64 05E8 01 ADD 05E9 90 SWAP1 05EA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @05AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @05B2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05B9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @05DF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e4f545f415554484f52495a4544000000000000000000000000000000000000 // @05EA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_05EB: // Incoming jump from 0x0584, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[5] // { // @05EF stack[-3] // @05F0 stack[-2] // @05F1 stack[-1] // @0602 memory[0x40:0x60] // @0619 msg.data[stack[-2]:stack[-2] + stack[-1]] // } 05EB 5B JUMPDEST 05EC 61 PUSH2 0x062b 05EF 83 DUP4 05F0 83 DUP4 05F1 83 DUP4 05F2 80 DUP1 05F3 80 DUP1 05F4 60 PUSH1 0x1f 05F6 01 ADD 05F7 60 PUSH1 0x20 05F9 80 DUP1 05FA 91 SWAP2 05FB 04 DIV 05FC 02 MUL 05FD 60 PUSH1 0x20 05FF 01 ADD 0600 60 PUSH1 0x40 0602 51 MLOAD 0603 90 SWAP1 0604 81 DUP2 0605 01 ADD 0606 60 PUSH1 0x40 0608 52 MSTORE 0609 80 DUP1 060A 93 SWAP4 060B 92 SWAP3 060C 91 SWAP2 060D 90 SWAP1 060E 81 DUP2 060F 81 DUP2 0610 52 MSTORE 0611 60 PUSH1 0x20 0613 01 ADD 0614 83 DUP4 0615 83 DUP4 0616 80 DUP1 0617 82 DUP3 0618 84 DUP5 0619 37 CALLDATACOPY 061A 60 PUSH1 0x00 061C 92 SWAP3 061D 01 ADD 061E 91 SWAP2 061F 90 SWAP1 0620 91 SWAP2 0621 52 MSTORE 0622 50 POP 0623 61 PUSH2 0x070e 0626 92 SWAP3 0627 50 POP 0628 50 POP 0629 50 POP 062A 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @05EC stack[0] = 0x062b // @05EF stack[1] = stack[-3] // @0608 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @060A stack[2] = memory[0x40:0x60] // @0610 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0619 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @0621 memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // } // Block ends with call to 0x070e, returns to 0x062B label_062B: // Incoming return from call to 0x070E at 0x062A // Incoming jump from 0x0782, if !memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @062F stack[-4] } 062B 5B JUMPDEST 062C 50 POP 062D 50 POP 062E 50 POP 062F 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0630: // Incoming call from 0x0215, returns to 0x0216 0630 5B JUMPDEST 0631 60 PUSH1 0x00 0633 61 PUSH2 0x063a 0636 61 PUSH2 0x06e9 0639 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0631 stack[0] = 0x00 // @0633 stack[1] = 0x063a // } // Block ends with call to 0x06e9, returns to 0x063A label_063A: // Incoming return from call to 0x06E9 at 0x0639 // Inputs[3] // { // @063B stack[-1] // @063B stack[-2] // @063D stack[-3] // } 063A 5B JUMPDEST 063B 90 SWAP1 063C 50 POP 063D 90 SWAP1 063E 56 *JUMP // Stack delta = -2 // Outputs[1] { @063D stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_063F: // Incoming jump from 0x027E 063F 5B JUMPDEST 0640 61 PUSH2 0x0647 0643 61 PUSH2 0x06e9 0646 56 *JUMP // Stack delta = +1 // Outputs[1] { @0640 stack[0] = 0x0647 } // Block ends with call to 0x06e9, returns to 0x0647 label_0647: // Incoming return from call to 0x06E9 at 0x0646 // Inputs[2] // { // @065D stack[-1] // @065E msg.sender // } 0647 5B JUMPDEST 0648 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 065D 16 AND 065E 33 CALLER 065F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0674 16 AND 0675 14 EQ 0676 61 PUSH2 0x06e0 0679 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06e0, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_067A: // Incoming jump from 0x0679, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[3] // { // @067D memory[0x40:0x60] // @06D6 memory[0x40:0x60] // @06DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 067A 60 PUSH1 0x40 067C 80 DUP1 067D 51 MLOAD 067E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 069F 81 DUP2 06A0 52 MSTORE 06A1 60 PUSH1 0x20 06A3 60 PUSH1 0x04 06A5 82 DUP3 06A6 01 ADD 06A7 52 MSTORE 06A8 60 PUSH1 0x0e 06AA 60 PUSH1 0x24 06AC 82 DUP3 06AD 01 ADD 06AE 52 MSTORE 06AF 7F PUSH32 0x4e4f545f415554484f52495a4544000000000000000000000000000000000000 06D0 60 PUSH1 0x44 06D2 82 DUP3 06D3 01 ADD 06D4 52 MSTORE 06D5 90 SWAP1 06D6 51 MLOAD 06D7 90 SWAP1 06D8 81 DUP2 06D9 90 SWAP1 06DA 03 SUB 06DB 60 PUSH1 0x64 06DD 01 ADD 06DE 90 SWAP1 06DF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @06A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @06A7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06AE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @06D4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e4f545f415554484f52495a4544000000000000000000000000000000000000 // @06DF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_06E0: // Incoming jump from 0x0679, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[1] { @06E4 stack[-1] } 06E0 5B JUMPDEST 06E1 61 PUSH2 0x0547 06E4 81 DUP2 06E5 61 PUSH2 0x0862 06E8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06E1 stack[0] = 0x0547 // @06E4 stack[1] = stack[-1] // } // Block ends with call to 0x0862, returns to 0x0547 label_06E9: // Incoming call from 0x0551, returns to 0x0552 // Incoming call from 0x0639, returns to 0x063A // Incoming call from 0x086B, returns to 0x086C // Incoming call from 0x0494, returns to 0x0495 // Incoming call from 0x0646, returns to 0x0647 // Inputs[2] // { // @070B storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] // @070C stack[-1] // } 06E9 5B JUMPDEST 06EA 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 070B 54 SLOAD 070C 90 SWAP1 070D 56 *JUMP // Stack delta = +0 // Outputs[1] { @070C stack[-1] = storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] } // Block ends with unconditional jump to stack[-1] label_070E: // Incoming call from 0x0546, returns to 0x0547 // Incoming call from 0x062A, returns to 0x062B // Inputs[6] // { // @0731 storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] // @0733 stack[-2] // @0738 memory[0x40:0x60] // @077B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @077C stack[-1] // @077D memory[stack[-1]:stack[-1] + 0x20] // } 070E 5B JUMPDEST 070F 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 0730 80 DUP1 0731 54 SLOAD 0732 90 SWAP1 0733 83 DUP4 0734 90 SWAP1 0735 55 SSTORE 0736 60 PUSH1 0x40 0738 51 MLOAD 0739 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 074E 80 DUP1 074F 85 DUP6 0750 16 AND 0751 91 SWAP2 0752 90 SWAP1 0753 83 DUP4 0754 16 AND 0755 90 SWAP1 0756 7F PUSH32 0x5570d70a002632a7b0b3c9304cc89efb62d8da9eca0dbd7752c83b7379068296 0777 90 SWAP1 0778 60 PUSH1 0x00 077A 90 SWAP1 077B A3 LOG3 077C 81 DUP2 077D 51 MLOAD 077E 15 ISZERO 077F 61 PUSH2 0x062b 0782 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0732 stack[0] = storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] // @0735 storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] = stack[-2] // @077B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x5570d70a002632a7b0b3c9304cc89efb62d8da9eca0dbd7752c83b7379068296, storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with conditional jump to 0x062b, if !memory[stack[-1]:stack[-1] + 0x20] label_0783: // Incoming jump from 0x0782, if not !memory[stack[-1]:stack[-1] + 0x20] // Inputs[4] // { // @0785 stack[-3] // @079C stack[-2] // @079F memory[0x40:0x60] // @07A3 memory[stack[-2]:stack[-2] + 0x20] // } 0783 60 PUSH1 0x00 0785 83 DUP4 0786 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 079B 16 AND 079C 83 DUP4 079D 60 PUSH1 0x40 079F 51 MLOAD 07A0 80 DUP1 07A1 82 DUP3 07A2 80 DUP1 07A3 51 MLOAD 07A4 90 SWAP1 07A5 60 PUSH1 0x20 07A7 01 ADD 07A8 90 SWAP1 07A9 80 DUP1 07AA 83 DUP4 07AB 83 DUP4 07AC 5B JUMPDEST 07AD 60 PUSH1 0x20 07AF 83 DUP4 07B0 10 LT 07B1 61 PUSH2 0x07e9 07B4 57 *JUMPI // Stack delta = +10 // Outputs[10] // { // @0783 stack[0] = 0x00 // @079B stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @079C stack[2] = stack[-2] // @079F stack[3] = memory[0x40:0x60] // @07A0 stack[4] = memory[0x40:0x60] // @07A8 stack[5] = 0x20 + stack[-2] // @07A8 stack[6] = memory[stack[-2]:stack[-2] + 0x20] // @07A9 stack[7] = memory[stack[-2]:stack[-2] + 0x20] // @07AA stack[8] = memory[0x40:0x60] // @07AB stack[9] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x07e9, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 label_07B5: // Incoming jump from 0x07B4, if not memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Incoming jump from 0x07B4, if not stack[-3] < 0x20 // Inputs[4] // { // @07B5 stack[-1] // @07B6 memory[stack[-1]:stack[-1] + 0x20] // @07B7 stack[-2] // @07DB stack[-3] // } 07B5 80 DUP1 07B6 51 MLOAD 07B7 82 DUP3 07B8 52 MSTORE 07B9 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 07DA 90 SWAP1 07DB 92 SWAP3 07DC 01 ADD 07DD 91 SWAP2 07DE 60 PUSH1 0x20 07E0 91 SWAP2 07E1 82 DUP3 07E2 01 ADD 07E3 91 SWAP2 07E4 01 ADD 07E5 61 PUSH2 0x07ac 07E8 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @07B8 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @07DD stack[-3] = stack[-3] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @07E3 stack[-2] = 0x20 + stack[-2] // @07E4 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x07ac label_07E9: // Incoming jump from 0x07B4, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Incoming jump from 0x07B4, if stack[-3] < 0x20 // Inputs[15] // { // @07EC stack[-3] // @07F7 stack[-1] // @07F8 memory[stack[-1]:stack[-1] + 0x20] // @07FB stack[-2] // @07FC memory[stack[-2]:stack[-2] + 0x20] // @0809 stack[-5] // @0809 stack[-4] // @080B stack[-6] // @080C stack[-8] // @0813 memory[0x40:0x60] // @0818 stack[-9] // @0819 msg.gas // @081A address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @081A memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @081E returndata.length // } 07E9 5B JUMPDEST 07EA 60 PUSH1 0x01 07EC 83 DUP4 07ED 60 PUSH1 0x20 07EF 03 SUB 07F0 61 PUSH2 0x0100 07F3 0A EXP 07F4 03 SUB 07F5 80 DUP1 07F6 19 NOT 07F7 82 DUP3 07F8 51 MLOAD 07F9 16 AND 07FA 81 DUP2 07FB 84 DUP5 07FC 51 MLOAD 07FD 16 AND 07FE 80 DUP1 07FF 82 DUP3 0800 17 OR 0801 85 DUP6 0802 52 MSTORE 0803 50 POP 0804 50 POP 0805 50 POP 0806 50 POP 0807 50 POP 0808 50 POP 0809 90 SWAP1 080A 50 POP 080B 01 ADD 080C 91 SWAP2 080D 50 POP 080E 50 POP 080F 60 PUSH1 0x00 0811 60 PUSH1 0x40 0813 51 MLOAD 0814 80 DUP1 0815 83 DUP4 0816 03 SUB 0817 81 DUP2 0818 85 DUP6 0819 5A GAS 081A F4 DELEGATECALL 081B 91 SWAP2 081C 50 POP 081D 50 POP 081E 3D RETURNDATASIZE 081F 80 DUP1 0820 60 PUSH1 0x00 0822 81 DUP2 0823 14 EQ 0824 61 PUSH2 0x0849 0827 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @0802 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @081A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @081B stack[-9] = address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @081E stack[-8] = returndata.length // @081F stack[-7] = returndata.length // } // Block ends with conditional jump to 0x0849, if returndata.length == 0x00 label_0828: // Incoming jump from 0x0827, if not returndata.length == 0x00 // Inputs[6] // { // @082A memory[0x40:0x60] // @082B stack[-2] // @0832 returndata.length // @083A returndata.length // @083D returndata.length // @0844 returndata[0x00:0x00 + returndata.length] // } 0828 60 PUSH1 0x40 082A 51 MLOAD 082B 91 SWAP2 082C 50 POP 082D 60 PUSH1 0x1f 082F 19 NOT 0830 60 PUSH1 0x3f 0832 3D RETURNDATASIZE 0833 01 ADD 0834 16 AND 0835 82 DUP3 0836 01 ADD 0837 60 PUSH1 0x40 0839 52 MSTORE 083A 3D RETURNDATASIZE 083B 82 DUP3 083C 52 MSTORE 083D 3D RETURNDATASIZE 083E 60 PUSH1 0x00 0840 60 PUSH1 0x20 0842 84 DUP5 0843 01 ADD 0844 3E RETURNDATACOPY 0845 61 PUSH2 0x084e 0848 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @082B stack[-2] = memory[0x40:0x60] // @0839 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @083C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0844 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x084e label_0849: // Incoming jump from 0x0827, if returndata.length == 0x00 // Inputs[3] // { // @084C stack[-2] // @0851 stack[-4] // @0851 stack[-3] // } 0849 5B JUMPDEST 084A 60 PUSH1 0x60 084C 91 SWAP2 084D 50 POP 084E 5B JUMPDEST 084F 50 POP 0850 50 POP 0851 90 SWAP1 0852 50 POP 0853 80 DUP1 0854 61 PUSH2 0x02c4 0857 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0851 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x02c4, if stack[-3] label_0858: // Incoming jump from 0x0857, if not stack[-3] // Incoming jump from 0x0857, if not stack[-3] // Inputs[3] // { // @0858 returndata.length // @085D returndata[0x00:0x00 + returndata.length] // @0861 memory[0x00:0x00 + returndata.length] // } 0858 3D RETURNDATASIZE 0859 80 DUP1 085A 60 PUSH1 0x00 085C 80 DUP1 085D 3E RETURNDATACOPY 085E 80 DUP1 085F 60 PUSH1 0x00 0861 FD *REVERT // Stack delta = +1 // Outputs[3] // { // @0858 stack[0] = returndata.length // @085D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0861 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0862: // Incoming call from 0x06E8, returns to 0x0547 0862 5B JUMPDEST 0863 60 PUSH1 0x00 0865 61 PUSH2 0x086c 0868 61 PUSH2 0x06e9 086B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0863 stack[0] = 0x00 // @0865 stack[1] = 0x086c // } // Block ends with call to 0x06e9, returns to 0x086C label_086C: // Incoming return from call to 0x06E9 at 0x086B // Inputs[7] // { // @086D stack[-1] // @086D stack[-2] // @086F stack[-3] // @08E3 memory[0x40:0x60] // @08E6 memory[0x40:0x60] // @08EB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @08EE stack[-4] // } 086C 5B JUMPDEST 086D 90 SWAP1 086E 50 POP 086F 81 DUP2 0870 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 0891 55 SSTORE 0892 81 DUP2 0893 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08A8 16 AND 08A9 81 DUP2 08AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08BF 16 AND 08C0 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 08E1 60 PUSH1 0x40 08E3 51 MLOAD 08E4 60 PUSH1 0x40 08E6 51 MLOAD 08E7 80 DUP1 08E8 91 SWAP2 08E9 03 SUB 08EA 90 SWAP1 08EB A3 LOG3 08EC 50 POP 08ED 50 POP 08EE 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0891 storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] = stack[-3] // @08EB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] 08EF FE *ASSERT 08F0 A2 LOG2 08F1 64 PUSH5 0x6970667358 08F7 22 22 08F8 12 SLT 08F9 20 SHA3 08FA 8C DUP13 08FB 84 DUP5 08FC 42 TIMESTAMP 08FD 84 DUP5 08FE 5E 5E 08FF 51 MLOAD 0900 51 MLOAD 0901 9F SWAP16 0902 E6 E6 0903 62 PUSH3 0x69cee8 0907 FE *ASSERT 0908 05 SDIV 0909 4B 4B 090A 83 DUP4 090B B7 B7 090C 61 PUSH2 0x7dbc 090F D8 D8 0910 CF CF 0911 4D 4D 0912 60 PUSH1 0x74 0914 0D 0D 0915 27 27 0916 3F EXTCODEHASH 0917 A0 LOG0 0918 B8 B8 0919 A4 LOG4 091A 64 PUSH5 0x736f6c6343 0920 00 *STOP 0921 07 SMOD 0922 06 MOD 0923 00 *STOP 0924 33 CALLER