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 0x0308 011C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0116 stack[-1] = 0x011d } // Block ends with call to 0x0308, returns to 0x011D label_011D: // Incoming return from call to 0x0308 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 0x0360 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 0x0360, returns to 0x01A0 label_01A0: // Incoming return from call to 0x0360 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 0x051e 01B6 56 *JUMP // Stack delta = +0 // Outputs[1] { @01B0 stack[-1] = 0x01b7 } // Block ends with call to 0x051e, returns to 0x01B7 label_01B7: // Incoming return from call to 0x051E 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 0x0301 // Incoming jump from 0x0263 // Incoming jump from 0x0519 // Incoming jump from 0x0571 // Incoming jump from 0x035B 01F9 5B JUMPDEST 01FA 61 PUSH2 0x0201 01FD 61 PUSH2 0x0576 0200 56 *JUMP // Stack delta = +1 // Outputs[1] { @01FA stack[0] = 0x0201 } // Block ends with call to 0x0576, returns to 0x0201 label_0201: // Incoming return from call to 0x0576 at 0x0200 0201 5B JUMPDEST 0202 61 PUSH2 0x0211 0205 61 PUSH2 0x020c 0208 61 PUSH2 0x0651 020B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0202 stack[0] = 0x0211 // @0205 stack[1] = 0x020c // } // Block ends with call to 0x0651, returns to 0x020C label_020C: // Incoming return from call to 0x0651 at 0x020B 020C 5B JUMPDEST 020D 61 PUSH2 0x0682 0210 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0682 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 0x06a8 021A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0214 stack[0] = 0x021b } // Block ends with call to 0x06a8, returns to 0x021B label_021B: // Incoming return from call to 0x06A8 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 0x06d9 0256 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @024F stack[0] = 0x0257 // @0252 stack[1] = stack[-1] // } // Block ends with call to 0x06d9, returns to 0x0257 label_0257: // Incoming return from call to 0x06D9 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 0x06a8 026F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0269 stack[0] = 0x0270 } // Block ends with call to 0x06a8, returns to 0x0270 label_0270: // Incoming return from call to 0x06A8 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 0x02fa 02A3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x02fa, 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 0x06d9 02AB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02A4 stack[0] = 0x02ac // @02A7 stack[1] = stack[-3] // } // Block ends with call to 0x06d9, returns to 0x02AC label_02AC: // Incoming return from call to 0x06D9 at 0x02AB // Inputs[10] // { // @02AD address(this) // @02C4 msg.value // @02C5 stack[-2] // @02C6 stack[-1] // @02C9 memory[0x40:0x60] // @02D0 msg.data[stack[-2]:stack[-2] + stack[-1]] // @02DE memory[0x40:0x60] // @02E5 msg.gas // @02E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]] // @02E6 address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).call.gas(msg.gas).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // } 02AC 5B JUMPDEST 02AD 30 ADDRESS 02AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02C3 16 AND 02C4 34 CALLVALUE 02C5 83 DUP4 02C6 83 DUP4 02C7 60 PUSH1 0x40 02C9 51 MLOAD 02CA 80 DUP1 02CB 83 DUP4 02CC 83 DUP4 02CD 80 DUP1 02CE 82 DUP3 02CF 84 DUP5 02D0 37 CALLDATACOPY 02D1 82 DUP3 02D2 01 ADD 02D3 91 SWAP2 02D4 50 POP 02D5 50 POP 02D6 92 SWAP3 02D7 50 POP 02D8 50 POP 02D9 50 POP 02DA 60 PUSH1 0x00 02DC 60 PUSH1 0x40 02DE 51 MLOAD 02DF 80 DUP1 02E0 83 DUP4 02E1 03 SUB 02E2 81 DUP2 02E3 85 DUP6 02E4 87 DUP8 02E5 5A GAS 02E6 F1 CALL 02E7 92 SWAP3 02E8 50 POP 02E9 50 POP 02EA 50 POP 02EB 15 ISZERO 02EC 15 ISZERO 02ED 61 PUSH2 0x02f5 02F0 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @02D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @02E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).call.gas(msg.gas).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x02f5, if !!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).call.gas(msg.gas).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) label_02F1: // Incoming jump from 0x02F0, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).call.gas(msg.gas).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // Inputs[1] { @02F4 memory[0x00:0x00] } 02F1 60 PUSH1 0x00 02F3 80 DUP1 02F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F4 revert(memory[0x00:0x00]); } // Block terminates label_02F5: // Incoming jump from 0x02F0, if !!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).call.gas(msg.gas).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) 02F5 5B JUMPDEST 02F6 61 PUSH2 0x0303 02F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0303 label_02FA: // Incoming jump from 0x02A3, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 02FA 5B JUMPDEST 02FB 61 PUSH2 0x0302 02FE 61 PUSH2 0x01f9 0301 56 *JUMP // Stack delta = +1 // Outputs[1] { @02FB stack[0] = 0x0302 } // Block ends with unconditional jump to 0x01f9 0302 5B JUMPDEST label_0303: // Incoming jump from 0x02F9 // Inputs[1] { @0307 stack[-4] } 0303 5B JUMPDEST 0304 50 POP 0305 50 POP 0306 50 POP 0307 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0308: // Incoming call from 0x011C, returns to 0x011D 0308 5B JUMPDEST 0309 60 PUSH1 0x00 030B 61 PUSH2 0x0312 030E 61 PUSH2 0x06a8 0311 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0309 stack[0] = 0x00 // @030B stack[1] = 0x0312 // } // Block ends with call to 0x06a8, returns to 0x0312 label_0312: // Incoming return from call to 0x06A8 at 0x0311 // Inputs[2] // { // @0328 stack[-1] // @0329 msg.sender // } 0312 5B JUMPDEST 0313 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0328 16 AND 0329 33 CALLER 032A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 033F 16 AND 0340 14 EQ 0341 15 ISZERO 0342 61 PUSH2 0x0354 0345 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0354, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0346: // Incoming jump from 0x0345, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0346 61 PUSH2 0x034d 0349 61 PUSH2 0x0651 034C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0346 stack[0] = 0x034d } // Block ends with call to 0x0651, returns to 0x034D label_034D: // Incoming return from call to 0x0651 at 0x034C // Inputs[2] // { // @034E stack[-1] // @034E stack[-2] // } 034D 5B JUMPDEST 034E 90 SWAP1 034F 50 POP 0350 61 PUSH2 0x035d 0353 56 *JUMP // Stack delta = -1 // Outputs[1] { @034E stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x035d label_0354: // Incoming jump from 0x0345, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0354 5B JUMPDEST 0355 61 PUSH2 0x035c 0358 61 PUSH2 0x01f9 035B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0355 stack[0] = 0x035c } // Block ends with unconditional jump to 0x01f9 035C 5B JUMPDEST label_035D: // Incoming jump from 0x0353 // Inputs[2] // { // @035E stack[-1] // @035E stack[-2] // } 035D 5B JUMPDEST 035E 90 SWAP1 035F 56 *JUMP // Stack delta = -1 // Outputs[1] { @035E stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0360: // Incoming call from 0x019F, returns to 0x01A0 0360 5B JUMPDEST 0361 61 PUSH2 0x0368 0364 61 PUSH2 0x06a8 0367 56 *JUMP // Stack delta = +1 // Outputs[1] { @0361 stack[0] = 0x0368 } // Block ends with call to 0x06a8, returns to 0x0368 label_0368: // Incoming return from call to 0x06A8 at 0x0367 // Inputs[2] // { // @037E stack[-1] // @037F msg.sender // } 0368 5B JUMPDEST 0369 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 037E 16 AND 037F 33 CALLER 0380 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0395 16 AND 0396 14 EQ 0397 15 ISZERO 0398 61 PUSH2 0x0512 039B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0512, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_039C: // Incoming jump from 0x039B, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @03B4 stack[-1] } 039C 60 PUSH1 0x00 039E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03B3 16 AND 03B4 81 DUP2 03B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03CA 16 AND 03CB 14 EQ 03CC 15 ISZERO 03CD 15 ISZERO 03CE 15 ISZERO 03CF 61 PUSH2 0x0466 03D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0466, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_03D3: // Incoming jump from 0x03D2, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @03D5 memory[0x40:0x60] // @0460 memory[0x40:0x60] // @0465 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03D3 60 PUSH1 0x40 03D5 51 MLOAD 03D6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 03F7 81 DUP2 03F8 52 MSTORE 03F9 60 PUSH1 0x04 03FB 01 ADD 03FC 80 DUP1 03FD 80 DUP1 03FE 60 PUSH1 0x20 0400 01 ADD 0401 82 DUP3 0402 81 DUP2 0403 03 SUB 0404 82 DUP3 0405 52 MSTORE 0406 60 PUSH1 0x36 0408 81 DUP2 0409 52 MSTORE 040A 60 PUSH1 0x20 040C 01 ADD 040D 80 DUP1 040E 7F PUSH32 0x43616e6e6f74206368616e6765207468652061646d696e206f6620612070726f 042F 81 DUP2 0430 52 MSTORE 0431 60 PUSH1 0x20 0433 01 ADD 0434 7F PUSH32 0x787920746f20746865207a65726f206164647265737300000000000000000000 0455 81 DUP2 0456 52 MSTORE 0457 50 POP 0458 60 PUSH1 0x40 045A 01 ADD 045B 91 SWAP2 045C 50 POP 045D 50 POP 045E 60 PUSH1 0x40 0460 51 MLOAD 0461 80 DUP1 0462 91 SWAP2 0463 03 SUB 0464 90 SWAP1 0465 FD *REVERT // Stack delta = +0 // Outputs[6] // { // @03F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0405 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0409 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x36 // @0430 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x43616e6e6f74206368616e6765207468652061646d696e206f6620612070726f // @0456 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x787920746f20746865207a65726f206164647265737300000000000000000000 // @0465 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0466: // Incoming jump from 0x03D2, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) 0466 5B JUMPDEST 0467 7F PUSH32 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f 0488 61 PUSH2 0x048f 048B 61 PUSH2 0x06a8 048E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0467 stack[0] = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f // @0488 stack[1] = 0x048f // } // Block ends with call to 0x06a8, returns to 0x048F label_048F: // Incoming return from call to 0x06A8 at 0x048E // Inputs[6] // { // @0490 stack[-3] // @0493 memory[0x40:0x60] // @0495 stack[-1] // @04FF memory[0x40:0x60] // @0504 stack[-2] // @0504 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 048F 5B JUMPDEST 0490 82 DUP3 0491 60 PUSH1 0x40 0493 51 MLOAD 0494 80 DUP1 0495 83 DUP4 0496 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04AB 16 AND 04AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04C1 16 AND 04C2 81 DUP2 04C3 52 MSTORE 04C4 60 PUSH1 0x20 04C6 01 ADD 04C7 82 DUP3 04C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04DD 16 AND 04DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04F3 16 AND 04F4 81 DUP2 04F5 52 MSTORE 04F6 60 PUSH1 0x20 04F8 01 ADD 04F9 92 SWAP3 04FA 50 POP 04FB 50 POP 04FC 50 POP 04FD 60 PUSH1 0x40 04FF 51 MLOAD 0500 80 DUP1 0501 91 SWAP2 0502 03 SUB 0503 90 SWAP1 0504 A1 LOG1 0505 61 PUSH2 0x050d 0508 81 DUP2 0509 61 PUSH2 0x0748 050C 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @04C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @04F5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0504 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // @0505 stack[-2] = 0x050d // @0508 stack[-1] = stack[-3] // } // Block ends with call to 0x0748, returns to 0x050D label_050D: // Incoming return from call to 0x0748 at 0x050C 050D 5B JUMPDEST 050E 61 PUSH2 0x051b 0511 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x051b label_0512: // Incoming jump from 0x039B, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0512 5B JUMPDEST 0513 61 PUSH2 0x051a 0516 61 PUSH2 0x01f9 0519 56 *JUMP // Stack delta = +1 // Outputs[1] { @0513 stack[0] = 0x051a } // Block ends with unconditional jump to 0x01f9 051A 5B JUMPDEST label_051B: // Incoming jump from 0x0511 // Inputs[1] { @051D stack[-2] } 051B 5B JUMPDEST 051C 50 POP 051D 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_051E: // Incoming call from 0x01B6, returns to 0x01B7 051E 5B JUMPDEST 051F 60 PUSH1 0x00 0521 61 PUSH2 0x0528 0524 61 PUSH2 0x06a8 0527 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @051F stack[0] = 0x00 // @0521 stack[1] = 0x0528 // } // Block ends with call to 0x06a8, returns to 0x0528 label_0528: // Incoming return from call to 0x06A8 at 0x0527 // Inputs[2] // { // @053E stack[-1] // @053F msg.sender // } 0528 5B JUMPDEST 0529 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 053E 16 AND 053F 33 CALLER 0540 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0555 16 AND 0556 14 EQ 0557 15 ISZERO 0558 61 PUSH2 0x056a 055B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x056a, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_055C: // Incoming jump from 0x055B, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 055C 61 PUSH2 0x0563 055F 61 PUSH2 0x06a8 0562 56 *JUMP // Stack delta = +1 // Outputs[1] { @055C stack[0] = 0x0563 } // Block ends with call to 0x06a8, returns to 0x0563 label_0563: // Incoming return from call to 0x06A8 at 0x0562 // Inputs[2] // { // @0564 stack[-1] // @0564 stack[-2] // } 0563 5B JUMPDEST 0564 90 SWAP1 0565 50 POP 0566 61 PUSH2 0x0573 0569 56 *JUMP // Stack delta = -1 // Outputs[1] { @0564 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0573 label_056A: // Incoming jump from 0x055B, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 056A 5B JUMPDEST 056B 61 PUSH2 0x0572 056E 61 PUSH2 0x01f9 0571 56 *JUMP // Stack delta = +1 // Outputs[1] { @056B stack[0] = 0x0572 } // Block ends with unconditional jump to 0x01f9 0572 5B JUMPDEST label_0573: // Incoming jump from 0x0569 // Inputs[2] // { // @0574 stack[-1] // @0574 stack[-2] // } 0573 5B JUMPDEST 0574 90 SWAP1 0575 56 *JUMP // Stack delta = -1 // Outputs[1] { @0574 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0576: // Incoming call from 0x0200, returns to 0x0201 0576 5B JUMPDEST 0577 61 PUSH2 0x057e 057A 61 PUSH2 0x06a8 057D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0577 stack[0] = 0x057e } // Block ends with call to 0x06a8, returns to 0x057E label_057E: // Incoming return from call to 0x06A8 at 0x057D // Inputs[2] // { // @0594 stack[-1] // @0595 msg.sender // } 057E 5B JUMPDEST 057F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0594 16 AND 0595 33 CALLER 0596 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05AB 16 AND 05AC 14 EQ 05AD 15 ISZERO 05AE 15 ISZERO 05AF 15 ISZERO 05B0 61 PUSH2 0x0647 05B3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0647, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_05B4: // Incoming jump from 0x05B3, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @05B6 memory[0x40:0x60] // @0641 memory[0x40:0x60] // @0646 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05B4 60 PUSH1 0x40 05B6 51 MLOAD 05B7 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 05D8 81 DUP2 05D9 52 MSTORE 05DA 60 PUSH1 0x04 05DC 01 ADD 05DD 80 DUP1 05DE 80 DUP1 05DF 60 PUSH1 0x20 05E1 01 ADD 05E2 82 DUP3 05E3 81 DUP2 05E4 03 SUB 05E5 82 DUP3 05E6 52 MSTORE 05E7 60 PUSH1 0x32 05E9 81 DUP2 05EA 52 MSTORE 05EB 60 PUSH1 0x20 05ED 01 ADD 05EE 80 DUP1 05EF 7F PUSH32 0x43616e6e6f742063616c6c2066616c6c6261636b2066756e6374696f6e206672 0610 81 DUP2 0611 52 MSTORE 0612 60 PUSH1 0x20 0614 01 ADD 0615 7F PUSH32 0x6f6d207468652070726f78792061646d696e0000000000000000000000000000 0636 81 DUP2 0637 52 MSTORE 0638 50 POP 0639 60 PUSH1 0x40 063B 01 ADD 063C 91 SWAP2 063D 50 POP 063E 50 POP 063F 60 PUSH1 0x40 0641 51 MLOAD 0642 80 DUP1 0643 91 SWAP2 0644 03 SUB 0645 90 SWAP1 0646 FD *REVERT // Stack delta = +0 // Outputs[6] // { // @05D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @05E6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @05EA memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x32 // @0611 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x43616e6e6f742063616c6c2066616c6c6261636b2066756e6374696f6e206672 // @0637 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x6f6d207468652070726f78792061646d696e0000000000000000000000000000 // @0646 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0647: // Incoming jump from 0x05B3, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0647 5B JUMPDEST 0648 61 PUSH2 0x064f 064B 61 PUSH2 0x0777 064E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0648 stack[0] = 0x064f } // Block ends with call to 0x0777, returns to 0x064F label_064F: // Incoming return from call to 0x0777 at 0x064E // Inputs[1] { @0650 stack[-1] } 064F 5B JUMPDEST 0650 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0651: // Incoming call from 0x034C, returns to 0x034D // Incoming call from 0x020B, returns to 0x020C // Inputs[2] // { // @067C storage[0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3] // @0680 stack[-1] // } 0651 5B JUMPDEST 0652 60 PUSH1 0x00 0654 80 DUP1 0655 7F PUSH32 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3 0676 60 PUSH1 0x01 0678 02 MUL 0679 90 SWAP1 067A 50 POP 067B 80 DUP1 067C 54 SLOAD 067D 91 SWAP2 067E 50 POP 067F 50 POP 0680 90 SWAP1 0681 56 *JUMP // Stack delta = +0 // Outputs[1] { @0680 stack[-1] = storage[0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3] } // Block ends with unconditional jump to stack[-1] label_0682: // Incoming jump from 0x0210 // Inputs[9] // { // @0683 msg.data.length // @0687 msg.data[0x00:0x00 + msg.data.length] // @068B msg.data.length // @068E stack[-1] // @068F msg.gas // @0690 address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0690 memory[0x00:0x00 + msg.data.length] // @0691 returndata.length // @0695 returndata[0x00:0x00 + returndata.length] // } 0682 5B JUMPDEST 0683 36 CALLDATASIZE 0684 60 PUSH1 0x00 0686 80 DUP1 0687 37 CALLDATACOPY 0688 60 PUSH1 0x00 068A 80 DUP1 068B 36 CALLDATASIZE 068C 60 PUSH1 0x00 068E 84 DUP5 068F 5A GAS 0690 F4 DELEGATECALL 0691 3D RETURNDATASIZE 0692 60 PUSH1 0x00 0694 80 DUP1 0695 3E RETURNDATACOPY 0696 80 DUP1 0697 60 PUSH1 0x00 0699 81 DUP2 069A 14 EQ 069B 61 PUSH2 0x06a3 069E 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0687 memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0690 memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0690 stack[0] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0695 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0696 stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // } // Block ends with conditional jump to 0x06a3, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 label_069F: // Incoming jump from 0x069E, if not address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 // Inputs[2] // { // @069F returndata.length // @06A2 memory[0x00:0x00 + returndata.length] // } 069F 3D RETURNDATASIZE 06A0 60 PUSH1 0x00 06A2 F3 *RETURN // Stack delta = +0 // Outputs[1] { @06A2 return memory[0x00:0x00 + returndata.length]; } // Block terminates label_06A3: // Incoming jump from 0x069E, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 // Inputs[2] // { // @06A4 returndata.length // @06A7 memory[0x00:0x00 + returndata.length] // } 06A3 5B JUMPDEST 06A4 3D RETURNDATASIZE 06A5 60 PUSH1 0x00 06A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A7 revert(memory[0x00:0x00 + returndata.length]); } // Block terminates label_06A8: // Incoming call from 0x026F, returns to 0x0270 // Incoming call from 0x057D, returns to 0x057E // Incoming call from 0x0562, returns to 0x0563 // Incoming call from 0x048E, returns to 0x048F // Incoming call from 0x021A, returns to 0x021B // Incoming call from 0x0311, returns to 0x0312 // Incoming call from 0x0367, returns to 0x0368 // Incoming call from 0x0527, returns to 0x0528 // Inputs[2] // { // @06D3 storage[0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b] // @06D7 stack[-1] // } 06A8 5B JUMPDEST 06A9 60 PUSH1 0x00 06AB 80 DUP1 06AC 7F PUSH32 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b 06CD 60 PUSH1 0x01 06CF 02 MUL 06D0 90 SWAP1 06D1 50 POP 06D2 80 DUP1 06D3 54 SLOAD 06D4 91 SWAP2 06D5 50 POP 06D6 50 POP 06D7 90 SWAP1 06D8 56 *JUMP // Stack delta = +0 // Outputs[1] { @06D7 stack[-1] = storage[0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b] } // Block ends with unconditional jump to stack[-1] label_06D9: // Incoming call from 0x02AB, returns to 0x02AC // Incoming call from 0x0256, returns to 0x0257 // Inputs[1] { @06DD stack[-1] } 06D9 5B JUMPDEST 06DA 61 PUSH2 0x06e2 06DD 81 DUP2 06DE 61 PUSH2 0x0779 06E1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06DA stack[0] = 0x06e2 // @06DD stack[1] = stack[-1] // } // Block ends with call to 0x0779, returns to 0x06E2 label_06E2: // Incoming return from call to 0x0779 at 0x06E1 // Inputs[5] // { // @0704 stack[-1] // @0707 memory[0x40:0x60] // @0740 memory[0x40:0x60] // @0745 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0747 stack[-2] // } 06E2 5B JUMPDEST 06E3 7F PUSH32 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b 0704 81 DUP2 0705 60 PUSH1 0x40 0707 51 MLOAD 0708 80 DUP1 0709 82 DUP3 070A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 071F 16 AND 0720 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0735 16 AND 0736 81 DUP2 0737 52 MSTORE 0738 60 PUSH1 0x20 073A 01 ADD 073B 91 SWAP2 073C 50 POP 073D 50 POP 073E 60 PUSH1 0x40 0740 51 MLOAD 0741 80 DUP1 0742 91 SWAP2 0743 03 SUB 0744 90 SWAP1 0745 A1 LOG1 0746 50 POP 0747 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0737 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0745 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b]); // } // Block ends with unconditional jump to stack[-2] label_0748: // Incoming call from 0x050C, returns to 0x050D // Inputs[2] // { // @0771 stack[-1] // @0776 stack[-2] // } 0748 5B JUMPDEST 0749 60 PUSH1 0x00 074B 7F PUSH32 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b 076C 60 PUSH1 0x01 076E 02 MUL 076F 90 SWAP1 0770 50 POP 0771 81 DUP2 0772 81 DUP2 0773 55 SSTORE 0774 50 POP 0775 50 POP 0776 56 *JUMP // Stack delta = -2 // Outputs[1] { @0773 storage[0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0777: // Incoming call from 0x064E, returns to 0x064F // Inputs[1] { @0778 stack[-1] } 0777 5B JUMPDEST 0778 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0779: // Incoming call from 0x06E1, returns to 0x06E2 // Inputs[1] { @077F stack[-1] } 0779 5B JUMPDEST 077A 60 PUSH1 0x00 077C 61 PUSH2 0x0784 077F 82 DUP3 0780 61 PUSH2 0x084b 0783 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @077A stack[0] = 0x00 // @077C stack[1] = 0x0784 // @077F stack[2] = stack[-1] // } // Block ends with call to 0x084b, returns to 0x0784 label_0784: // Incoming return from call to 0x084B at 0x0783 // Inputs[1] { @0785 stack[-1] } 0784 5B JUMPDEST 0785 15 ISZERO 0786 15 ISZERO 0787 61 PUSH2 0x081e 078A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x081e, if !!stack[-1] label_078B: // Incoming jump from 0x078A, if not !!stack[-1] // Inputs[3] // { // @078D memory[0x40:0x60] // @0818 memory[0x40:0x60] // @081D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 078B 60 PUSH1 0x40 078D 51 MLOAD 078E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 07AF 81 DUP2 07B0 52 MSTORE 07B1 60 PUSH1 0x04 07B3 01 ADD 07B4 80 DUP1 07B5 80 DUP1 07B6 60 PUSH1 0x20 07B8 01 ADD 07B9 82 DUP3 07BA 81 DUP2 07BB 03 SUB 07BC 82 DUP3 07BD 52 MSTORE 07BE 60 PUSH1 0x3b 07C0 81 DUP2 07C1 52 MSTORE 07C2 60 PUSH1 0x20 07C4 01 ADD 07C5 80 DUP1 07C6 7F PUSH32 0x43616e6e6f742073657420612070726f787920696d706c656d656e746174696f 07E7 81 DUP2 07E8 52 MSTORE 07E9 60 PUSH1 0x20 07EB 01 ADD 07EC 7F PUSH32 0x6e20746f2061206e6f6e2d636f6e747261637420616464726573730000000000 080D 81 DUP2 080E 52 MSTORE 080F 50 POP 0810 60 PUSH1 0x40 0812 01 ADD 0813 91 SWAP2 0814 50 POP 0815 50 POP 0816 60 PUSH1 0x40 0818 51 MLOAD 0819 80 DUP1 081A 91 SWAP2 081B 03 SUB 081C 90 SWAP1 081D FD *REVERT // Stack delta = +0 // Outputs[6] // { // @07B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @07BD memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @07C1 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x3b // @07E8 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x43616e6e6f742073657420612070726f787920696d706c656d656e746174696f // @080E memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x6e20746f2061206e6f6e2d636f6e747261637420616464726573730000000000 // @081D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_081E: // Incoming jump from 0x078A, if !!stack[-1] // Inputs[3] // { // @0843 stack[-1] // @0845 stack[-2] // @084A stack[-3] // } 081E 5B JUMPDEST 081F 7F PUSH32 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3 0840 60 PUSH1 0x01 0842 02 MUL 0843 90 SWAP1 0844 50 POP 0845 81 DUP2 0846 81 DUP2 0847 55 SSTORE 0848 50 POP 0849 50 POP 084A 56 *JUMP // Stack delta = -3 // Outputs[1] { @0847 storage[0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_084B: // Incoming call from 0x0783, returns to 0x0784 // Inputs[3] // { // @084F stack[-1] // @0850 address(stack[-1]).code.length // @085A stack[-2] // } 084B 5B JUMPDEST 084C 60 PUSH1 0x00 084E 80 DUP1 084F 82 DUP3 0850 3B EXTCODESIZE 0851 90 SWAP1 0852 50 POP 0853 60 PUSH1 0x00 0855 81 DUP2 0856 11 GT 0857 91 SWAP2 0858 50 POP 0859 50 POP 085A 91 SWAP2 085B 90 SWAP1 085C 50 POP 085D 56 *JUMP // Stack delta = -1 // Outputs[1] { @085A stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] 085E 00 *STOP 085F A1 LOG1 0860 65 PUSH6 0x627a7a723058 0867 20 SHA3 0868 A4 LOG4 0869 A5 A5 086A 47 SELFBALANCE 086B CF CF 086C C7 C7 086D 20 SHA3 086E 2C 2C 086F 5A GAS 0870 CA CA 0871 AA AA 0872 E7 E7 0873 4D 4D 0874 42 TIMESTAMP 0875 8E DUP15 0876 98 SWAP9 0877 8B DUP12 0878 C6 C6 0879 2A 2A 087A D5 D5 087B 02 MUL 087C 4E 4E 087D B0 PUSH 087E 16 AND 087F 55 SSTORE 0880 32 ORIGIN 0881 D3 D3 0882 A8 A8 0883 F9 F9 0884 1D SAR 0885 B4 B4 0886 ED ED 0887 24 24 0888 00 *STOP 0889 29 29