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 0x006d 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x006d, 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 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002E 90 SWAP1 002F 04 DIV 0030 63 PUSH4 0xffffffff 0035 16 AND 0036 80 DUP1 0037 63 PUSH4 0x3659cfe6 003C 14 EQ 003D 61 PUSH2 0x0077 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0077, if 0x3659cfe6 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x3659cfe6 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x4f1ef286 0047 14 EQ 0048 61 PUSH2 0x00ba 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ba, if 0x4f1ef286 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x4f1ef286 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x5c60da1b 0052 14 EQ 0053 61 PUSH2 0x0108 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0108, if 0x5c60da1b == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x5c60da1b == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x8f283970 005D 14 EQ 005E 61 PUSH2 0x015f 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015f, if 0x8f283970 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x8f283970 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf851a440 0068 14 EQ 0069 61 PUSH2 0x01a2 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a2, if 0xf851a440 == stack[-1] label_006D: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x006C, if not 0xf851a440 == stack[-1] 006D 5B JUMPDEST 006E 61 PUSH2 0x0075 0071 61 PUSH2 0x01f9 0074 56 *JUMP // Stack delta = +1 // Outputs[1] { @006E stack[0] = 0x0075 } // Block ends with unconditional jump to 0x01f9 0075 5B JUMPDEST 0076 00 *STOP label_0077: // Incoming jump from 0x0040, if 0x3659cfe6 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0078 msg.value } 0077 5B JUMPDEST 0078 34 CALLVALUE 0079 80 DUP1 007A 15 ISZERO 007B 61 PUSH2 0x0083 007E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0078 stack[0] = msg.value } // Block ends with conditional jump to 0x0083, if !msg.value label_007F: // Incoming jump from 0x007E, if not !msg.value // Inputs[1] { @0082 memory[0x00:0x00] } 007F 60 PUSH1 0x00 0081 80 DUP1 0082 FD *REVERT // Stack delta = +0 // Outputs[1] { @0082 revert(memory[0x00:0x00]); } // Block terminates label_0083: // Incoming jump from 0x007E, if !msg.value // Inputs[2] // { // @008B msg.data.length // @0092 msg.data[0x04:0x24] // } 0083 5B JUMPDEST 0084 50 POP 0085 61 PUSH2 0x00b8 0088 60 PUSH1 0x04 008A 80 DUP1 008B 36 CALLDATASIZE 008C 03 SUB 008D 81 DUP2 008E 01 ADD 008F 90 SWAP1 0090 80 DUP1 0091 80 DUP1 0092 35 CALLDATALOAD 0093 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00A8 16 AND 00A9 90 SWAP1 00AA 60 PUSH1 0x20 00AC 01 ADD 00AD 90 SWAP1 00AE 92 SWAP3 00AF 91 SWAP2 00B0 90 SWAP1 00B1 50 POP 00B2 50 POP 00B3 50 POP 00B4 61 PUSH2 0x0213 00B7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0085 stack[-1] = 0x00b8 // @00AE stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0213, returns to 0x00B8 label_00B8: // Incoming return from call to 0x0213 at 0x00B7 00B8 5B JUMPDEST 00B9 00 *STOP // Stack delta = +0 // Outputs[1] { @00B9 stop(); } // Block terminates label_00BA: // Incoming jump from 0x004B, if 0x4f1ef286 == stack[-1] // Inputs[4] // { // @00C1 msg.data.length // @00C8 msg.data[0x04:0x24] // @00E8 msg.data[0x24:0x44] // @00F1 msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20] // } 00BA 5B JUMPDEST 00BB 61 PUSH2 0x0106 00BE 60 PUSH1 0x04 00C0 80 DUP1 00C1 36 CALLDATASIZE 00C2 03 SUB 00C3 81 DUP2 00C4 01 ADD 00C5 90 SWAP1 00C6 80 DUP1 00C7 80 DUP1 00C8 35 CALLDATALOAD 00C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00DE 16 AND 00DF 90 SWAP1 00E0 60 PUSH1 0x20 00E2 01 ADD 00E3 90 SWAP1 00E4 92 SWAP3 00E5 91 SWAP2 00E6 90 SWAP1 00E7 80 DUP1 00E8 35 CALLDATALOAD 00E9 90 SWAP1 00EA 60 PUSH1 0x20 00EC 01 ADD 00ED 90 SWAP1 00EE 82 DUP3 00EF 01 ADD 00F0 80 DUP1 00F1 35 CALLDATALOAD 00F2 90 SWAP1 00F3 60 PUSH1 0x20 00F5 01 ADD 00F6 91 SWAP2 00F7 90 SWAP1 00F8 91 SWAP2 00F9 92 SWAP3 00FA 93 SWAP4 00FB 91 SWAP2 00FC 92 SWAP3 00FD 93 SWAP4 00FE 90 SWAP1 00FF 50 POP 0100 50 POP 0101 50 POP 0102 61 PUSH2 0x0268 0105 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00BB stack[0] = 0x0106 // @00E4 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @00FC stack[3] = msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20] // @00FD stack[2] = 0x20 + 0x04 + msg.data[0x24:0x44] // } // Block ends with call to 0x0268, returns to 0x0106 label_0106: // Incoming return from call to 0x0268 at 0x0105 0106 5B JUMPDEST 0107 00 *STOP // Stack delta = +0 // Outputs[1] { @0107 stop(); } // Block terminates label_0108: // Incoming jump from 0x0056, if 0x5c60da1b == stack[-1] // Inputs[1] { @0109 msg.value } 0108 5B JUMPDEST 0109 34 CALLVALUE 010A 80 DUP1 010B 15 ISZERO 010C 61 PUSH2 0x0114 010F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0109 stack[0] = msg.value } // Block ends with conditional jump to 0x0114, if !msg.value label_0110: // Incoming jump from 0x010F, if not !msg.value // Inputs[1] { @0113 memory[0x00:0x00] } 0110 60 PUSH1 0x00 0112 80 DUP1 0113 FD *REVERT // Stack delta = +0 // Outputs[1] { @0113 revert(memory[0x00:0x00]); } // Block terminates label_0114: // Incoming jump from 0x010F, if !msg.value 0114 5B JUMPDEST 0115 50 POP 0116 61 PUSH2 0x011d 0119 61 PUSH2 0x0305 011C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0116 stack[-1] = 0x011d } // Block ends with call to 0x0305, returns to 0x011D label_011D: // Incoming return from call to 0x0305 at 0x011C // Inputs[4] // { // @0120 memory[0x40:0x60] // @0122 stack[-1] // @0159 memory[0x40:0x60] // @015E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 011D 5B JUMPDEST 011E 60 PUSH1 0x40 0120 51 MLOAD 0121 80 DUP1 0122 82 DUP3 0123 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0138 16 AND 0139 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 014E 16 AND 014F 81 DUP2 0150 52 MSTORE 0151 60 PUSH1 0x20 0153 01 ADD 0154 91 SWAP2 0155 50 POP 0156 50 POP 0157 60 PUSH1 0x40 0159 51 MLOAD 015A 80 DUP1 015B 91 SWAP2 015C 03 SUB 015D 90 SWAP1 015E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0150 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @015E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_015F: // Incoming jump from 0x0061, if 0x8f283970 == stack[-1] // Inputs[1] { @0160 msg.value } 015F 5B JUMPDEST 0160 34 CALLVALUE 0161 80 DUP1 0162 15 ISZERO 0163 61 PUSH2 0x016b 0166 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0160 stack[0] = msg.value } // Block ends with conditional jump to 0x016b, if !msg.value label_0167: // Incoming jump from 0x0166, if not !msg.value // Inputs[1] { @016A memory[0x00:0x00] } 0167 60 PUSH1 0x00 0169 80 DUP1 016A FD *REVERT // Stack delta = +0 // Outputs[1] { @016A revert(memory[0x00:0x00]); } // Block terminates label_016B: // Incoming jump from 0x0166, if !msg.value // Inputs[2] // { // @0173 msg.data.length // @017A msg.data[0x04:0x24] // } 016B 5B JUMPDEST 016C 50 POP 016D 61 PUSH2 0x01a0 0170 60 PUSH1 0x04 0172 80 DUP1 0173 36 CALLDATASIZE 0174 03 SUB 0175 81 DUP2 0176 01 ADD 0177 90 SWAP1 0178 80 DUP1 0179 80 DUP1 017A 35 CALLDATALOAD 017B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0190 16 AND 0191 90 SWAP1 0192 60 PUSH1 0x20 0194 01 ADD 0195 90 SWAP1 0196 92 SWAP3 0197 91 SWAP2 0198 90 SWAP1 0199 50 POP 019A 50 POP 019B 50 POP 019C 61 PUSH2 0x035d 019F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @016D stack[-1] = 0x01a0 // @0196 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x035d, returns to 0x01A0 label_01A0: // Incoming return from call to 0x035D at 0x019F 01A0 5B JUMPDEST 01A1 00 *STOP // Stack delta = +0 // Outputs[1] { @01A1 stop(); } // Block terminates label_01A2: // Incoming jump from 0x006C, if 0xf851a440 == stack[-1] // Inputs[1] { @01A3 msg.value } 01A2 5B JUMPDEST 01A3 34 CALLVALUE 01A4 80 DUP1 01A5 15 ISZERO 01A6 61 PUSH2 0x01ae 01A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01A3 stack[0] = msg.value } // Block ends with conditional jump to 0x01ae, if !msg.value label_01AA: // Incoming jump from 0x01A9, if not !msg.value // Inputs[1] { @01AD memory[0x00:0x00] } 01AA 60 PUSH1 0x00 01AC 80 DUP1 01AD FD *REVERT // Stack delta = +0 // Outputs[1] { @01AD revert(memory[0x00:0x00]); } // Block terminates label_01AE: // Incoming jump from 0x01A9, if !msg.value 01AE 5B JUMPDEST 01AF 50 POP 01B0 61 PUSH2 0x01b7 01B3 61 PUSH2 0x051b 01B6 56 *JUMP // Stack delta = +0 // Outputs[1] { @01B0 stack[-1] = 0x01b7 } // Block ends with call to 0x051b, returns to 0x01B7 label_01B7: // Incoming return from call to 0x051B at 0x01B6 // Inputs[4] // { // @01BA memory[0x40:0x60] // @01BC stack[-1] // @01F3 memory[0x40:0x60] // @01F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01B7 5B JUMPDEST 01B8 60 PUSH1 0x40 01BA 51 MLOAD 01BB 80 DUP1 01BC 82 DUP3 01BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01D2 16 AND 01D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01E8 16 AND 01E9 81 DUP2 01EA 52 MSTORE 01EB 60 PUSH1 0x20 01ED 01 ADD 01EE 91 SWAP2 01EF 50 POP 01F0 50 POP 01F1 60 PUSH1 0x40 01F3 51 MLOAD 01F4 80 DUP1 01F5 91 SWAP2 01F6 03 SUB 01F7 90 SWAP1 01F8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @01F8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01F9: // Incoming jump from 0x0074 // Incoming jump from 0x056E // Incoming jump from 0x0516 // Incoming jump from 0x02FE // Incoming jump from 0x0263 // Incoming jump from 0x0358 01F9 5B JUMPDEST 01FA 61 PUSH2 0x0201 01FD 61 PUSH2 0x0573 0200 56 *JUMP // Stack delta = +1 // Outputs[1] { @01FA stack[0] = 0x0201 } // Block ends with call to 0x0573, returns to 0x0201 label_0201: // Incoming return from call to 0x0573 at 0x0200 0201 5B JUMPDEST 0202 61 PUSH2 0x0211 0205 61 PUSH2 0x020c 0208 61 PUSH2 0x064e 020B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0202 stack[0] = 0x0211 // @0205 stack[1] = 0x020c // } // Block ends with call to 0x064e, returns to 0x020C label_020C: // Incoming return from call to 0x064E at 0x020B 020C 5B JUMPDEST 020D 61 PUSH2 0x067f 0210 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x067f 0211 5B JUMPDEST 0212 56 *JUMP label_0213: // Incoming call from 0x00B7, returns to 0x00B8 0213 5B JUMPDEST 0214 61 PUSH2 0x021b 0217 61 PUSH2 0x06a5 021A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0214 stack[0] = 0x021b } // Block ends with call to 0x06a5, returns to 0x021B label_021B: // Incoming return from call to 0x06A5 at 0x021A // Inputs[2] // { // @0231 stack[-1] // @0232 msg.sender // } 021B 5B JUMPDEST 021C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0231 16 AND 0232 33 CALLER 0233 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0248 16 AND 0249 14 EQ 024A 15 ISZERO 024B 61 PUSH2 0x025c 024E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x025c, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_024F: // Incoming jump from 0x024E, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @0252 stack[-1] } 024F 61 PUSH2 0x0257 0252 81 DUP2 0253 61 PUSH2 0x06d6 0256 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @024F stack[0] = 0x0257 // @0252 stack[1] = stack[-1] // } // Block ends with call to 0x06d6, returns to 0x0257 label_0257: // Incoming return from call to 0x06D6 at 0x0256 0257 5B JUMPDEST 0258 61 PUSH2 0x0265 025B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0265 label_025C: // Incoming jump from 0x024E, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 025C 5B JUMPDEST 025D 61 PUSH2 0x0264 0260 61 PUSH2 0x01f9 0263 56 *JUMP // Stack delta = +1 // Outputs[1] { @025D stack[0] = 0x0264 } // Block ends with unconditional jump to 0x01f9 0264 5B JUMPDEST label_0265: // Incoming jump from 0x025B // Inputs[1] { @0267 stack[-2] } 0265 5B JUMPDEST 0266 50 POP 0267 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0268: // Incoming call from 0x0105, returns to 0x0106 0268 5B JUMPDEST 0269 61 PUSH2 0x0270 026C 61 PUSH2 0x06a5 026F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0269 stack[0] = 0x0270 } // Block ends with call to 0x06a5, returns to 0x0270 label_0270: // Incoming return from call to 0x06A5 at 0x026F // Inputs[2] // { // @0286 stack[-1] // @0287 msg.sender // } 0270 5B JUMPDEST 0271 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0286 16 AND 0287 33 CALLER 0288 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 029D 16 AND 029E 14 EQ 029F 15 ISZERO 02A0 61 PUSH2 0x02f7 02A3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x02f7, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_02A4: // Incoming jump from 0x02A3, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @02A7 stack[-3] } 02A4 61 PUSH2 0x02ac 02A7 83 DUP4 02A8 61 PUSH2 0x06d6 02AB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02A4 stack[0] = 0x02ac // @02A7 stack[1] = stack[-3] // } // Block ends with call to 0x06d6, returns to 0x02AC label_02AC: // Incoming return from call to 0x06D6 at 0x02AB // Inputs[9] // { // @02AD stack[-3] // @02C4 stack[-2] // @02C5 stack[-1] // @02C8 memory[0x40:0x60] // @02CF msg.data[stack[-2]:stack[-2] + stack[-1]] // @02DD memory[0x40:0x60] // @02E3 msg.gas // @02E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]] // @02E4 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // } 02AC 5B JUMPDEST 02AD 82 DUP3 02AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02C3 16 AND 02C4 82 DUP3 02C5 82 DUP3 02C6 60 PUSH1 0x40 02C8 51 MLOAD 02C9 80 DUP1 02CA 83 DUP4 02CB 83 DUP4 02CC 80 DUP1 02CD 82 DUP3 02CE 84 DUP5 02CF 37 CALLDATACOPY 02D0 82 DUP3 02D1 01 ADD 02D2 91 SWAP2 02D3 50 POP 02D4 50 POP 02D5 92 SWAP3 02D6 50 POP 02D7 50 POP 02D8 50 POP 02D9 60 PUSH1 0x00 02DB 60 PUSH1 0x40 02DD 51 MLOAD 02DE 80 DUP1 02DF 83 DUP4 02E0 03 SUB 02E1 81 DUP2 02E2 85 DUP6 02E3 5A GAS 02E4 F4 DELEGATECALL 02E5 91 SWAP2 02E6 50 POP 02E7 50 POP 02E8 15 ISZERO 02E9 15 ISZERO 02EA 61 PUSH2 0x02f2 02ED 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @02CF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @02E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x02f2, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) label_02EE: // Incoming jump from 0x02ED, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // Inputs[1] { @02F1 memory[0x00:0x00] } 02EE 60 PUSH1 0x00 02F0 80 DUP1 02F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F1 revert(memory[0x00:0x00]); } // Block terminates label_02F2: // Incoming jump from 0x02ED, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) 02F2 5B JUMPDEST 02F3 61 PUSH2 0x0300 02F6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0300 label_02F7: // Incoming jump from 0x02A3, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 02F7 5B JUMPDEST 02F8 61 PUSH2 0x02ff 02FB 61 PUSH2 0x01f9 02FE 56 *JUMP // Stack delta = +1 // Outputs[1] { @02F8 stack[0] = 0x02ff } // Block ends with unconditional jump to 0x01f9 02FF 5B JUMPDEST label_0300: // Incoming jump from 0x02F6 // Inputs[1] { @0304 stack[-4] } 0300 5B JUMPDEST 0301 50 POP 0302 50 POP 0303 50 POP 0304 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0305: // Incoming call from 0x011C, returns to 0x011D 0305 5B JUMPDEST 0306 60 PUSH1 0x00 0308 61 PUSH2 0x030f 030B 61 PUSH2 0x06a5 030E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0306 stack[0] = 0x00 // @0308 stack[1] = 0x030f // } // Block ends with call to 0x06a5, returns to 0x030F label_030F: // Incoming return from call to 0x06A5 at 0x030E // Inputs[2] // { // @0325 stack[-1] // @0326 msg.sender // } 030F 5B JUMPDEST 0310 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0325 16 AND 0326 33 CALLER 0327 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 033C 16 AND 033D 14 EQ 033E 15 ISZERO 033F 61 PUSH2 0x0351 0342 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0351, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0343: // Incoming jump from 0x0342, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0343 61 PUSH2 0x034a 0346 61 PUSH2 0x064e 0349 56 *JUMP // Stack delta = +1 // Outputs[1] { @0343 stack[0] = 0x034a } // Block ends with call to 0x064e, returns to 0x034A label_034A: // Incoming return from call to 0x064E at 0x0349 // Inputs[2] // { // @034B stack[-2] // @034B stack[-1] // } 034A 5B JUMPDEST 034B 90 SWAP1 034C 50 POP 034D 61 PUSH2 0x035a 0350 56 *JUMP // Stack delta = -1 // Outputs[1] { @034B stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x035a label_0351: // Incoming jump from 0x0342, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0351 5B JUMPDEST 0352 61 PUSH2 0x0359 0355 61 PUSH2 0x01f9 0358 56 *JUMP // Stack delta = +1 // Outputs[1] { @0352 stack[0] = 0x0359 } // Block ends with unconditional jump to 0x01f9 0359 5B JUMPDEST label_035A: // Incoming jump from 0x0350 // Inputs[2] // { // @035B stack[-2] // @035B stack[-1] // } 035A 5B JUMPDEST 035B 90 SWAP1 035C 56 *JUMP // Stack delta = -1 // Outputs[1] { @035B stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_035D: // Incoming call from 0x019F, returns to 0x01A0 035D 5B JUMPDEST 035E 61 PUSH2 0x0365 0361 61 PUSH2 0x06a5 0364 56 *JUMP // Stack delta = +1 // Outputs[1] { @035E stack[0] = 0x0365 } // Block ends with call to 0x06a5, returns to 0x0365 label_0365: // Incoming return from call to 0x06A5 at 0x0364 // Inputs[2] // { // @037B stack[-1] // @037C msg.sender // } 0365 5B JUMPDEST 0366 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 037B 16 AND 037C 33 CALLER 037D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0392 16 AND 0393 14 EQ 0394 15 ISZERO 0395 61 PUSH2 0x050f 0398 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x050f, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0399: // Incoming jump from 0x0398, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @03B1 stack[-1] } 0399 60 PUSH1 0x00 039B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03B0 16 AND 03B1 81 DUP2 03B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03C7 16 AND 03C8 14 EQ 03C9 15 ISZERO 03CA 15 ISZERO 03CB 15 ISZERO 03CC 61 PUSH2 0x0463 03CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0463, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_03D0: // Incoming jump from 0x03CF, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @03D2 memory[0x40:0x60] // @045D memory[0x40:0x60] // @0462 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03D0 60 PUSH1 0x40 03D2 51 MLOAD 03D3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 03F4 81 DUP2 03F5 52 MSTORE 03F6 60 PUSH1 0x04 03F8 01 ADD 03F9 80 DUP1 03FA 80 DUP1 03FB 60 PUSH1 0x20 03FD 01 ADD 03FE 82 DUP3 03FF 81 DUP2 0400 03 SUB 0401 82 DUP3 0402 52 MSTORE 0403 60 PUSH1 0x36 0405 81 DUP2 0406 52 MSTORE 0407 60 PUSH1 0x20 0409 01 ADD 040A 80 DUP1 040B 7F PUSH32 0x43616e6e6f74206368616e6765207468652061646d696e206f6620612070726f 042C 81 DUP2 042D 52 MSTORE 042E 60 PUSH1 0x20 0430 01 ADD 0431 7F PUSH32 0x787920746f20746865207a65726f206164647265737300000000000000000000 0452 81 DUP2 0453 52 MSTORE 0454 50 POP 0455 60 PUSH1 0x40 0457 01 ADD 0458 91 SWAP2 0459 50 POP 045A 50 POP 045B 60 PUSH1 0x40 045D 51 MLOAD 045E 80 DUP1 045F 91 SWAP2 0460 03 SUB 0461 90 SWAP1 0462 FD *REVERT // Stack delta = +0 // Outputs[6] // { // @03F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0402 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0406 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x36 // @042D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x43616e6e6f74206368616e6765207468652061646d696e206f6620612070726f // @0453 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x787920746f20746865207a65726f206164647265737300000000000000000000 // @0462 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0463: // Incoming jump from 0x03CF, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) 0463 5B JUMPDEST 0464 7F PUSH32 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f 0485 61 PUSH2 0x048c 0488 61 PUSH2 0x06a5 048B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0464 stack[0] = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f // @0485 stack[1] = 0x048c // } // Block ends with call to 0x06a5, returns to 0x048C label_048C: // Incoming return from call to 0x06A5 at 0x048B // Inputs[6] // { // @048D stack[-3] // @0490 memory[0x40:0x60] // @0492 stack[-1] // @04FC memory[0x40:0x60] // @0501 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0501 stack[-2] // } 048C 5B JUMPDEST 048D 82 DUP3 048E 60 PUSH1 0x40 0490 51 MLOAD 0491 80 DUP1 0492 83 DUP4 0493 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04A8 16 AND 04A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04BE 16 AND 04BF 81 DUP2 04C0 52 MSTORE 04C1 60 PUSH1 0x20 04C3 01 ADD 04C4 82 DUP3 04C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04DA 16 AND 04DB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04F0 16 AND 04F1 81 DUP2 04F2 52 MSTORE 04F3 60 PUSH1 0x20 04F5 01 ADD 04F6 92 SWAP3 04F7 50 POP 04F8 50 POP 04F9 50 POP 04FA 60 PUSH1 0x40 04FC 51 MLOAD 04FD 80 DUP1 04FE 91 SWAP2 04FF 03 SUB 0500 90 SWAP1 0501 A1 LOG1 0502 61 PUSH2 0x050a 0505 81 DUP2 0506 61 PUSH2 0x0725 0509 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @04C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @04F2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0501 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // @0502 stack[-2] = 0x050a // @0505 stack[-1] = stack[-3] // } // Block ends with call to 0x0725, returns to 0x050A label_050A: // Incoming return from call to 0x0725 at 0x0509 050A 5B JUMPDEST 050B 61 PUSH2 0x0518 050E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0518 label_050F: // Incoming jump from 0x0398, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 050F 5B JUMPDEST 0510 61 PUSH2 0x0517 0513 61 PUSH2 0x01f9 0516 56 *JUMP // Stack delta = +1 // Outputs[1] { @0510 stack[0] = 0x0517 } // Block ends with unconditional jump to 0x01f9 0517 5B JUMPDEST label_0518: // Incoming jump from 0x050E // Inputs[1] { @051A stack[-2] } 0518 5B JUMPDEST 0519 50 POP 051A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_051B: // Incoming call from 0x01B6, returns to 0x01B7 051B 5B JUMPDEST 051C 60 PUSH1 0x00 051E 61 PUSH2 0x0525 0521 61 PUSH2 0x06a5 0524 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @051C stack[0] = 0x00 // @051E stack[1] = 0x0525 // } // Block ends with call to 0x06a5, returns to 0x0525 label_0525: // Incoming return from call to 0x06A5 at 0x0524 // Inputs[2] // { // @053B stack[-1] // @053C msg.sender // } 0525 5B JUMPDEST 0526 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 053B 16 AND 053C 33 CALLER 053D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0552 16 AND 0553 14 EQ 0554 15 ISZERO 0555 61 PUSH2 0x0567 0558 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0567, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0559: // Incoming jump from 0x0558, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0559 61 PUSH2 0x0560 055C 61 PUSH2 0x06a5 055F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0559 stack[0] = 0x0560 } // Block ends with call to 0x06a5, returns to 0x0560 label_0560: // Incoming return from call to 0x06A5 at 0x055F // Inputs[2] // { // @0561 stack[-2] // @0561 stack[-1] // } 0560 5B JUMPDEST 0561 90 SWAP1 0562 50 POP 0563 61 PUSH2 0x0570 0566 56 *JUMP // Stack delta = -1 // Outputs[1] { @0561 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0570 label_0567: // Incoming jump from 0x0558, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0567 5B JUMPDEST 0568 61 PUSH2 0x056f 056B 61 PUSH2 0x01f9 056E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0568 stack[0] = 0x056f } // Block ends with unconditional jump to 0x01f9 056F 5B JUMPDEST label_0570: // Incoming jump from 0x0566 // Inputs[2] // { // @0571 stack[-2] // @0571 stack[-1] // } 0570 5B JUMPDEST 0571 90 SWAP1 0572 56 *JUMP // Stack delta = -1 // Outputs[1] { @0571 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0573: // Incoming call from 0x0200, returns to 0x0201 0573 5B JUMPDEST 0574 61 PUSH2 0x057b 0577 61 PUSH2 0x06a5 057A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0574 stack[0] = 0x057b } // Block ends with call to 0x06a5, returns to 0x057B label_057B: // Incoming return from call to 0x06A5 at 0x057A // Inputs[2] // { // @0591 stack[-1] // @0592 msg.sender // } 057B 5B JUMPDEST 057C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0591 16 AND 0592 33 CALLER 0593 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05A8 16 AND 05A9 14 EQ 05AA 15 ISZERO 05AB 15 ISZERO 05AC 15 ISZERO 05AD 61 PUSH2 0x0644 05B0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0644, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_05B1: // Incoming jump from 0x05B0, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @05B3 memory[0x40:0x60] // @063E memory[0x40:0x60] // @0643 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05B1 60 PUSH1 0x40 05B3 51 MLOAD 05B4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 05D5 81 DUP2 05D6 52 MSTORE 05D7 60 PUSH1 0x04 05D9 01 ADD 05DA 80 DUP1 05DB 80 DUP1 05DC 60 PUSH1 0x20 05DE 01 ADD 05DF 82 DUP3 05E0 81 DUP2 05E1 03 SUB 05E2 82 DUP3 05E3 52 MSTORE 05E4 60 PUSH1 0x32 05E6 81 DUP2 05E7 52 MSTORE 05E8 60 PUSH1 0x20 05EA 01 ADD 05EB 80 DUP1 05EC 7F PUSH32 0x43616e6e6f742063616c6c2066616c6c6261636b2066756e6374696f6e206672 060D 81 DUP2 060E 52 MSTORE 060F 60 PUSH1 0x20 0611 01 ADD 0612 7F PUSH32 0x6f6d207468652070726f78792061646d696e0000000000000000000000000000 0633 81 DUP2 0634 52 MSTORE 0635 50 POP 0636 60 PUSH1 0x40 0638 01 ADD 0639 91 SWAP2 063A 50 POP 063B 50 POP 063C 60 PUSH1 0x40 063E 51 MLOAD 063F 80 DUP1 0640 91 SWAP2 0641 03 SUB 0642 90 SWAP1 0643 FD *REVERT // Stack delta = +0 // Outputs[6] // { // @05D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @05E3 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @05E7 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x32 // @060E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x43616e6e6f742063616c6c2066616c6c6261636b2066756e6374696f6e206672 // @0634 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x6f6d207468652070726f78792061646d696e0000000000000000000000000000 // @0643 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0644: // Incoming jump from 0x05B0, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0644 5B JUMPDEST 0645 61 PUSH2 0x064c 0648 61 PUSH2 0x0754 064B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0645 stack[0] = 0x064c } // Block ends with call to 0x0754, returns to 0x064C label_064C: // Incoming return from call to 0x0754 at 0x064B // Inputs[1] { @064D stack[-1] } 064C 5B JUMPDEST 064D 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_064E: // Incoming call from 0x0349, returns to 0x034A // Incoming call from 0x020B, returns to 0x020C // Inputs[2] // { // @0679 storage[0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3] // @067D stack[-1] // } 064E 5B JUMPDEST 064F 60 PUSH1 0x00 0651 80 DUP1 0652 7F PUSH32 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3 0673 60 PUSH1 0x01 0675 02 MUL 0676 90 SWAP1 0677 50 POP 0678 80 DUP1 0679 54 SLOAD 067A 91 SWAP2 067B 50 POP 067C 50 POP 067D 90 SWAP1 067E 56 *JUMP // Stack delta = +0 // Outputs[1] { @067D stack[-1] = storage[0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3] } // Block ends with unconditional jump to stack[-1] label_067F: // Incoming jump from 0x0210 // Inputs[9] // { // @0680 msg.data.length // @0684 msg.data[0x00:0x00 + msg.data.length] // @0688 msg.data.length // @068B stack[-1] // @068C msg.gas // @068D address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @068D memory[0x00:0x00 + msg.data.length] // @068E returndata.length // @0692 returndata[0x00:0x00 + returndata.length] // } 067F 5B JUMPDEST 0680 36 CALLDATASIZE 0681 60 PUSH1 0x00 0683 80 DUP1 0684 37 CALLDATACOPY 0685 60 PUSH1 0x00 0687 80 DUP1 0688 36 CALLDATASIZE 0689 60 PUSH1 0x00 068B 84 DUP5 068C 5A GAS 068D F4 DELEGATECALL 068E 3D RETURNDATASIZE 068F 60 PUSH1 0x00 0691 80 DUP1 0692 3E RETURNDATACOPY 0693 80 DUP1 0694 60 PUSH1 0x00 0696 81 DUP2 0697 14 EQ 0698 61 PUSH2 0x06a0 069B 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0684 memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @068D memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @068D stack[0] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0692 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0693 stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // } // Block ends with conditional jump to 0x06a0, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 label_069C: // Incoming jump from 0x069B, if not address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 // Inputs[2] // { // @069C returndata.length // @069F memory[0x00:0x00 + returndata.length] // } 069C 3D RETURNDATASIZE 069D 60 PUSH1 0x00 069F F3 *RETURN // Stack delta = +0 // Outputs[1] { @069F return memory[0x00:0x00 + returndata.length]; } // Block terminates label_06A0: // Incoming jump from 0x069B, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 // Inputs[2] // { // @06A1 returndata.length // @06A4 memory[0x00:0x00 + returndata.length] // } 06A0 5B JUMPDEST 06A1 3D RETURNDATASIZE 06A2 60 PUSH1 0x00 06A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A4 revert(memory[0x00:0x00 + returndata.length]); } // Block terminates label_06A5: // Incoming call from 0x057A, returns to 0x057B // Incoming call from 0x0364, returns to 0x0365 // Incoming call from 0x048B, returns to 0x048C // Incoming call from 0x030E, returns to 0x030F // Incoming call from 0x026F, returns to 0x0270 // Incoming call from 0x021A, returns to 0x021B // Incoming call from 0x0524, returns to 0x0525 // Incoming call from 0x055F, returns to 0x0560 // Inputs[2] // { // @06D0 storage[0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b] // @06D4 stack[-1] // } 06A5 5B JUMPDEST 06A6 60 PUSH1 0x00 06A8 80 DUP1 06A9 7F PUSH32 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b 06CA 60 PUSH1 0x01 06CC 02 MUL 06CD 90 SWAP1 06CE 50 POP 06CF 80 DUP1 06D0 54 SLOAD 06D1 91 SWAP2 06D2 50 POP 06D3 50 POP 06D4 90 SWAP1 06D5 56 *JUMP // Stack delta = +0 // Outputs[1] { @06D4 stack[-1] = storage[0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b] } // Block ends with unconditional jump to stack[-1] label_06D6: // Incoming call from 0x0256, returns to 0x0257 // Incoming call from 0x02AB, returns to 0x02AC // Inputs[1] { @06DA stack[-1] } 06D6 5B JUMPDEST 06D7 61 PUSH2 0x06df 06DA 81 DUP2 06DB 61 PUSH2 0x0756 06DE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06D7 stack[0] = 0x06df // @06DA stack[1] = stack[-1] // } // Block ends with call to 0x0756, returns to 0x06DF label_06DF: // Incoming return from call to 0x0756 at 0x06DE // Inputs[5] // { // @06E0 stack[-1] // @071A memory[0x40:0x60] // @071D memory[0x40:0x60] // @0722 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0724 stack[-2] // } 06DF 5B JUMPDEST 06E0 80 DUP1 06E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06F6 16 AND 06F7 7F PUSH32 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b 0718 60 PUSH1 0x40 071A 51 MLOAD 071B 60 PUSH1 0x40 071D 51 MLOAD 071E 80 DUP1 071F 91 SWAP2 0720 03 SUB 0721 90 SWAP1 0722 A2 LOG2 0723 50 POP 0724 56 *JUMP // Stack delta = -2 // Outputs[1] { @0722 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); } // Block ends with unconditional jump to stack[-2] label_0725: // Incoming call from 0x0509, returns to 0x050A // Inputs[2] // { // @074E stack[-1] // @0753 stack[-2] // } 0725 5B JUMPDEST 0726 60 PUSH1 0x00 0728 7F PUSH32 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b 0749 60 PUSH1 0x01 074B 02 MUL 074C 90 SWAP1 074D 50 POP 074E 81 DUP2 074F 81 DUP2 0750 55 SSTORE 0751 50 POP 0752 50 POP 0753 56 *JUMP // Stack delta = -2 // Outputs[1] { @0750 storage[0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0754: // Incoming call from 0x064B, returns to 0x064C // Inputs[1] { @0755 stack[-1] } 0754 5B JUMPDEST 0755 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0756: // Incoming call from 0x06DE, returns to 0x06DF // Inputs[1] { @075C stack[-1] } 0756 5B JUMPDEST 0757 60 PUSH1 0x00 0759 61 PUSH2 0x0761 075C 82 DUP3 075D 61 PUSH2 0x0828 0760 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0757 stack[0] = 0x00 // @0759 stack[1] = 0x0761 // @075C stack[2] = stack[-1] // } // Block ends with call to 0x0828, returns to 0x0761 label_0761: // Incoming return from call to 0x0828 at 0x0760 // Inputs[1] { @0762 stack[-1] } 0761 5B JUMPDEST 0762 15 ISZERO 0763 15 ISZERO 0764 61 PUSH2 0x07fb 0767 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07fb, if !!stack[-1] label_0768: // Incoming jump from 0x0767, if not !!stack[-1] // Inputs[3] // { // @076A memory[0x40:0x60] // @07F5 memory[0x40:0x60] // @07FA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0768 60 PUSH1 0x40 076A 51 MLOAD 076B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 078C 81 DUP2 078D 52 MSTORE 078E 60 PUSH1 0x04 0790 01 ADD 0791 80 DUP1 0792 80 DUP1 0793 60 PUSH1 0x20 0795 01 ADD 0796 82 DUP3 0797 81 DUP2 0798 03 SUB 0799 82 DUP3 079A 52 MSTORE 079B 60 PUSH1 0x3b 079D 81 DUP2 079E 52 MSTORE 079F 60 PUSH1 0x20 07A1 01 ADD 07A2 80 DUP1 07A3 7F PUSH32 0x43616e6e6f742073657420612070726f787920696d706c656d656e746174696f 07C4 81 DUP2 07C5 52 MSTORE 07C6 60 PUSH1 0x20 07C8 01 ADD 07C9 7F PUSH32 0x6e20746f2061206e6f6e2d636f6e747261637420616464726573730000000000 07EA 81 DUP2 07EB 52 MSTORE 07EC 50 POP 07ED 60 PUSH1 0x40 07EF 01 ADD 07F0 91 SWAP2 07F1 50 POP 07F2 50 POP 07F3 60 PUSH1 0x40 07F5 51 MLOAD 07F6 80 DUP1 07F7 91 SWAP2 07F8 03 SUB 07F9 90 SWAP1 07FA FD *REVERT // Stack delta = +0 // Outputs[6] // { // @078D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @079A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @079E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x3b // @07C5 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x43616e6e6f742073657420612070726f787920696d706c656d656e746174696f // @07EB memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x6e20746f2061206e6f6e2d636f6e747261637420616464726573730000000000 // @07FA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_07FB: // Incoming jump from 0x0767, if !!stack[-1] // Inputs[3] // { // @0820 stack[-1] // @0822 stack[-2] // @0827 stack[-3] // } 07FB 5B JUMPDEST 07FC 7F PUSH32 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3 081D 60 PUSH1 0x01 081F 02 MUL 0820 90 SWAP1 0821 50 POP 0822 81 DUP2 0823 81 DUP2 0824 55 SSTORE 0825 50 POP 0826 50 POP 0827 56 *JUMP // Stack delta = -3 // Outputs[1] { @0824 storage[0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0828: // Incoming call from 0x0760, returns to 0x0761 // Inputs[3] // { // @082C stack[-1] // @082D address(stack[-1]).code.length // @0837 stack[-2] // } 0828 5B JUMPDEST 0829 60 PUSH1 0x00 082B 80 DUP1 082C 82 DUP3 082D 3B EXTCODESIZE 082E 90 SWAP1 082F 50 POP 0830 60 PUSH1 0x00 0832 81 DUP2 0833 11 GT 0834 91 SWAP2 0835 50 POP 0836 50 POP 0837 91 SWAP2 0838 90 SWAP1 0839 50 POP 083A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0837 stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] 083B 00 *STOP 083C A1 LOG1 083D 65 PUSH6 0x627a7a723058 0844 20 SHA3 0845 82 DUP3 0846 55 SSTORE 0847 4E 4E 0848 AF AF 0849 53 MSTORE8 084A 6C PUSH13 0x0d193937f132068d40a645790b 0858 E3 E3 0859 87 DUP8 085A CB CB 085B CA CA 085C BF BF 085D C1 C1 085E A4 LOG4 085F 88 DUP9 0860 7A PUSH27 0x92cca2e70029