Online Solidity Decompiler

« Decompile another contract

Address

0x949a6ac29b9347b3eb9a420272a9dd7890b787a3 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x2a0f7696 Unknown
0x5b6b431d Withdraw(uint256)
0x9f1b3bad Receive()

Internal Methods

func_00CC(arg0) returns (r0)
Withdraw(arg0)
Receive()

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x60; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 == 0x2a0f7696) { // Dispatch table entry for 0x2a0f7696 (unknown) if (msg.value) { revert(memory[0x00:0x00]); } var var1 = 0x0081; var var2 = msg.data[0x04:0x24] & 0xffff; var1 = func_00CC(var2); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var1; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x5b6b431d) { // Dispatch table entry for Withdraw(uint256) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x00c0; var2 = msg.data[0x04:0x24]; Withdraw(var2); stop(); } else if (var0 == 0x9f1b3bad) { // Dispatch table entry for Receive() var1 = 0x00ca; Receive(); stop(); } else { revert(memory[0x00:0x00]); } } function func_00CC(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 & 0xffff != storage[0x01] & 0xffff) { return 0x00; } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x02; return storage[keccak256(memory[0x00:0x40])]; } function Withdraw(var arg0) { if (msg.sender != storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var temp0 = arg0; var temp1 = memory[0x40:0x60]; var temp2; temp2, memory[temp1:temp1 + 0x00] = address(msg.sender).call.gas(!temp0 * 0x08fc).value(temp0)(memory[temp1:temp1 + memory[0x40:0x60] - temp1]); if (temp2) { return; } else { revert(memory[0x00:0x00]); } } function Receive() { var var0 = 0x00; var var1 = var0; var var2 = 0x02; memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = msg.value; var var3 = temp0 + 0x20; var temp1 = memory[0x40:0x60]; var temp2; temp2, memory[temp1:temp1 + 0x20] = address(var2).call.gas(msg.gas - 0x646e)(memory[temp1:temp1 + var3 - temp1]); if (!temp2) { revert(memory[0x00:0x00]); } var temp3 = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] ~ storage[0x01]; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x02; storage[keccak256(memory[0x00:0x40])] = temp3; } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x60 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0057 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x60 } // Block ends with conditional jump to 0x0057, 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 0x2a0f7696 003C 14 EQ 003D 61 PUSH2 0x005c 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x005c, if 0x2a0f7696 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x2a0f7696 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x5b6b431d 0047 14 EQ 0048 61 PUSH2 0x009f 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x009f, if 0x5b6b431d == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x5b6b431d == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x9f1b3bad 0052 14 EQ 0053 61 PUSH2 0x00c2 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c2, if 0x9f1b3bad == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x9f1b3bad == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @005B memory[0x00:0x00] } 0057 5B JUMPDEST 0058 60 PUSH1 0x00 005A 80 DUP1 005B FD *REVERT // Stack delta = +0 // Outputs[1] { @005B revert(memory[0x00:0x00]); } // Block terminates label_005C: // Incoming jump from 0x0040, if 0x2a0f7696 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @005D msg.value } 005C 5B JUMPDEST 005D 34 CALLVALUE 005E 15 ISZERO 005F 61 PUSH2 0x0067 0062 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0067, if !msg.value label_0063: // Incoming jump from 0x0062, if not !msg.value // Inputs[1] { @0066 memory[0x00:0x00] } 0063 60 PUSH1 0x00 0065 80 DUP1 0066 FD *REVERT // Stack delta = +0 // Outputs[1] { @0066 revert(memory[0x00:0x00]); } // Block terminates label_0067: // Incoming jump from 0x0062, if !msg.value // Inputs[1] { @006F msg.data[0x04:0x24] } 0067 5B JUMPDEST 0068 61 PUSH2 0x0081 006B 60 PUSH1 0x04 006D 80 DUP1 006E 80 DUP1 006F 35 CALLDATALOAD 0070 61 PUSH2 0xffff 0073 16 AND 0074 90 SWAP1 0075 60 PUSH1 0x20 0077 01 ADD 0078 90 SWAP1 0079 91 SWAP2 007A 90 SWAP1 007B 50 POP 007C 50 POP 007D 61 PUSH2 0x00cc 0080 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0068 stack[0] = 0x0081 // @0079 stack[1] = 0xffff & msg.data[0x04:0x24] // } // Block ends with call to 0x00cc, returns to 0x0081 label_0081: // Incoming return from call to 0x00CC at 0x0080 // Inputs[4] // { // @0084 memory[0x40:0x60] // @0086 stack[-1] // @0099 memory[0x40:0x60] // @009E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0081 5B JUMPDEST 0082 60 PUSH1 0x40 0084 51 MLOAD 0085 80 DUP1 0086 82 DUP3 0087 60 PUSH1 0x00 0089 19 NOT 008A 16 AND 008B 60 PUSH1 0x00 008D 19 NOT 008E 16 AND 008F 81 DUP2 0090 52 MSTORE 0091 60 PUSH1 0x20 0093 01 ADD 0094 91 SWAP2 0095 50 POP 0096 50 POP 0097 60 PUSH1 0x40 0099 51 MLOAD 009A 80 DUP1 009B 91 SWAP2 009C 03 SUB 009D 90 SWAP1 009E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0090 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-1] // @009E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_009F: // Incoming jump from 0x004B, if 0x5b6b431d == stack[-1] // Inputs[1] { @00A0 msg.value } 009F 5B JUMPDEST 00A0 34 CALLVALUE 00A1 15 ISZERO 00A2 61 PUSH2 0x00aa 00A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00aa, if !msg.value label_00A6: // Incoming jump from 0x00A5, if not !msg.value // Inputs[1] { @00A9 memory[0x00:0x00] } 00A6 60 PUSH1 0x00 00A8 80 DUP1 00A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A9 revert(memory[0x00:0x00]); } // Block terminates label_00AA: // Incoming jump from 0x00A5, if !msg.value // Inputs[1] { @00B2 msg.data[0x04:0x24] } 00AA 5B JUMPDEST 00AB 61 PUSH2 0x00c0 00AE 60 PUSH1 0x04 00B0 80 DUP1 00B1 80 DUP1 00B2 35 CALLDATALOAD 00B3 90 SWAP1 00B4 60 PUSH1 0x20 00B6 01 ADD 00B7 90 SWAP1 00B8 91 SWAP2 00B9 90 SWAP1 00BA 50 POP 00BB 50 POP 00BC 61 PUSH2 0x0138 00BF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @00AB stack[0] = 0x00c0 // @00B8 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x0138, returns to 0x00C0 label_00C0: // Incoming return from call to 0x0138 at 0x00BF 00C0 5B JUMPDEST 00C1 00 *STOP // Stack delta = +0 // Outputs[1] { @00C1 stop(); } // Block terminates label_00C2: // Incoming jump from 0x0056, if 0x9f1b3bad == stack[-1] 00C2 5B JUMPDEST 00C3 61 PUSH2 0x00ca 00C6 61 PUSH2 0x01d6 00C9 56 *JUMP // Stack delta = +1 // Outputs[1] { @00C3 stack[0] = 0x00ca } // Block ends with call to 0x01d6, returns to 0x00CA label_00CA: // Incoming return from call to 0x01D6 at 0x00C9 00CA 5B JUMPDEST 00CB 00 *STOP // Stack delta = +0 // Outputs[1] { @00CB stop(); } // Block terminates label_00CC: // Incoming call from 0x0080, returns to 0x0081 // Inputs[2] // { // @00D1 storage[0x01] // @00DA stack[-1] // } 00CC 5B JUMPDEST 00CD 60 PUSH1 0x00 00CF 60 PUSH1 0x01 00D1 54 SLOAD 00D2 60 PUSH1 0x01 00D4 90 SWAP1 00D5 04 DIV 00D6 61 PUSH2 0xffff 00D9 16 AND 00DA 82 DUP3 00DB 61 PUSH2 0xffff 00DE 16 AND 00DF 14 EQ 00E0 15 ISZERO 00E1 61 PUSH2 0x012b 00E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00CD stack[0] = 0x00 } // Block ends with conditional jump to 0x012b, if !(0xffff & stack[-1] == 0xffff & storage[0x01] / 0x01) label_00E5: // Incoming jump from 0x00E4, if not !(0xffff & stack[-1] == 0xffff & storage[0x01] / 0x01) // Inputs[4] // { // @00E9 msg.sender // @0123 memory[0x00:0x40] // @0124 storage[keccak256(memory[0x00:0x40])] // @0125 stack[-1] // } 00E5 60 PUSH1 0x02 00E7 60 PUSH1 0x00 00E9 33 CALLER 00EA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00FF 16 AND 0100 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0115 16 AND 0116 81 DUP2 0117 52 MSTORE 0118 60 PUSH1 0x20 011A 01 ADD 011B 90 SWAP1 011C 81 DUP2 011D 52 MSTORE 011E 60 PUSH1 0x20 0120 01 ADD 0121 60 PUSH1 0x00 0123 20 SHA3 0124 54 SLOAD 0125 90 SWAP1 0126 50 POP 0127 61 PUSH2 0x0133 012A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0117 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @011D memory[0x20:0x40] = 0x02 // @0125 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x0133 label_012B: // Incoming jump from 0x00E4, if !(0xffff & stack[-1] == 0xffff & storage[0x01] / 0x01) // Inputs[3] // { // @0131 stack[-1] // @0134 stack[-3] // @0135 stack[-2] // } 012B 5B JUMPDEST 012C 60 PUSH1 0x00 012E 60 PUSH1 0x01 0130 02 MUL 0131 90 SWAP1 0132 50 POP 0133 5B JUMPDEST 0134 91 SWAP2 0135 90 SWAP1 0136 50 POP 0137 56 *JUMP // Stack delta = -2 // Outputs[1] { @0134 stack[-3] = 0x01 * 0x00 } // Block ends with unconditional jump to stack[-3] label_0138: // Incoming call from 0x00BF, returns to 0x00C0 // Inputs[2] // { // @013D storage[0x00] // @0171 msg.sender // } 0138 5B JUMPDEST 0139 60 PUSH1 0x00 013B 80 DUP1 013C 90 SWAP1 013D 54 SLOAD 013E 90 SWAP1 013F 61 PUSH2 0x0100 0142 0A EXP 0143 90 SWAP1 0144 04 DIV 0145 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 015A 16 AND 015B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0170 16 AND 0171 33 CALLER 0172 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0187 16 AND 0188 14 EQ 0189 15 ISZERO 018A 15 ISZERO 018B 61 PUSH2 0x0193 018E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0193, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) label_018F: // Incoming jump from 0x018E, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[1] { @0192 memory[0x00:0x00] } 018F 60 PUSH1 0x00 0191 80 DUP1 0192 FD *REVERT // Stack delta = +0 // Outputs[1] { @0192 revert(memory[0x00:0x00]); } // Block terminates label_0193: // Incoming jump from 0x018E, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[6] // { // @0194 msg.sender // @01AE stack[-1] // @01B6 memory[0x40:0x60] // @01BB memory[0x40:0x60] // @01C3 address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @01C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 0193 5B JUMPDEST 0194 33 CALLER 0195 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01AA 16 AND 01AB 61 PUSH2 0x08fc 01AE 82 DUP3 01AF 90 SWAP1 01B0 81 DUP2 01B1 15 ISZERO 01B2 02 MUL 01B3 90 SWAP1 01B4 60 PUSH1 0x40 01B6 51 MLOAD 01B7 60 PUSH1 0x00 01B9 60 PUSH1 0x40 01BB 51 MLOAD 01BC 80 DUP1 01BD 83 DUP4 01BE 03 SUB 01BF 81 DUP2 01C0 85 DUP6 01C1 88 DUP9 01C2 88 DUP9 01C3 F1 CALL 01C4 93 SWAP4 01C5 50 POP 01C6 50 POP 01C7 50 POP 01C8 50 POP 01C9 15 ISZERO 01CA 15 ISZERO 01CB 61 PUSH2 0x01d3 01CE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @01C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) } // Block ends with conditional jump to 0x01d3, if !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_01CF: // Incoming jump from 0x01CE, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @01D2 memory[0x00:0x00] } 01CF 60 PUSH1 0x00 01D1 80 DUP1 01D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D2 revert(memory[0x00:0x00]); } // Block terminates label_01D3: // Incoming jump from 0x01CE, if !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @01D5 stack[-2] } 01D3 5B JUMPDEST 01D4 50 POP 01D5 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_01D6: // Incoming call from 0x00C9, returns to 0x00CA // Inputs[7] // { // @01DC msg.value // @01E1 memory[0x40:0x60] // @01E8 memory[0x40:0x60] // @01F7 memory[0x40:0x60] // @0202 msg.gas // @0204 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0204 address(0x02).call.gas(msg.gas - 0x646e)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 01D6 5B JUMPDEST 01D7 60 PUSH1 0x00 01D9 80 DUP1 01DA 60 PUSH1 0x02 01DC 34 CALLVALUE 01DD 60 PUSH1 0x00 01DF 60 PUSH1 0x40 01E1 51 MLOAD 01E2 60 PUSH1 0x20 01E4 01 ADD 01E5 52 MSTORE 01E6 60 PUSH1 0x40 01E8 51 MLOAD 01E9 80 DUP1 01EA 82 DUP3 01EB 81 DUP2 01EC 52 MSTORE 01ED 60 PUSH1 0x20 01EF 01 ADD 01F0 91 SWAP2 01F1 50 POP 01F2 50 POP 01F3 60 PUSH1 0x20 01F5 60 PUSH1 0x40 01F7 51 MLOAD 01F8 80 DUP1 01F9 83 DUP4 01FA 03 SUB 01FB 81 DUP2 01FC 60 PUSH1 0x00 01FE 86 DUP7 01FF 61 PUSH2 0x646e 0202 5A GAS 0203 03 SUB 0204 F1 CALL 0205 15 ISZERO 0206 15 ISZERO 0207 61 PUSH2 0x020f 020A 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @01D7 stack[0] = 0x00 // @01D9 stack[1] = 0x00 // @01DA stack[2] = 0x02 // @01E5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @01EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.value // @01F0 stack[3] = 0x20 + memory[0x40:0x60] // @0204 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(0x02).call.gas(msg.gas - 0x646e)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x020f, if !!address(0x02).call.gas(msg.gas - 0x646e)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_020B: // Incoming jump from 0x020A, if not !!address(0x02).call.gas(msg.gas - 0x646e)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[1] { @020E memory[0x00:0x00] } 020B 60 PUSH1 0x00 020D 80 DUP1 020E FD *REVERT // Stack delta = +0 // Outputs[1] { @020E revert(memory[0x00:0x00]); } // Block terminates label_020F: // Incoming jump from 0x020A, if !!address(0x02).call.gas(msg.gas - 0x646e)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[8] // { // @0214 memory[0x40:0x60] // @0216 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0219 stack[-4] // @021D storage[0x01] // @0220 stack[-3] // @0227 msg.sender // @0261 memory[0x00:0x40] // @026C stack[-5] // } 020F 5B JUMPDEST 0210 50 POP 0211 50 POP 0212 60 PUSH1 0x40 0214 51 MLOAD 0215 80 DUP1 0216 51 MLOAD 0217 90 SWAP1 0218 50 POP 0219 91 SWAP2 021A 50 POP 021B 60 PUSH1 0x01 021D 54 SLOAD 021E 82 DUP3 021F 18 XOR 0220 90 SWAP1 0221 50 POP 0222 80 DUP1 0223 60 PUSH1 0x02 0225 60 PUSH1 0x00 0227 33 CALLER 0228 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 023D 16 AND 023E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0253 16 AND 0254 81 DUP2 0255 52 MSTORE 0256 60 PUSH1 0x20 0258 01 ADD 0259 90 SWAP1 025A 81 DUP2 025B 52 MSTORE 025C 60 PUSH1 0x20 025E 01 ADD 025F 60 PUSH1 0x00 0261 20 SHA3 0262 81 DUP2 0263 60 PUSH1 0x00 0265 19 NOT 0266 16 AND 0267 90 SWAP1 0268 55 SSTORE 0269 50 POP 026A 50 POP 026B 50 POP 026C 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @0255 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @025B memory[0x20:0x40] = 0x02 // @0268 storage[keccak256(memory[0x00:0x40])] = ~0x00 & (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] ~ storage[0x01]) // } // Block ends with unconditional jump to stack[-5] 026D 00 *STOP 026E A1 LOG1 026F 65 PUSH6 0x627a7a723058 0276 20 SHA3 0277 47 47 0278 60 PUSH1 0xa4 027A FE *ASSERT 027B 70 PUSH17 0x8c70459c1c33c4668609c3f1a8cf0a82d2 028D FC FC 028E 77 PUSH24 0x86c343457dbb55c30029
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]