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 0x004e 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x004e, 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 0x3659cfe6 0019 14 EQ 001A 61 PUSH2 0x0067 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0067, if 0x3659cfe6 == msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x3659cfe6 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x4f1ef286 0024 14 EQ 0025 61 PUSH2 0x00b8 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b8, 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 0x5c60da1b 002F 14 EQ 0030 61 PUSH2 0x0151 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0151, if 0x5c60da1b == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0x5c60da1b == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0x8f283970 003A 14 EQ 003B 61 PUSH2 0x01a8 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a8, if 0x8f283970 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0x8f283970 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf851a440 0045 14 EQ 0046 61 PUSH2 0x01f9 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f9, if 0xf851a440 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf851a440 == stack[-1] 004A 61 PUSH2 0x005d 004D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x005d label_004E: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @004F msg.data.length } 004E 5B JUMPDEST 004F 36 CALLDATASIZE 0050 61 PUSH2 0x005d 0053 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x005d, if msg.data.length label_0054: // Incoming jump from 0x0053, if not msg.data.length 0054 61 PUSH2 0x005b 0057 61 PUSH2 0x0250 005A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0054 stack[0] = 0x005b } // Block ends with unconditional jump to 0x0250 005B 5B JUMPDEST 005C 00 *STOP label_005D: // Incoming jump from 0x0053, if msg.data.length // Incoming jump from 0x004D 005D 5B JUMPDEST 005E 61 PUSH2 0x0065 0061 61 PUSH2 0x0250 0064 56 *JUMP // Stack delta = +1 // Outputs[1] { @005E stack[0] = 0x0065 } // Block ends with unconditional jump to 0x0250 0065 5B JUMPDEST 0066 00 *STOP label_0067: // Incoming jump from 0x001D, if 0x3659cfe6 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0068 msg.value } 0067 5B JUMPDEST 0068 34 CALLVALUE 0069 80 DUP1 006A 15 ISZERO 006B 61 PUSH2 0x0073 006E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0068 stack[0] = msg.value } // Block ends with conditional jump to 0x0073, if !msg.value label_006F: // Incoming jump from 0x006E, if not !msg.value // Inputs[1] { @0072 memory[0x00:0x00] } 006F 60 PUSH1 0x00 0071 80 DUP1 0072 FD *REVERT // Stack delta = +0 // Outputs[1] { @0072 revert(memory[0x00:0x00]); } // Block terminates label_0073: // Incoming jump from 0x006E, if !msg.value // Inputs[1] { @007B msg.data.length } 0073 5B JUMPDEST 0074 50 POP 0075 61 PUSH2 0x00b6 0078 60 PUSH1 0x04 007A 80 DUP1 007B 36 CALLDATASIZE 007C 03 SUB 007D 60 PUSH1 0x20 007F 81 DUP2 0080 10 LT 0081 15 ISZERO 0082 61 PUSH2 0x008a 0085 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0075 stack[-1] = 0x00b6 // @0078 stack[0] = 0x04 // @007C stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x008a, returns to 0x00B6, if !(msg.data.length - 0x04 < 0x20) label_0086: // Incoming jump from 0x0085, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0089 memory[0x00:0x00] } 0086 60 PUSH1 0x00 0088 80 DUP1 0089 FD *REVERT // Stack delta = +0 // Outputs[1] { @0089 revert(memory[0x00:0x00]); } // Block terminates label_008A: // Incoming call from 0x0085, returns to 0x00B6, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @008B stack[-2] // @008C stack[-1] // @0090 msg.data[stack[-2]:stack[-2] + 0x20] // } 008A 5B JUMPDEST 008B 81 DUP2 008C 01 ADD 008D 90 SWAP1 008E 80 DUP1 008F 80 DUP1 0090 35 CALLDATALOAD 0091 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00A6 16 AND 00A7 90 SWAP1 00A8 60 PUSH1 0x20 00AA 01 ADD 00AB 90 SWAP1 00AC 92 SWAP3 00AD 91 SWAP2 00AE 90 SWAP1 00AF 50 POP 00B0 50 POP 00B1 50 POP 00B2 61 PUSH2 0x026a 00B5 56 *JUMP // Stack delta = -1 // Outputs[1] { @00AC stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x026a label_00B6: // Incoming return from call to 0x008A at 0x0085 00B6 5B JUMPDEST 00B7 00 *STOP // Stack delta = +0 // Outputs[1] { @00B7 stop(); } // Block terminates label_00B8: // Incoming jump from 0x0028, if 0x4f1ef286 == stack[-1] // Inputs[1] { @00BF msg.data.length } 00B8 5B JUMPDEST 00B9 61 PUSH2 0x014f 00BC 60 PUSH1 0x04 00BE 80 DUP1 00BF 36 CALLDATASIZE 00C0 03 SUB 00C1 60 PUSH1 0x40 00C3 81 DUP2 00C4 10 LT 00C5 15 ISZERO 00C6 61 PUSH2 0x00ce 00C9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @00B9 stack[0] = 0x014f // @00BC stack[1] = 0x04 // @00C0 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00ce, returns to 0x014F, if !(msg.data.length - 0x04 < 0x40) label_00CA: // Incoming jump from 0x00C9, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @00CD memory[0x00:0x00] } 00CA 60 PUSH1 0x00 00CC 80 DUP1 00CD FD *REVERT // Stack delta = +0 // Outputs[1] { @00CD revert(memory[0x00:0x00]); } // Block terminates label_00CE: // Incoming call from 0x00C9, returns to 0x014F, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @00CF stack[-2] // @00D0 stack[-1] // @00D4 msg.data[stack[-2]:stack[-2] + 0x20] // @00F4 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 00CE 5B JUMPDEST 00CF 81 DUP2 00D0 01 ADD 00D1 90 SWAP1 00D2 80 DUP1 00D3 80 DUP1 00D4 35 CALLDATALOAD 00D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00EA 16 AND 00EB 90 SWAP1 00EC 60 PUSH1 0x20 00EE 01 ADD 00EF 90 SWAP1 00F0 92 SWAP3 00F1 91 SWAP2 00F2 90 SWAP1 00F3 80 DUP1 00F4 35 CALLDATALOAD 00F5 90 SWAP1 00F6 60 PUSH1 0x20 00F8 01 ADD 00F9 90 SWAP1 00FA 64 PUSH5 0x0100000000 0100 81 DUP2 0101 11 GT 0102 15 ISZERO 0103 61 PUSH2 0x010b 0106 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @00F0 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @00F1 stack[-1] = stack[-2] + stack[-1] // @00F2 stack[0] = stack[-2] // @00F9 stack[1] = 0x20 + 0x20 + stack[-2] // @00F9 stack[2] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x010b, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) label_0107: // Incoming jump from 0x0106, if not !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @010A memory[0x00:0x00] } 0107 60 PUSH1 0x00 0109 80 DUP1 010A FD *REVERT // Stack delta = +0 // Outputs[1] { @010A revert(memory[0x00:0x00]); } // Block terminates label_010B: // Incoming jump from 0x0106, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @010C stack[-3] // @010D stack[-1] // @010E stack[-4] // } 010B 5B JUMPDEST 010C 82 DUP3 010D 01 ADD 010E 83 DUP4 010F 60 PUSH1 0x20 0111 82 DUP3 0112 01 ADD 0113 11 GT 0114 15 ISZERO 0115 61 PUSH2 0x011d 0118 57 *JUMPI // Stack delta = +0 // Outputs[1] { @010D stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x011d, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0119: // Incoming jump from 0x0118, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @011C memory[0x00:0x00] } 0119 60 PUSH1 0x00 011B 80 DUP1 011C FD *REVERT // Stack delta = +0 // Outputs[1] { @011C revert(memory[0x00:0x00]); } // Block terminates label_011D: // Incoming jump from 0x0118, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @011E stack[-1] // @011F msg.data[stack[-1]:stack[-1] + 0x20] // @0124 stack[-2] // @0125 stack[-4] // } 011D 5B JUMPDEST 011E 80 DUP1 011F 35 CALLDATALOAD 0120 90 SWAP1 0121 60 PUSH1 0x20 0123 01 ADD 0124 91 SWAP2 0125 84 DUP5 0126 60 PUSH1 0x01 0128 83 DUP4 0129 02 MUL 012A 84 DUP5 012B 01 ADD 012C 11 GT 012D 64 PUSH5 0x0100000000 0133 83 DUP4 0134 11 GT 0135 17 OR 0136 15 ISZERO 0137 61 PUSH2 0x013f 013A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0120 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0124 stack[0] = stack[-2] // @0124 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x013f, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_013B: // Incoming jump from 0x013A, 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] { @013E memory[0x00:0x00] } 013B 60 PUSH1 0x00 013D 80 DUP1 013E FD *REVERT // Stack delta = +0 // Outputs[1] { @013E revert(memory[0x00:0x00]); } // Block terminates label_013F: // Incoming jump from 0x013A, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[5] // { // @0140 stack[-2] // @0140 stack[-1] // @0141 stack[-3] // @0142 stack[-4] // @0143 stack[-5] // } 013F 5B JUMPDEST 0140 90 SWAP1 0141 91 SWAP2 0142 92 SWAP3 0143 93 SWAP4 0144 91 SWAP2 0145 92 SWAP3 0146 93 SWAP4 0147 90 SWAP1 0148 50 POP 0149 50 POP 014A 50 POP 014B 61 PUSH2 0x02bf 014E 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0145 stack[-4] = stack[-2] // @0146 stack[-5] = stack[-3] // } // Block ends with unconditional jump to 0x02bf label_014F: // Incoming return from call to 0x00CE at 0x00C9 014F 5B JUMPDEST 0150 00 *STOP // Stack delta = +0 // Outputs[1] { @0150 stop(); } // Block terminates label_0151: // Incoming jump from 0x0033, if 0x5c60da1b == stack[-1] // Inputs[1] { @0152 msg.value } 0151 5B JUMPDEST 0152 34 CALLVALUE 0153 80 DUP1 0154 15 ISZERO 0155 61 PUSH2 0x015d 0158 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0152 stack[0] = msg.value } // Block ends with conditional jump to 0x015d, if !msg.value label_0159: // Incoming jump from 0x0158, if not !msg.value // Inputs[1] { @015C memory[0x00:0x00] } 0159 60 PUSH1 0x00 015B 80 DUP1 015C FD *REVERT // Stack delta = +0 // Outputs[1] { @015C revert(memory[0x00:0x00]); } // Block terminates label_015D: // Incoming jump from 0x0158, if !msg.value 015D 5B JUMPDEST 015E 50 POP 015F 61 PUSH2 0x0166 0162 61 PUSH2 0x0395 0165 56 *JUMP // Stack delta = +0 // Outputs[1] { @015F stack[-1] = 0x0166 } // Block ends with call to 0x0395, returns to 0x0166 label_0166: // Incoming return from call to 0x0395 at 0x0165 // Inputs[4] // { // @0169 memory[0x40:0x60] // @016B stack[-1] // @01A2 memory[0x40:0x60] // @01A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0166 5B JUMPDEST 0167 60 PUSH1 0x40 0169 51 MLOAD 016A 80 DUP1 016B 82 DUP3 016C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0181 16 AND 0182 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0197 16 AND 0198 81 DUP2 0199 52 MSTORE 019A 60 PUSH1 0x20 019C 01 ADD 019D 91 SWAP2 019E 50 POP 019F 50 POP 01A0 60 PUSH1 0x40 01A2 51 MLOAD 01A3 80 DUP1 01A4 91 SWAP2 01A5 03 SUB 01A6 90 SWAP1 01A7 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0199 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @01A7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01A8: // Incoming jump from 0x003E, if 0x8f283970 == stack[-1] // Inputs[1] { @01A9 msg.value } 01A8 5B JUMPDEST 01A9 34 CALLVALUE 01AA 80 DUP1 01AB 15 ISZERO 01AC 61 PUSH2 0x01b4 01AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01A9 stack[0] = msg.value } // Block ends with conditional jump to 0x01b4, if !msg.value label_01B0: // Incoming jump from 0x01AF, if not !msg.value // Inputs[1] { @01B3 memory[0x00:0x00] } 01B0 60 PUSH1 0x00 01B2 80 DUP1 01B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B3 revert(memory[0x00:0x00]); } // Block terminates label_01B4: // Incoming jump from 0x01AF, if !msg.value // Inputs[1] { @01BC msg.data.length } 01B4 5B JUMPDEST 01B5 50 POP 01B6 61 PUSH2 0x01f7 01B9 60 PUSH1 0x04 01BB 80 DUP1 01BC 36 CALLDATASIZE 01BD 03 SUB 01BE 60 PUSH1 0x20 01C0 81 DUP2 01C1 10 LT 01C2 15 ISZERO 01C3 61 PUSH2 0x01cb 01C6 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @01B6 stack[-1] = 0x01f7 // @01B9 stack[0] = 0x04 // @01BD stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01cb, returns to 0x01F7, if !(msg.data.length - 0x04 < 0x20) label_01C7: // Incoming jump from 0x01C6, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @01CA memory[0x00:0x00] } 01C7 60 PUSH1 0x00 01C9 80 DUP1 01CA FD *REVERT // Stack delta = +0 // Outputs[1] { @01CA revert(memory[0x00:0x00]); } // Block terminates label_01CB: // Incoming call from 0x01C6, returns to 0x01F7, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @01CC stack[-2] // @01CD stack[-1] // @01D1 msg.data[stack[-2]:stack[-2] + 0x20] // } 01CB 5B JUMPDEST 01CC 81 DUP2 01CD 01 ADD 01CE 90 SWAP1 01CF 80 DUP1 01D0 80 DUP1 01D1 35 CALLDATALOAD 01D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01E7 16 AND 01E8 90 SWAP1 01E9 60 PUSH1 0x20 01EB 01 ADD 01EC 90 SWAP1 01ED 92 SWAP3 01EE 91 SWAP2 01EF 90 SWAP1 01F0 50 POP 01F1 50 POP 01F2 50 POP 01F3 61 PUSH2 0x03ed 01F6 56 *JUMP // Stack delta = -1 // Outputs[1] { @01ED stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x03ed label_01F7: // Incoming return from call to 0x01CB at 0x01C6 01F7 5B JUMPDEST 01F8 00 *STOP // Stack delta = +0 // Outputs[1] { @01F8 stop(); } // Block terminates label_01F9: // Incoming jump from 0x0049, if 0xf851a440 == stack[-1] // Inputs[1] { @01FA msg.value } 01F9 5B JUMPDEST 01FA 34 CALLVALUE 01FB 80 DUP1 01FC 15 ISZERO 01FD 61 PUSH2 0x0205 0200 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01FA stack[0] = msg.value } // Block ends with conditional jump to 0x0205, if !msg.value label_0201: // Incoming jump from 0x0200, if not !msg.value // Inputs[1] { @0204 memory[0x00:0x00] } 0201 60 PUSH1 0x00 0203 80 DUP1 0204 FD *REVERT // Stack delta = +0 // Outputs[1] { @0204 revert(memory[0x00:0x00]); } // Block terminates label_0205: // Incoming jump from 0x0200, if !msg.value 0205 5B JUMPDEST 0206 50 POP 0207 61 PUSH2 0x020e 020A 61 PUSH2 0x0566 020D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0207 stack[-1] = 0x020e } // Block ends with call to 0x0566, returns to 0x020E label_020E: // Incoming return from call to 0x0566 at 0x020D // Inputs[4] // { // @0211 memory[0x40:0x60] // @0213 stack[-1] // @024A memory[0x40:0x60] // @024F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 020E 5B JUMPDEST 020F 60 PUSH1 0x40 0211 51 MLOAD 0212 80 DUP1 0213 82 DUP3 0214 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0229 16 AND 022A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 023F 16 AND 0240 81 DUP2 0241 52 MSTORE 0242 60 PUSH1 0x20 0244 01 ADD 0245 91 SWAP2 0246 50 POP 0247 50 POP 0248 60 PUSH1 0x40 024A 51 MLOAD 024B 80 DUP1 024C 91 SWAP2 024D 03 SUB 024E 90 SWAP1 024F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0241 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @024F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0250: // Incoming jump from 0x005A // Incoming jump from 0x03E8 // Incoming jump from 0x02BA // Incoming jump from 0x05B9 // Incoming jump from 0x038E // Incoming jump from 0x0064 // Incoming jump from 0x0561 0250 5B JUMPDEST 0251 61 PUSH2 0x0258 0254 61 PUSH2 0x05d1 0257 56 *JUMP // Stack delta = +1 // Outputs[1] { @0251 stack[0] = 0x0258 } // Block ends with call to 0x05d1, returns to 0x0258 label_0258: // Incoming return from call to 0x05D1 at 0x0257 0258 5B JUMPDEST 0259 61 PUSH2 0x0268 025C 61 PUSH2 0x0263 025F 61 PUSH2 0x0667 0262 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0259 stack[0] = 0x0268 // @025C stack[1] = 0x0263 // } // Block ends with call to 0x0667, returns to 0x0263 label_0263: // Incoming return from call to 0x0667 at 0x0262 0263 5B JUMPDEST 0264 61 PUSH2 0x0698 0267 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0698 0268 5B JUMPDEST 0269 56 *JUMP label_026A: // Incoming jump from 0x00B5 026A 5B JUMPDEST 026B 61 PUSH2 0x0272 026E 61 PUSH2 0x06be 0271 56 *JUMP // Stack delta = +1 // Outputs[1] { @026B stack[0] = 0x0272 } // Block ends with call to 0x06be, returns to 0x0272 label_0272: // Incoming return from call to 0x06BE at 0x0271 // Inputs[2] // { // @0288 stack[-1] // @0289 msg.sender // } 0272 5B JUMPDEST 0273 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0288 16 AND 0289 33 CALLER 028A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 029F 16 AND 02A0 14 EQ 02A1 15 ISZERO 02A2 61 PUSH2 0x02b3 02A5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x02b3, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_02A6: // Incoming jump from 0x02A5, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @02A9 stack[-1] } 02A6 61 PUSH2 0x02ae 02A9 81 DUP2 02AA 61 PUSH2 0x06ef 02AD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02A6 stack[0] = 0x02ae // @02A9 stack[1] = stack[-1] // } // Block ends with call to 0x06ef, returns to 0x02AE label_02AE: // Incoming return from call to 0x06EF at 0x02AD 02AE 5B JUMPDEST 02AF 61 PUSH2 0x02bc 02B2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02bc label_02B3: // Incoming jump from 0x02A5, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 02B3 5B JUMPDEST 02B4 61 PUSH2 0x02bb 02B7 61 PUSH2 0x0250 02BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @02B4 stack[0] = 0x02bb } // Block ends with unconditional jump to 0x0250 02BB 5B JUMPDEST label_02BC: // Incoming jump from 0x02B2 // Inputs[1] { @02BE stack[-2] } 02BC 5B JUMPDEST 02BD 50 POP 02BE 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_02BF: // Incoming jump from 0x014E 02BF 5B JUMPDEST 02C0 61 PUSH2 0x02c7 02C3 61 PUSH2 0x06be 02C6 56 *JUMP // Stack delta = +1 // Outputs[1] { @02C0 stack[0] = 0x02c7 } // Block ends with call to 0x06be, returns to 0x02C7 label_02C7: // Incoming return from call to 0x06BE at 0x02C6 // Inputs[2] // { // @02DD stack[-1] // @02DE msg.sender // } 02C7 5B JUMPDEST 02C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02DD 16 AND 02DE 33 CALLER 02DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02F4 16 AND 02F5 14 EQ 02F6 15 ISZERO 02F7 61 PUSH2 0x0387 02FA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0387, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_02FB: // Incoming jump from 0x02FA, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @02FE stack[-3] } 02FB 61 PUSH2 0x0303 02FE 83 DUP4 02FF 61 PUSH2 0x06ef 0302 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02FB stack[0] = 0x0303 // @02FE stack[1] = stack[-3] // } // Block ends with call to 0x06ef, returns to 0x0303 label_0303: // Incoming return from call to 0x06EF at 0x0302 // Inputs[10] // { // @0306 stack[-3] // @031D stack[-2] // @031E stack[-1] // @0321 memory[0x40:0x60] // @0328 msg.data[stack[-2]:stack[-2] + stack[-1]] // @0338 memory[0x40:0x60] // @033E msg.gas // @033F memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]] // @033F address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // @0343 returndata.length // } 0303 5B JUMPDEST 0304 60 PUSH1 0x00 0306 83 DUP4 0307 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 031C 16 AND 031D 83 DUP4 031E 83 DUP4 031F 60 PUSH1 0x40 0321 51 MLOAD 0322 80 DUP1 0323 83 DUP4 0324 83 DUP4 0325 80 DUP1 0326 82 DUP3 0327 84 DUP5 0328 37 CALLDATACOPY 0329 80 DUP1 032A 83 DUP4 032B 01 ADD 032C 92 SWAP3 032D 50 POP 032E 50 POP 032F 50 POP 0330 92 SWAP3 0331 50 POP 0332 50 POP 0333 50 POP 0334 60 PUSH1 0x00 0336 60 PUSH1 0x40 0338 51 MLOAD 0339 80 DUP1 033A 83 DUP4 033B 03 SUB 033C 81 DUP2 033D 85 DUP6 033E 5A GAS 033F F4 DELEGATECALL 0340 91 SWAP2 0341 50 POP 0342 50 POP 0343 3D RETURNDATASIZE 0344 80 DUP1 0345 60 PUSH1 0x00 0347 81 DUP2 0348 14 EQ 0349 61 PUSH2 0x036e 034C 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0304 stack[0] = 0x00 // @0328 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @033F 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]]) // @0340 stack[1] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // @0343 stack[2] = returndata.length // @0344 stack[3] = returndata.length // } // Block ends with conditional jump to 0x036e, if returndata.length == 0x00 label_034D: // Incoming jump from 0x034C, if not returndata.length == 0x00 // Inputs[6] // { // @034F memory[0x40:0x60] // @0350 stack[-2] // @0357 returndata.length // @035F returndata.length // @0362 returndata.length // @0369 returndata[0x00:0x00 + returndata.length] // } 034D 60 PUSH1 0x40 034F 51 MLOAD 0350 91 SWAP2 0351 50 POP 0352 60 PUSH1 0x1f 0354 19 NOT 0355 60 PUSH1 0x3f 0357 3D RETURNDATASIZE 0358 01 ADD 0359 16 AND 035A 82 DUP3 035B 01 ADD 035C 60 PUSH1 0x40 035E 52 MSTORE 035F 3D RETURNDATASIZE 0360 82 DUP3 0361 52 MSTORE 0362 3D RETURNDATASIZE 0363 60 PUSH1 0x00 0365 60 PUSH1 0x20 0367 84 DUP5 0368 01 ADD 0369 3E RETURNDATACOPY 036A 61 PUSH2 0x0373 036D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0350 stack[-2] = memory[0x40:0x60] // @035E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0361 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0369 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0373 label_036E: // Incoming jump from 0x034C, if returndata.length == 0x00 // Inputs[3] // { // @0371 stack[-2] // @0376 stack[-3] // @0376 stack[-4] // } 036E 5B JUMPDEST 036F 60 PUSH1 0x60 0371 91 SWAP2 0372 50 POP 0373 5B JUMPDEST 0374 50 POP 0375 50 POP 0376 90 SWAP1 0377 50 POP 0378 80 DUP1 0379 61 PUSH2 0x0381 037C 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0376 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0381, if stack[-3] label_037D: // Incoming jump from 0x037C, if not stack[-3] // Incoming jump from 0x037C, if not stack[-3] // Inputs[1] { @0380 memory[0x00:0x00] } 037D 60 PUSH1 0x00 037F 80 DUP1 0380 FD *REVERT // Stack delta = +0 // Outputs[1] { @0380 revert(memory[0x00:0x00]); } // Block terminates label_0381: // Incoming jump from 0x037C, if stack[-3] // Incoming jump from 0x037C, if stack[-3] 0381 5B JUMPDEST 0382 50 POP 0383 61 PUSH2 0x0390 0386 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x0390 label_0387: // Incoming jump from 0x02FA, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 0387 5B JUMPDEST 0388 61 PUSH2 0x038f 038B 61 PUSH2 0x0250 038E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0388 stack[0] = 0x038f } // Block ends with unconditional jump to 0x0250 038F 5B JUMPDEST label_0390: // Incoming jump from 0x0386 // Inputs[1] { @0394 stack[-4] } 0390 5B JUMPDEST 0391 50 POP 0392 50 POP 0393 50 POP 0394 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0395: // Incoming call from 0x0165, returns to 0x0166 0395 5B JUMPDEST 0396 60 PUSH1 0x00 0398 61 PUSH2 0x039f 039B 61 PUSH2 0x06be 039E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0396 stack[0] = 0x00 // @0398 stack[1] = 0x039f // } // Block ends with call to 0x06be, returns to 0x039F label_039F: // Incoming return from call to 0x06BE at 0x039E // Inputs[2] // { // @03B5 stack[-1] // @03B6 msg.sender // } 039F 5B JUMPDEST 03A0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03B5 16 AND 03B6 33 CALLER 03B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03CC 16 AND 03CD 14 EQ 03CE 15 ISZERO 03CF 61 PUSH2 0x03e1 03D2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x03e1, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_03D3: // Incoming jump from 0x03D2, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 03D3 61 PUSH2 0x03da 03D6 61 PUSH2 0x0667 03D9 56 *JUMP // Stack delta = +1 // Outputs[1] { @03D3 stack[0] = 0x03da } // Block ends with call to 0x0667, returns to 0x03DA label_03DA: // Incoming return from call to 0x0667 at 0x03D9 // Inputs[2] // { // @03DB stack[-2] // @03DB stack[-1] // } 03DA 5B JUMPDEST 03DB 90 SWAP1 03DC 50 POP 03DD 61 PUSH2 0x03ea 03E0 56 *JUMP // Stack delta = -1 // Outputs[1] { @03DB stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x03ea label_03E1: // Incoming jump from 0x03D2, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 03E1 5B JUMPDEST 03E2 61 PUSH2 0x03e9 03E5 61 PUSH2 0x0250 03E8 56 *JUMP // Stack delta = +1 // Outputs[1] { @03E2 stack[0] = 0x03e9 } // Block ends with unconditional jump to 0x0250 03E9 5B JUMPDEST label_03EA: // Incoming jump from 0x03E0 // Inputs[2] // { // @03EB stack[-2] // @03EB stack[-1] // } 03EA 5B JUMPDEST 03EB 90 SWAP1 03EC 56 *JUMP // Stack delta = -1 // Outputs[1] { @03EB stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_03ED: // Incoming jump from 0x01F6 03ED 5B JUMPDEST 03EE 61 PUSH2 0x03f5 03F1 61 PUSH2 0x06be 03F4 56 *JUMP // Stack delta = +1 // Outputs[1] { @03EE stack[0] = 0x03f5 } // Block ends with call to 0x06be, returns to 0x03F5 label_03F5: // Incoming return from call to 0x06BE at 0x03F4 // Inputs[2] // { // @040B stack[-1] // @040C msg.sender // } 03F5 5B JUMPDEST 03F6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 040B 16 AND 040C 33 CALLER 040D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0422 16 AND 0423 14 EQ 0424 15 ISZERO 0425 61 PUSH2 0x055a 0428 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x055a, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0429: // Incoming jump from 0x0428, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @0441 stack[-1] } 0429 60 PUSH1 0x00 042B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0440 16 AND 0441 81 DUP2 0442 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0457 16 AND 0458 14 EQ 0459 15 ISZERO 045A 61 PUSH2 0x04ae 045D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ae, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_045E: // Incoming jump from 0x045D, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @0460 memory[0x40:0x60] // @04A8 memory[0x40:0x60] // @04AD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 045E 60 PUSH1 0x40 0460 51 MLOAD 0461 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0482 81 DUP2 0483 52 MSTORE 0484 60 PUSH1 0x04 0486 01 ADD 0487 80 DUP1 0488 80 DUP1 0489 60 PUSH1 0x20 048B 01 ADD 048C 82 DUP3 048D 81 DUP2 048E 03 SUB 048F 82 DUP3 0490 52 MSTORE 0491 60 PUSH1 0x36 0493 81 DUP2 0494 52 MSTORE 0495 60 PUSH1 0x20 0497 01 ADD 0498 80 DUP1 0499 61 PUSH2 0x082f 049C 60 PUSH1 0x36 049E 91 SWAP2 049F 39 CODECOPY 04A0 60 PUSH1 0x40 04A2 01 ADD 04A3 91 SWAP2 04A4 50 POP 04A5 50 POP 04A6 60 PUSH1 0x40 04A8 51 MLOAD 04A9 80 DUP1 04AA 91 SWAP2 04AB 03 SUB 04AC 90 SWAP1 04AD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0483 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0490 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0494 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x36 // @049F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x36] = code[0x082f:0x0865] // @04AD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_04AE: // Incoming jump from 0x045D, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) 04AE 5B JUMPDEST 04AF 7F PUSH32 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f 04D0 61 PUSH2 0x04d7 04D3 61 PUSH2 0x06be 04D6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @04AF stack[0] = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f // @04D0 stack[1] = 0x04d7 // } // Block ends with call to 0x06be, returns to 0x04D7 label_04D7: // Incoming return from call to 0x06BE at 0x04D6 // Inputs[6] // { // @04D8 stack[-3] // @04DB memory[0x40:0x60] // @04DD stack[-1] // @0547 memory[0x40:0x60] // @054C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @054C stack[-2] // } 04D7 5B JUMPDEST 04D8 82 DUP3 04D9 60 PUSH1 0x40 04DB 51 MLOAD 04DC 80 DUP1 04DD 83 DUP4 04DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04F3 16 AND 04F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0509 16 AND 050A 81 DUP2 050B 52 MSTORE 050C 60 PUSH1 0x20 050E 01 ADD 050F 82 DUP3 0510 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0525 16 AND 0526 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 053B 16 AND 053C 81 DUP2 053D 52 MSTORE 053E 60 PUSH1 0x20 0540 01 ADD 0541 92 SWAP3 0542 50 POP 0543 50 POP 0544 50 POP 0545 60 PUSH1 0x40 0547 51 MLOAD 0548 80 DUP1 0549 91 SWAP2 054A 03 SUB 054B 90 SWAP1 054C A1 LOG1 054D 61 PUSH2 0x0555 0550 81 DUP2 0551 61 PUSH2 0x073e 0554 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @050B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @053D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @054C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // @054D stack[-2] = 0x0555 // @0550 stack[-1] = stack[-3] // } // Block ends with call to 0x073e, returns to 0x0555 label_0555: // Incoming return from call to 0x073E at 0x0554 0555 5B JUMPDEST 0556 61 PUSH2 0x0563 0559 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0563 label_055A: // Incoming jump from 0x0428, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 055A 5B JUMPDEST 055B 61 PUSH2 0x0562 055E 61 PUSH2 0x0250 0561 56 *JUMP // Stack delta = +1 // Outputs[1] { @055B stack[0] = 0x0562 } // Block ends with unconditional jump to 0x0250 0562 5B JUMPDEST label_0563: // Incoming jump from 0x0559 // Inputs[1] { @0565 stack[-2] } 0563 5B JUMPDEST 0564 50 POP 0565 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0566: // Incoming call from 0x020D, returns to 0x020E 0566 5B JUMPDEST 0567 60 PUSH1 0x00 0569 61 PUSH2 0x0570 056C 61 PUSH2 0x06be 056F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0567 stack[0] = 0x00 // @0569 stack[1] = 0x0570 // } // Block ends with call to 0x06be, returns to 0x0570 label_0570: // Incoming return from call to 0x06BE at 0x056F // Inputs[2] // { // @0586 stack[-1] // @0587 msg.sender // } 0570 5B JUMPDEST 0571 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0586 16 AND 0587 33 CALLER 0588 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 059D 16 AND 059E 14 EQ 059F 15 ISZERO 05A0 61 PUSH2 0x05b2 05A3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05b2, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_05A4: // Incoming jump from 0x05A3, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 05A4 61 PUSH2 0x05ab 05A7 61 PUSH2 0x06be 05AA 56 *JUMP // Stack delta = +1 // Outputs[1] { @05A4 stack[0] = 0x05ab } // Block ends with call to 0x06be, returns to 0x05AB label_05AB: // Incoming return from call to 0x06BE at 0x05AA // Inputs[2] // { // @05AC stack[-1] // @05AC stack[-2] // } 05AB 5B JUMPDEST 05AC 90 SWAP1 05AD 50 POP 05AE 61 PUSH2 0x05bb 05B1 56 *JUMP // Stack delta = -1 // Outputs[1] { @05AC stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x05bb label_05B2: // Incoming jump from 0x05A3, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 05B2 5B JUMPDEST 05B3 61 PUSH2 0x05ba 05B6 61 PUSH2 0x0250 05B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @05B3 stack[0] = 0x05ba } // Block ends with unconditional jump to 0x0250 05BA 5B JUMPDEST label_05BB: // Incoming jump from 0x05B1 // Inputs[2] // { // @05BC stack[-1] // @05BC stack[-2] // } 05BB 5B JUMPDEST 05BC 90 SWAP1 05BD 56 *JUMP // Stack delta = -1 // Outputs[1] { @05BC stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_05BE: // Incoming call from 0x0777, returns to 0x0778 // Inputs[3] // { // @05C2 stack[-1] // @05C3 address(stack[-1]).code.length // @05CD stack[-2] // } 05BE 5B JUMPDEST 05BF 60 PUSH1 0x00 05C1 80 DUP1 05C2 82 DUP3 05C3 3B EXTCODESIZE 05C4 90 SWAP1 05C5 50 POP 05C6 60 PUSH1 0x00 05C8 81 DUP2 05C9 11 GT 05CA 91 SWAP2 05CB 50 POP 05CC 50 POP 05CD 91 SWAP2 05CE 90 SWAP1 05CF 50 POP 05D0 56 *JUMP // Stack delta = -1 // Outputs[1] { @05CD stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_05D1: // Incoming call from 0x0257, returns to 0x0258 05D1 5B JUMPDEST 05D2 61 PUSH2 0x05d9 05D5 61 PUSH2 0x06be 05D8 56 *JUMP // Stack delta = +1 // Outputs[1] { @05D2 stack[0] = 0x05d9 } // Block ends with call to 0x06be, returns to 0x05D9 label_05D9: // Incoming return from call to 0x06BE at 0x05D8 // Inputs[2] // { // @05EF stack[-1] // @05F0 msg.sender // } 05D9 5B JUMPDEST 05DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05EF 16 AND 05F0 33 CALLER 05F1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0606 16 AND 0607 14 EQ 0608 15 ISZERO 0609 61 PUSH2 0x065d 060C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x065d, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_060D: // Incoming jump from 0x060C, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @060F memory[0x40:0x60] // @0657 memory[0x40:0x60] // @065C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 060D 60 PUSH1 0x40 060F 51 MLOAD 0610 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0631 81 DUP2 0632 52 MSTORE 0633 60 PUSH1 0x04 0635 01 ADD 0636 80 DUP1 0637 80 DUP1 0638 60 PUSH1 0x20 063A 01 ADD 063B 82 DUP3 063C 81 DUP2 063D 03 SUB 063E 82 DUP3 063F 52 MSTORE 0640 60 PUSH1 0x32 0642 81 DUP2 0643 52 MSTORE 0644 60 PUSH1 0x20 0646 01 ADD 0647 80 DUP1 0648 61 PUSH2 0x07fd 064B 60 PUSH1 0x32 064D 91 SWAP2 064E 39 CODECOPY 064F 60 PUSH1 0x40 0651 01 ADD 0652 91 SWAP2 0653 50 POP 0654 50 POP 0655 60 PUSH1 0x40 0657 51 MLOAD 0658 80 DUP1 0659 91 SWAP2 065A 03 SUB 065B 90 SWAP1 065C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0632 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @063F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0643 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x32 // @064E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x32] = code[0x07fd:0x082f] // @065C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_065D: // Incoming jump from 0x060C, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) 065D 5B JUMPDEST 065E 61 PUSH2 0x0665 0661 61 PUSH2 0x076d 0664 56 *JUMP // Stack delta = +1 // Outputs[1] { @065E stack[0] = 0x0665 } // Block ends with call to 0x076d, returns to 0x0665 label_0665: // Incoming return from call to 0x076D at 0x0664 // Inputs[1] { @0666 stack[-1] } 0665 5B JUMPDEST 0666 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0667: // Incoming call from 0x0262, returns to 0x0263 // Incoming call from 0x03D9, returns to 0x03DA // Inputs[2] // { // @0692 storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] // @0696 stack[-1] // } 0667 5B JUMPDEST 0668 60 PUSH1 0x00 066A 80 DUP1 066B 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 068C 60 PUSH1 0x00 068E 1B SHL 068F 90 SWAP1 0690 50 POP 0691 80 DUP1 0692 54 SLOAD 0693 91 SWAP2 0694 50 POP 0695 50 POP 0696 90 SWAP1 0697 56 *JUMP // Stack delta = +0 // Outputs[1] { @0696 stack[-1] = storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] } // Block ends with unconditional jump to stack[-1] label_0698: // Incoming jump from 0x0267 // Inputs[9] // { // @0699 msg.data.length // @069D msg.data[0x00:0x00 + msg.data.length] // @06A1 msg.data.length // @06A4 stack[-1] // @06A5 msg.gas // @06A6 address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @06A6 memory[0x00:0x00 + msg.data.length] // @06A7 returndata.length // @06AB returndata[0x00:0x00 + returndata.length] // } 0698 5B JUMPDEST 0699 36 CALLDATASIZE 069A 60 PUSH1 0x00 069C 80 DUP1 069D 37 CALLDATACOPY 069E 60 PUSH1 0x00 06A0 80 DUP1 06A1 36 CALLDATASIZE 06A2 60 PUSH1 0x00 06A4 84 DUP5 06A5 5A GAS 06A6 F4 DELEGATECALL 06A7 3D RETURNDATASIZE 06A8 60 PUSH1 0x00 06AA 80 DUP1 06AB 3E RETURNDATACOPY 06AC 80 DUP1 06AD 60 PUSH1 0x00 06AF 81 DUP2 06B0 14 EQ 06B1 61 PUSH2 0x06b9 06B4 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @069D memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @06A6 memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @06A6 stack[0] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @06AB memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @06AC stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // } // Block ends with conditional jump to 0x06b9, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 label_06B5: // Incoming jump from 0x06B4, if not address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 // Inputs[2] // { // @06B5 returndata.length // @06B8 memory[0x00:0x00 + returndata.length] // } 06B5 3D RETURNDATASIZE 06B6 60 PUSH1 0x00 06B8 F3 *RETURN // Stack delta = +0 // Outputs[1] { @06B8 return memory[0x00:0x00 + returndata.length]; } // Block terminates label_06B9: // Incoming jump from 0x06B4, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00 // Inputs[2] // { // @06BA returndata.length // @06BD memory[0x00:0x00 + returndata.length] // } 06B9 5B JUMPDEST 06BA 3D RETURNDATASIZE 06BB 60 PUSH1 0x00 06BD FD *REVERT // Stack delta = +0 // Outputs[1] { @06BD revert(memory[0x00:0x00 + returndata.length]); } // Block terminates label_06BE: // Incoming call from 0x05D8, returns to 0x05D9 // Incoming call from 0x056F, returns to 0x0570 // Incoming call from 0x05AA, returns to 0x05AB // Incoming call from 0x039E, returns to 0x039F // Incoming call from 0x04D6, returns to 0x04D7 // Incoming call from 0x0271, returns to 0x0272 // Incoming call from 0x02C6, returns to 0x02C7 // Incoming call from 0x03F4, returns to 0x03F5 // Inputs[2] // { // @06E9 storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] // @06ED stack[-1] // } 06BE 5B JUMPDEST 06BF 60 PUSH1 0x00 06C1 80 DUP1 06C2 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 06E3 60 PUSH1 0x00 06E5 1B SHL 06E6 90 SWAP1 06E7 50 POP 06E8 80 DUP1 06E9 54 SLOAD 06EA 91 SWAP2 06EB 50 POP 06EC 50 POP 06ED 90 SWAP1 06EE 56 *JUMP // Stack delta = +0 // Outputs[1] { @06ED stack[-1] = storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] } // Block ends with unconditional jump to stack[-1] label_06EF: // Incoming call from 0x0302, returns to 0x0303 // Incoming call from 0x02AD, returns to 0x02AE // Inputs[1] { @06F3 stack[-1] } 06EF 5B JUMPDEST 06F0 61 PUSH2 0x06f8 06F3 81 DUP2 06F4 61 PUSH2 0x076f 06F7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06F0 stack[0] = 0x06f8 // @06F3 stack[1] = stack[-1] // } // Block ends with call to 0x076f, returns to 0x06F8 label_06F8: // Incoming return from call to 0x076F at 0x06F7 // Inputs[5] // { // @06F9 stack[-1] // @0733 memory[0x40:0x60] // @0736 memory[0x40:0x60] // @073B memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @073D stack[-2] // } 06F8 5B JUMPDEST 06F9 80 DUP1 06FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 070F 16 AND 0710 7F PUSH32 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b 0731 60 PUSH1 0x40 0733 51 MLOAD 0734 60 PUSH1 0x40 0736 51 MLOAD 0737 80 DUP1 0738 91 SWAP2 0739 03 SUB 073A 90 SWAP1 073B A2 LOG2 073C 50 POP 073D 56 *JUMP // Stack delta = -2 // Outputs[1] { @073B 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_073E: // Incoming call from 0x0554, returns to 0x0555 // Inputs[2] // { // @0767 stack[-1] // @076C stack[-2] // } 073E 5B JUMPDEST 073F 60 PUSH1 0x00 0741 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 0762 60 PUSH1 0x00 0764 1B SHL 0765 90 SWAP1 0766 50 POP 0767 81 DUP2 0768 81 DUP2 0769 55 SSTORE 076A 50 POP 076B 50 POP 076C 56 *JUMP // Stack delta = -2 // Outputs[1] { @0769 storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_076D: // Incoming call from 0x0664, returns to 0x0665 // Inputs[1] { @076E stack[-1] } 076D 5B JUMPDEST 076E 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_076F: // Incoming call from 0x06F7, returns to 0x06F8 // Inputs[1] { @0773 stack[-1] } 076F 5B JUMPDEST 0770 61 PUSH2 0x0778 0773 81 DUP2 0774 61 PUSH2 0x05be 0777 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0770 stack[0] = 0x0778 // @0773 stack[1] = stack[-1] // } // Block ends with call to 0x05be, returns to 0x0778 label_0778: // Incoming return from call to 0x05BE at 0x0777 // Inputs[1] { @077C stack[-1] } 0778 5B JUMPDEST 0779 61 PUSH2 0x07cd 077C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07cd, if stack[-1] label_077D: // Incoming jump from 0x077C, if not stack[-1] // Inputs[3] // { // @077F memory[0x40:0x60] // @07C7 memory[0x40:0x60] // @07CC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 077D 60 PUSH1 0x40 077F 51 MLOAD 0780 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 07A1 81 DUP2 07A2 52 MSTORE 07A3 60 PUSH1 0x04 07A5 01 ADD 07A6 80 DUP1 07A7 80 DUP1 07A8 60 PUSH1 0x20 07AA 01 ADD 07AB 82 DUP3 07AC 81 DUP2 07AD 03 SUB 07AE 82 DUP3 07AF 52 MSTORE 07B0 60 PUSH1 0x3b 07B2 81 DUP2 07B3 52 MSTORE 07B4 60 PUSH1 0x20 07B6 01 ADD 07B7 80 DUP1 07B8 61 PUSH2 0x0865 07BB 60 PUSH1 0x3b 07BD 91 SWAP2 07BE 39 CODECOPY 07BF 60 PUSH1 0x40 07C1 01 ADD 07C2 91 SWAP2 07C3 50 POP 07C4 50 POP 07C5 60 PUSH1 0x40 07C7 51 MLOAD 07C8 80 DUP1 07C9 91 SWAP2 07CA 03 SUB 07CB 90 SWAP1 07CC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @07A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @07AF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @07B3 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x3b // @07BE memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x3b] = code[0x0865:0x08a0] // @07CC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_07CD: // Incoming jump from 0x077C, if stack[-1] // Inputs[2] // { // @07F6 stack[-1] // @07FB stack[-2] // } 07CD 5B JUMPDEST 07CE 60 PUSH1 0x00 07D0 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 07F1 60 PUSH1 0x00 07F3 1B SHL 07F4 90 SWAP1 07F5 50 POP 07F6 81 DUP2 07F7 81 DUP2 07F8 55 SSTORE 07F9 50 POP 07FA 50 POP 07FB 56 *JUMP // Stack delta = -2 // Outputs[1] { @07F8 storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] = stack[-1] } // Block ends with unconditional jump to stack[-2] 07FC FE *ASSERT 07FD 43 NUMBER 07FE 61 PUSH2 0x6e6e 0801 6F PUSH16 0x742063616c6c2066616c6c6261636b20 0812 66 PUSH7 0x756e6374696f6e 081A 20 SHA3 081B 66 PUSH7 0x726f6d20746865 0823 20 SHA3 0824 70 PUSH17 0x726f78792061646d696e43616e6e6f7420 0836 63 PUSH4 0x68616e67 083B 65 PUSH6 0x207468652061 0842 64 PUSH5 0x6d696e206f 0848 66 PUSH7 0x20612070726f78 0850 79 PUSH26 0x20746f20746865207a65726f206164647265737343616e6e6f74 086B 20 SHA3 086C 73 PUSH20 0x657420612070726f787920696d706c656d656e74 0881 61 PUSH2 0x7469 0884 6F PUSH16 0x6e20746f2061206e6f6e2d636f6e7472 0895 61 PUSH2 0x6374 0898 20 SHA3 0899 61 PUSH2 0x6464 089C 72 PUSH19 0x657373a2646970667358221220b0503c23d64d 08B0 00 *STOP 08B1 87 DUP8 08B2 2F 2F 08B3 30 ADDRESS 08B4 9A SWAP11 08B5 F6 F6 08B6 EB EB 08B7 C4 C4 08B8 39 CODECOPY 08B9 40 BLOCKHASH 08BA 1F 1F 08BB 4A 4A 08BC 3A GASPRICE 08BD 52 MSTORE 08BE 89 DUP10 08BF BB BB 08C0 B6 B6 08C1 98 SWAP9 08C2 FA STATICCALL 08C3 4E 4E 08C4 5A GAS 08C5 AB AB 08C6 D7 D7 08C7 47 SELFBALANCE 08C8 64 PUSH5 0x2664736f6c 08CE 63 PUSH4 0x43000608 08D3 00 *STOP 08D4 33 CALLER