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 0x004c 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x004c, 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 0x4b64e492 003C 14 EQ 003D 61 PUSH2 0x004e 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x004e, if 0x4b64e492 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x4b64e492 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x80e10aa5 0047 14 EQ 0048 61 PUSH2 0x0084 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0084, if 0x80e10aa5 == stack[-1] label_004C: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x004B, if not 0x80e10aa5 == stack[-1] 004C 5B JUMPDEST 004D 00 *STOP // Stack delta = +0 // Outputs[1] { @004D stop(); } // Block terminates label_004E: // Incoming jump from 0x0040, if 0x4b64e492 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[2] // { // @0055 msg.data.length // @005C msg.data[0x04:0x24] // } 004E 5B JUMPDEST 004F 61 PUSH2 0x0082 0052 60 PUSH1 0x04 0054 80 DUP1 0055 36 CALLDATASIZE 0056 03 SUB 0057 81 DUP2 0058 01 ADD 0059 90 SWAP1 005A 80 DUP1 005B 80 DUP1 005C 35 CALLDATALOAD 005D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0072 16 AND 0073 90 SWAP1 0074 60 PUSH1 0x20 0076 01 ADD 0077 90 SWAP1 0078 92 SWAP3 0079 91 SWAP2 007A 90 SWAP1 007B 50 POP 007C 50 POP 007D 50 POP 007E 61 PUSH2 0x008e 0081 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @004F stack[0] = 0x0082 // @0078 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with unconditional jump to 0x008e 0082 5B JUMPDEST 0083 00 *STOP label_0084: // Incoming jump from 0x004B, if 0x80e10aa5 == stack[-1] 0084 5B JUMPDEST 0085 61 PUSH2 0x008c 0088 61 PUSH2 0x02ee 008B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0085 stack[0] = 0x008c } // Block ends with unconditional jump to 0x02ee 008C 5B JUMPDEST 008D 00 *STOP label_008E: // Incoming jump from 0x0081 008E 5B JUMPDEST 008F 60 PUSH1 0x00 0091 80 DUP1 0092 61 PUSH2 0x0099 0095 61 PUSH2 0x0494 0098 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @008F stack[0] = 0x00 // @0091 stack[1] = 0x00 // @0092 stack[2] = 0x0099 // } // Block ends with call to 0x0494, returns to 0x0099 label_0099: // Incoming return from call to 0x0494 at 0x0098 // Inputs[6] // { // @009E stack[-4] // @00DB memory[0x40:0x60] // @00E1 memory[0x40:0x60] // @0113 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @013E memory[0x40:0x60] // @0142 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0099 5B JUMPDEST 009A 60 PUSH1 0x00 009C 15 ISZERO 009D 15 ISZERO 009E 84 DUP5 009F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00B4 16 AND 00B5 63 PUSH4 0x4b64e492 00BA 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 00D8 02 MUL 00D9 60 PUSH1 0x40 00DB 51 MLOAD 00DC 60 PUSH1 0x24 00DE 01 ADD 00DF 60 PUSH1 0x40 00E1 51 MLOAD 00E2 60 PUSH1 0x20 00E4 81 DUP2 00E5 83 DUP4 00E6 03 SUB 00E7 03 SUB 00E8 81 DUP2 00E9 52 MSTORE 00EA 90 SWAP1 00EB 60 PUSH1 0x40 00ED 52 MSTORE 00EE 90 SWAP1 00EF 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 010C 19 NOT 010D 16 AND 010E 60 PUSH1 0x20 0110 82 DUP3 0111 01 ADD 0112 80 DUP1 0113 51 MLOAD 0114 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0131 83 DUP4 0132 81 DUP2 0133 83 DUP4 0134 16 AND 0135 17 OR 0136 83 DUP4 0137 52 MSTORE 0138 50 POP 0139 50 POP 013A 50 POP 013B 50 POP 013C 60 PUSH1 0x40 013E 51 MLOAD 013F 80 DUP1 0140 82 DUP3 0141 80 DUP1 0142 51 MLOAD 0143 90 SWAP1 0144 60 PUSH1 0x20 0146 01 ADD 0147 90 SWAP1 0148 80 DUP1 0149 83 DUP4 014A 83 DUP4 014B 60 PUSH1 0x00 014D 5B JUMPDEST 014E 83 DUP4 014F 81 DUP2 0150 10 LT 0151 15 ISZERO 0152 61 PUSH2 0x0168 0155 57 *JUMPI // Stack delta = +11 // Outputs[14] // { // @009D stack[0] = !!0x00 // @00B4 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @00E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @00ED memory[0x40:0x60] = 0x24 + memory[0x40:0x60] // @00EE stack[2] = memory[0x40:0x60] // @0137 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | (~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000 * 0x4b64e492) // @013E stack[3] = memory[0x40:0x60] // @013F stack[4] = memory[0x40:0x60] // @0147 stack[5] = 0x20 + memory[0x40:0x60] // @0147 stack[6] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0148 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0149 stack[8] = memory[0x40:0x60] // @014A stack[9] = 0x20 + memory[0x40:0x60] // @014B stack[10] = 0x00 // } // Block ends with conditional jump to 0x0168, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) label_0156: // Incoming jump from 0x0155, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0155, if not !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Inputs[4] // { // @0156 stack[-1] // @0157 stack[-2] // @0159 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @015B stack[-3] // } 0156 80 DUP1 0157 82 DUP3 0158 01 ADD 0159 51 MLOAD 015A 81 DUP2 015B 84 DUP5 015C 01 ADD 015D 52 MSTORE 015E 60 PUSH1 0x20 0160 81 DUP2 0161 01 ADD 0162 90 SWAP1 0163 50 POP 0164 61 PUSH2 0x014d 0167 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @015D memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0162 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x014d label_0168: // Incoming jump from 0x0155, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0155, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Inputs[3] // { // @016D stack[-5] // @016D stack[-6] // @016F stack[-7] // } 0168 5B JUMPDEST 0169 50 POP 016A 50 POP 016B 50 POP 016C 50 POP 016D 90 SWAP1 016E 50 POP 016F 90 SWAP1 0170 81 DUP2 0171 01 ADD 0172 90 SWAP1 0173 60 PUSH1 0x1f 0175 16 AND 0176 80 DUP1 0177 15 ISZERO 0178 61 PUSH2 0x0195 017B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0172 stack[-7] = stack[-5] + stack[-7] // @0175 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0195, if !(0x1f & stack[-5]) label_017C: // Incoming jump from 0x017B, if not !(0x1f & stack[-5]) // Inputs[10] // { // @017C stack[-1] // @017D stack[-2] // @0180 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0197 stack[-4] // @019E memory[0x40:0x60] // @01A3 stack[-5] // @01A4 msg.gas // @01A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @01A5 address(stack[-5]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]) // @01AB stack[-6] // } 017C 80 DUP1 017D 82 DUP3 017E 03 SUB 017F 80 DUP1 0180 51 MLOAD 0181 60 PUSH1 0x01 0183 83 DUP4 0184 60 PUSH1 0x20 0186 03 SUB 0187 61 PUSH2 0x0100 018A 0A EXP 018B 03 SUB 018C 19 NOT 018D 16 AND 018E 81 DUP2 018F 52 MSTORE 0190 60 PUSH1 0x20 0192 01 ADD 0193 91 SWAP2 0194 50 POP 0195 5B JUMPDEST 0196 50 POP 0197 91 SWAP2 0198 50 POP 0199 50 POP 019A 60 PUSH1 0x00 019C 60 PUSH1 0x40 019E 51 MLOAD 019F 80 DUP1 01A0 83 DUP4 01A1 03 SUB 01A2 81 DUP2 01A3 85 DUP6 01A4 5A GAS 01A5 F4 DELEGATECALL 01A6 91 SWAP2 01A7 50 POP 01A8 50 POP 01A9 15 ISZERO 01AA 15 ISZERO 01AB 14 EQ 01AC 15 ISZERO 01AD 15 ISZERO 01AE 61 PUSH2 0x021f 01B1 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @018F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @01A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-5]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x021f, if !!(!!address(stack[-5]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]) == stack[-6]) label_01B2: // Incoming jump from 0x01B1, if not !!(!!address(stack[-5]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-2] - memory[0x40:0x60]]) == stack[-6]) // Incoming jump from 0x01B1, if not !!(!!address(stack[-5]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]) == stack[-6]) // Inputs[3] // { // @01B4 memory[0x40:0x60] // @0219 memory[0x40:0x60] // @021E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01B2 60 PUSH1 0x40 01B4 51 MLOAD 01B5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 01D6 81 DUP2 01D7 52 MSTORE 01D8 60 PUSH1 0x04 01DA 01 ADD 01DB 80 DUP1 01DC 80 DUP1 01DD 60 PUSH1 0x20 01DF 01 ADD 01E0 82 DUP3 01E1 81 DUP2 01E2 03 SUB 01E3 82 DUP3 01E4 52 MSTORE 01E5 60 PUSH1 0x10 01E7 81 DUP2 01E8 52 MSTORE 01E9 60 PUSH1 0x20 01EB 01 ADD 01EC 80 DUP1 01ED 7F PUSH32 0x756e7361666520657865637574696f6e00000000000000000000000000000000 020E 81 DUP2 020F 52 MSTORE 0210 50 POP 0211 60 PUSH1 0x20 0213 01 ADD 0214 91 SWAP2 0215 50 POP 0216 50 POP 0217 60 PUSH1 0x40 0219 51 MLOAD 021A 80 DUP1 021B 91 SWAP2 021C 03 SUB 021D 90 SWAP1 021E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @01D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @01E4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @01E8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x10 // @020F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x756e7361666520657865637574696f6e00000000000000000000000000000000 // @021E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_021F: // Incoming jump from 0x01B1, if !!(!!address(stack[-5]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-2] - memory[0x40:0x60]]) == stack[-6]) // Incoming jump from 0x01B1, if !!(!!address(stack[-5]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]) == stack[-6]) 021F 5B JUMPDEST 0220 61 PUSH2 0x0227 0223 61 PUSH2 0x043d 0226 56 *JUMP // Stack delta = +1 // Outputs[1] { @0220 stack[0] = 0x0227 } // Block ends with call to 0x043d, returns to 0x0227 label_0227: // Incoming return from call to 0x043D at 0x0226 // Inputs[7] // { // @0228 stack[-1] // @0229 stack[-4] // @022B stack[-2] // @022C stack[-5] // @0232 memory[0x40:0x60] // @0260 memory[0x40:0x60] // @0265 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x0e + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0227 5B JUMPDEST 0228 80 DUP1 0229 93 SWAP4 022A 50 POP 022B 81 DUP2 022C 94 SWAP5 022D 50 POP 022E 50 POP 022F 50 POP 0230 60 PUSH1 0x40 0232 51 MLOAD 0233 80 DUP1 0234 80 DUP1 0235 7F PUSH32 0x66696674682875696e7432353629000000000000000000000000000000000000 0256 81 DUP2 0257 52 MSTORE 0258 50 POP 0259 60 PUSH1 0x0e 025B 01 ADD 025C 90 SWAP1 025D 50 POP 025E 60 PUSH1 0x40 0260 51 MLOAD 0261 80 DUP1 0262 91 SWAP2 0263 03 SUB 0264 90 SWAP1 0265 20 SHA3 0266 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0283 19 NOT 0284 16 AND 0285 83 DUP4 0286 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 02A3 19 NOT 02A4 16 AND 02A5 14 EQ 02A6 15 ISZERO 02A7 15 ISZERO 02A8 61 PUSH2 0x02b0 02AB 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @0229 stack[-4] = stack[-1] // @022C stack[-5] = stack[-2] // @0257 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x66696674682875696e7432353629000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x02b0, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-2] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x0e + memory[0x40:0x60]) - memory[0x40:0x60]])) label_02AC: // Incoming jump from 0x02AB, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-2] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x0e + memory[0x40:0x60]) - memory[0x40:0x60]])) // Inputs[1] { @02AF memory[0x00:0x00] } 02AC 60 PUSH1 0x00 02AE 80 DUP1 02AF FD *REVERT // Stack delta = +0 // Outputs[1] { @02AF revert(memory[0x00:0x00]); } // Block terminates label_02B0: // Incoming jump from 0x02AB, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-2] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x0e + memory[0x40:0x60]) - memory[0x40:0x60]])) // Inputs[4] // { // @02B4 stack[-1] // @02D3 stack[-2] // @02D5 memory[stack[-1]:stack[-1] + 0x20] // @02E0 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 02B0 5B JUMPDEST 02B1 61 PUSH2 0x048a 02B4 81 DUP2 02B5 60 PUSH1 0x00 02B7 01 ADD 02B8 90 SWAP1 02B9 67 PUSH8 0xffffffffffffffff 02C2 16 AND 02C3 90 SWAP1 02C4 81 DUP2 02C5 67 PUSH8 0xffffffffffffffff 02CE 16 AND 02CF 81 DUP2 02D0 52 MSTORE 02D1 50 POP 02D2 50 POP 02D3 81 DUP2 02D4 81 DUP2 02D5 51 MLOAD 02D6 03 SUB 02D7 81 DUP2 02D8 52 MSTORE 02D9 61 PUSH2 0x02e8 02DC 81 DUP2 02DD 60 PUSH1 0x00 02DF 01 ADD 02E0 51 MLOAD 02E1 63 PUSH4 0xffffffff 02E6 16 AND 02E7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @02D0 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] = 0xffffffffffffffff & 0xffffffffffffffff & 0x048a // @02D8 memory[stack[-1]:stack[-1] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] - stack[-2] // @02D9 stack[0] = 0x02e8 // } // Block ends with unconditional jump to 0xffffffff & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] 02E8 5B JUMPDEST 02E9 50 POP 02EA 50 POP 02EB 50 POP 02EC 50 POP 02ED 56 *JUMP label_02EE: // Incoming jump from 0x008B // Inputs[2] // { // @02F3 storage[0x00] // @0327 msg.sender // } 02EE 5B JUMPDEST 02EF 60 PUSH1 0x00 02F1 80 DUP1 02F2 90 SWAP1 02F3 54 SLOAD 02F4 90 SWAP1 02F5 61 PUSH2 0x0100 02F8 0A EXP 02F9 90 SWAP1 02FA 04 DIV 02FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0310 16 AND 0311 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0326 16 AND 0327 33 CALLER 0328 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 033D 16 AND 033E 14 EQ 033F 15 ISZERO 0340 15 ISZERO 0341 61 PUSH2 0x0349 0344 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0349, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) label_0345: // Incoming jump from 0x0344, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[1] { @0348 memory[0x00:0x00] } 0345 60 PUSH1 0x00 0347 80 DUP1 0348 FD *REVERT // Stack delta = +0 // Outputs[1] { @0348 revert(memory[0x00:0x00]); } // Block terminates label_0349: // Incoming jump from 0x0344, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[1] { @034C msg.value } 0349 5B JUMPDEST 034A 60 PUSH1 0x01 034C 34 CALLVALUE 034D 14 EQ 034E 15 ISZERO 034F 15 ISZERO 0350 61 PUSH2 0x03c1 0353 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c1, if !!(msg.value == 0x01) label_0354: // Incoming jump from 0x0353, if not !!(msg.value == 0x01) // Inputs[3] // { // @0356 memory[0x40:0x60] // @03BB memory[0x40:0x60] // @03C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0354 60 PUSH1 0x40 0356 51 MLOAD 0357 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0378 81 DUP2 0379 52 MSTORE 037A 60 PUSH1 0x04 037C 01 ADD 037D 80 DUP1 037E 80 DUP1 037F 60 PUSH1 0x20 0381 01 ADD 0382 82 DUP3 0383 81 DUP2 0384 03 SUB 0385 82 DUP3 0386 52 MSTORE 0387 60 PUSH1 0x1b 0389 81 DUP2 038A 52 MSTORE 038B 60 PUSH1 0x20 038D 01 ADD 038E 80 DUP1 038F 7F PUSH32 0x49206f6e6c79206e6565642061206c6974746c65206d6f6e6579210000000000 03B0 81 DUP2 03B1 52 MSTORE 03B2 50 POP 03B3 60 PUSH1 0x20 03B5 01 ADD 03B6 91 SWAP2 03B7 50 POP 03B8 50 POP 03B9 60 PUSH1 0x40 03BB 51 MLOAD 03BC 80 DUP1 03BD 91 SWAP2 03BE 03 SUB 03BF 90 SWAP1 03C0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0379 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0386 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @038A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1b // @03B1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x49206f6e6c79206e6565642061206c6974746c65206d6f6e6579210000000000 // @03C0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_03C1: // Incoming jump from 0x0353, if !!(msg.value == 0x01) // Inputs[5] // { // @03E3 msg.sender // @03E6 memory[0x40:0x60] // @041F memory[0x40:0x60] // @0424 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0425 msg.sender // } 03C1 5B JUMPDEST 03C2 7F PUSH32 0x2d3bd82a572c860ef85a36e8d4873a9deed3f76b9fddbf13fbe4fe8a97c4a579 03E3 33 CALLER 03E4 60 PUSH1 0x40 03E6 51 MLOAD 03E7 80 DUP1 03E8 82 DUP3 03E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03FE 16 AND 03FF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0414 16 AND 0415 81 DUP2 0416 52 MSTORE 0417 60 PUSH1 0x20 0419 01 ADD 041A 91 SWAP2 041B 50 POP 041C 50 POP 041D 60 PUSH1 0x40 041F 51 MLOAD 0420 80 DUP1 0421 91 SWAP2 0422 03 SUB 0423 90 SWAP1 0424 A1 LOG1 0425 33 CALLER 0426 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 043B 16 AND 043C FF *SELFDESTRUCT // Stack delta = +0 // Outputs[3] // { // @0416 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0424 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x2d3bd82a572c860ef85a36e8d4873a9deed3f76b9fddbf13fbe4fe8a97c4a579]); // @043C selfdestruct(0xffffffffffffffffffffffffffffffffffffffff & msg.sender); // } // Block terminates label_043D: // Incoming call from 0x0226, returns to 0x0227 // Inputs[1] { @0443 returndata.length } 043D 5B JUMPDEST 043E 60 PUSH1 0x00 0440 80 DUP1 0441 60 PUSH1 0x24 0443 3D RETURNDATASIZE 0444 14 EQ 0445 15 ISZERO 0446 15 ISZERO 0447 61 PUSH2 0x044f 044A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @043E stack[0] = 0x00 // @0440 stack[1] = 0x00 // } // Block ends with conditional jump to 0x044f, if !!(returndata.length == 0x24) label_044B: // Incoming jump from 0x044A, if not !!(returndata.length == 0x24) // Inputs[1] { @044E memory[0x00:0x00] } 044B 60 PUSH1 0x00 044D 80 DUP1 044E FD *REVERT // Stack delta = +0 // Outputs[1] { @044E revert(memory[0x00:0x00]); } // Block terminates label_044F: // Incoming jump from 0x044A, if !!(returndata.length == 0x24) // Inputs[7] // { // @0452 memory[0x40:0x60] // @0458 returndata[0x00:0x24] // @047B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @047D stack[-2] // @0483 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] // @0484 stack[-1] // @0488 stack[-3] // } 044F 5B JUMPDEST 0450 60 PUSH1 0x40 0452 51 MLOAD 0453 60 PUSH1 0x24 0455 60 PUSH1 0x00 0457 82 DUP3 0458 3E RETURNDATACOPY 0459 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 047A 81 DUP2 047B 51 MLOAD 047C 16 AND 047D 92 SWAP3 047E 50 POP 047F 80 DUP1 0480 60 PUSH1 0x04 0482 01 ADD 0483 51 MLOAD 0484 91 SWAP2 0485 50 POP 0486 50 POP 0487 90 SWAP1 0488 91 SWAP2 0489 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0458 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] = returndata[0x00:0x24] // @0487 stack[-2] = memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] // @0488 stack[-3] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-3] 048A 5B JUMPDEST 048B 61 PUSH2 0x0492 048E 61 PUSH2 0x02ee 0491 56 *JUMP 0492 5B JUMPDEST 0493 56 *JUMP label_0494: // Incoming call from 0x0098, returns to 0x0099 // Inputs[2] // { // @0499 memory[0x40:0x60] // @04A7 stack[-1] // } 0494 5B JUMPDEST 0495 60 PUSH1 0x20 0497 60 PUSH1 0x40 0499 51 MLOAD 049A 90 SWAP1 049B 81 DUP2 049C 01 ADD 049D 60 PUSH1 0x40 049F 52 MSTORE 04A0 80 DUP1 04A1 61 PUSH2 0x04a9 04A4 81 DUP2 04A5 52 MSTORE 04A6 50 POP 04A7 90 SWAP1 04A8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @049F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @04A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x04a9 // @04A7 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] 04A9 5B JUMPDEST 04AA FE *ASSERT 04AB 00 *STOP 04AC A1 LOG1 04AD 65 PUSH6 0x627a7a723058 04B4 20 SHA3 04B5 9E SWAP15 04B6 FD *REVERT 04B7 A9 A9 04B8 63 PUSH4 0x40c6046a 04BD 79 PUSH26 0x1f59d6e47c7102a30046674783f5bad575b2e7dfefe99d0029