Online Solidity Decompiler

« Decompile another contract

Address

0x22778878428c001234bc0d9a708d9664045d80bc [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x27e235e3 balances(address)
0x2e1a7d4d withdraw(uint256)
0x70a08231 balanceOf(address)

Internal Methods

donate(arg0, arg1)
balances(arg0, arg2) returns (r0)
withdraw(arg0, arg1)
balanceOf(arg0, arg1) returns (r0)
func_0387(arg0, arg1) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; if (msg.data.length < 0x04) { stop(); } var var0 = msg.data[0x00:0x20] >> 0xe0; if (var0 == 0x362a95) { // Dispatch table entry for donate(address) var var1 = 0x0087; var var2 = 0x04; var var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } donate(var2, var3); stop(); } else if (var0 == 0x27e235e3) { // Dispatch table entry for balances(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00d8; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var2 = balances(var2, var3); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var2; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x2e1a7d4d) { // Dispatch table entry for withdraw(uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0127; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } withdraw(var2, var3); stop(); } else if (var0 == 0x70a08231) { // Dispatch table entry for balanceOf(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0178; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = balanceOf(var2, var3); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = var1; var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + (temp2 + 0x20) - temp3]; } else { stop(); } } function donate(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = 0x01df; memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; var var0 = storage[keccak256(memory[0x00:0x40])]; var var1 = msg.value; arg1 = func_0387(var0, var1); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = arg1; } function balances(var arg0, var arg1) returns (var arg0) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])]; } function withdraw(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (storage[keccak256(memory[0x00:0x40])] < arg0) { label_033C: return; } else { arg1 = 0x00; var var0 = 0x60; var temp0 = memory[0x40:0x60]; var temp1; temp1, memory[temp0:temp0 + 0x00] = address(msg.sender).call.gas(msg.gas).value(arg0)(memory[temp0:temp0 + memory[0x40:0x60] - temp0]); var var2 = returndata.length; var var3 = var2; if (var3 == 0x00) { // Error: StackRead before write??? var var1; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; var temp2 = keccak256(memory[0x00:0x40]); storage[temp2] = storage[temp2] - arg0; goto label_033C; } else { var temp3 = memory[0x40:0x60]; var2 = temp3; memory[0x40:0x60] = var2 + (returndata.length + 0x3f & ~0x1f); memory[var2:var2 + 0x20] = returndata.length; var temp4 = returndata.length; memory[var2 + 0x20:var2 + 0x20 + temp4] = returndata[0x00:0x00 + temp4]; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; var temp5 = keccak256(memory[0x00:0x40]); storage[temp5] = storage[temp5] - arg0; goto label_033C; } } } function balanceOf(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; return storage[keccak256(memory[0x00:0x40])]; } function func_0387(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var temp0 = arg0; var var1 = temp0 + arg1; if (var1 >= temp0) { return var1; } var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp2 = temp1 + 0x04; var temp3 = temp2 + 0x20; memory[temp2:temp2 + 0x20] = temp3 - temp2; memory[temp3:temp3 + 0x20] = 0x1b; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000; var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + (temp4 + 0x20) - temp5]); } }

Disassembly

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 0x0042 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0042, 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 62 PUSH3 0x362a95 0018 14 EQ 0019 61 PUSH2 0x0045 001C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0045, if 0x362a95 == msg.data[0x00:0x20] >> 0xe0 label_001D: // Incoming jump from 0x001C, if not 0x362a95 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001D stack[-1] } 001D 80 DUP1 001E 63 PUSH4 0x27e235e3 0023 14 EQ 0024 61 PUSH2 0x0089 0027 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0089, if 0x27e235e3 == stack[-1] label_0028: // Incoming jump from 0x0027, if not 0x27e235e3 == stack[-1] // Inputs[1] { @0028 stack[-1] } 0028 80 DUP1 0029 63 PUSH4 0x2e1a7d4d 002E 14 EQ 002F 61 PUSH2 0x00ee 0032 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ee, if 0x2e1a7d4d == stack[-1] label_0033: // Incoming jump from 0x0032, if not 0x2e1a7d4d == stack[-1] // Inputs[1] { @0033 stack[-1] } 0033 80 DUP1 0034 63 PUSH4 0x70a08231 0039 14 EQ 003A 61 PUSH2 0x0129 003D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0129, if 0x70a08231 == stack[-1] label_003E: // Incoming jump from 0x003D, if not 0x70a08231 == stack[-1] 003E 61 PUSH2 0x0043 0041 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0043 label_0042: // Incoming jump from 0x000C, if msg.data.length < 0x04 0042 5B JUMPDEST 0043 5B JUMPDEST 0044 00 *STOP // Stack delta = +0 // Outputs[1] { @0044 stop(); } // Block terminates label_0045: // Incoming jump from 0x001C, if 0x362a95 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @004C msg.data.length } 0045 5B JUMPDEST 0046 61 PUSH2 0x0087 0049 60 PUSH1 0x04 004B 80 DUP1 004C 36 CALLDATASIZE 004D 03 SUB 004E 60 PUSH1 0x20 0050 81 DUP2 0051 10 LT 0052 15 ISZERO 0053 61 PUSH2 0x005b 0056 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0046 stack[0] = 0x0087 // @0049 stack[1] = 0x04 // @004D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x005b, returns to 0x0087, if !(msg.data.length - 0x04 < 0x20) label_0057: // Incoming jump from 0x0056, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @005A memory[0x00:0x00] } 0057 60 PUSH1 0x00 0059 80 DUP1 005A FD *REVERT // Stack delta = +0 // Outputs[1] { @005A revert(memory[0x00:0x00]); } // Block terminates label_005B: // Incoming call from 0x0056, returns to 0x0087, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @005C stack[-2] // @005D stack[-1] // @0061 msg.data[stack[-2]:stack[-2] + 0x20] // } 005B 5B JUMPDEST 005C 81 DUP2 005D 01 ADD 005E 90 SWAP1 005F 80 DUP1 0060 80 DUP1 0061 35 CALLDATALOAD 0062 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0077 16 AND 0078 90 SWAP1 0079 60 PUSH1 0x20 007B 01 ADD 007C 90 SWAP1 007D 92 SWAP3 007E 91 SWAP2 007F 90 SWAP1 0080 50 POP 0081 50 POP 0082 50 POP 0083 61 PUSH2 0x018e 0086 56 *JUMP // Stack delta = -1 // Outputs[1] { @007D stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x018e label_0087: // Incoming return from call to 0x005B at 0x0056 0087 5B JUMPDEST 0088 00 *STOP // Stack delta = +0 // Outputs[1] { @0088 stop(); } // Block terminates label_0089: // Incoming jump from 0x0027, if 0x27e235e3 == stack[-1] // Inputs[1] { @008A msg.value } 0089 5B JUMPDEST 008A 34 CALLVALUE 008B 80 DUP1 008C 15 ISZERO 008D 61 PUSH2 0x0095 0090 57 *JUMPI // Stack delta = +1 // Outputs[1] { @008A stack[0] = msg.value } // Block ends with conditional jump to 0x0095, if !msg.value label_0091: // Incoming jump from 0x0090, if not !msg.value // Inputs[1] { @0094 memory[0x00:0x00] } 0091 60 PUSH1 0x00 0093 80 DUP1 0094 FD *REVERT // Stack delta = +0 // Outputs[1] { @0094 revert(memory[0x00:0x00]); } // Block terminates label_0095: // Incoming jump from 0x0090, if !msg.value // Inputs[1] { @009D msg.data.length } 0095 5B JUMPDEST 0096 50 POP 0097 61 PUSH2 0x00d8 009A 60 PUSH1 0x04 009C 80 DUP1 009D 36 CALLDATASIZE 009E 03 SUB 009F 60 PUSH1 0x20 00A1 81 DUP2 00A2 10 LT 00A3 15 ISZERO 00A4 61 PUSH2 0x00ac 00A7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0097 stack[-1] = 0x00d8 // @009A stack[0] = 0x04 // @009E stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00ac, returns to 0x00D8, if !(msg.data.length - 0x04 < 0x20) label_00A8: // Incoming jump from 0x00A7, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @00AB memory[0x00:0x00] } 00A8 60 PUSH1 0x00 00AA 80 DUP1 00AB FD *REVERT // Stack delta = +0 // Outputs[1] { @00AB revert(memory[0x00:0x00]); } // Block terminates label_00AC: // Incoming call from 0x00A7, returns to 0x00D8, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @00AD stack[-2] // @00AE stack[-1] // @00B2 msg.data[stack[-2]:stack[-2] + 0x20] // } 00AC 5B JUMPDEST 00AD 81 DUP2 00AE 01 ADD 00AF 90 SWAP1 00B0 80 DUP1 00B1 80 DUP1 00B2 35 CALLDATALOAD 00B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00C8 16 AND 00C9 90 SWAP1 00CA 60 PUSH1 0x20 00CC 01 ADD 00CD 90 SWAP1 00CE 92 SWAP3 00CF 91 SWAP2 00D0 90 SWAP1 00D1 50 POP 00D2 50 POP 00D3 50 POP 00D4 61 PUSH2 0x0224 00D7 56 *JUMP // Stack delta = -1 // Outputs[1] { @00CE stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0224 label_00D8: // Incoming return from call to 0x00AC at 0x00A7 // Inputs[4] // { // @00DB memory[0x40:0x60] // @00DD stack[-1] // @00E8 memory[0x40:0x60] // @00ED memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00D8 5B JUMPDEST 00D9 60 PUSH1 0x40 00DB 51 MLOAD 00DC 80 DUP1 00DD 82 DUP3 00DE 81 DUP2 00DF 52 MSTORE 00E0 60 PUSH1 0x20 00E2 01 ADD 00E3 91 SWAP2 00E4 50 POP 00E5 50 POP 00E6 60 PUSH1 0x40 00E8 51 MLOAD 00E9 80 DUP1 00EA 91 SWAP2 00EB 03 SUB 00EC 90 SWAP1 00ED F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @00ED return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00EE: // Incoming jump from 0x0032, if 0x2e1a7d4d == stack[-1] // Inputs[1] { @00EF msg.value } 00EE 5B JUMPDEST 00EF 34 CALLVALUE 00F0 80 DUP1 00F1 15 ISZERO 00F2 61 PUSH2 0x00fa 00F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00EF stack[0] = msg.value } // Block ends with conditional jump to 0x00fa, if !msg.value label_00F6: // Incoming jump from 0x00F5, if not !msg.value // Inputs[1] { @00F9 memory[0x00:0x00] } 00F6 60 PUSH1 0x00 00F8 80 DUP1 00F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F9 revert(memory[0x00:0x00]); } // Block terminates label_00FA: // Incoming jump from 0x00F5, if !msg.value // Inputs[1] { @0102 msg.data.length } 00FA 5B JUMPDEST 00FB 50 POP 00FC 61 PUSH2 0x0127 00FF 60 PUSH1 0x04 0101 80 DUP1 0102 36 CALLDATASIZE 0103 03 SUB 0104 60 PUSH1 0x20 0106 81 DUP2 0107 10 LT 0108 15 ISZERO 0109 61 PUSH2 0x0111 010C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @00FC stack[-1] = 0x0127 // @00FF stack[0] = 0x04 // @0103 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0111, returns to 0x0127, if !(msg.data.length - 0x04 < 0x20) label_010D: // Incoming jump from 0x010C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0110 memory[0x00:0x00] } 010D 60 PUSH1 0x00 010F 80 DUP1 0110 FD *REVERT // Stack delta = +0 // Outputs[1] { @0110 revert(memory[0x00:0x00]); } // Block terminates label_0111: // Incoming call from 0x010C, returns to 0x0127, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0112 stack[-2] // @0113 stack[-1] // @0117 msg.data[stack[-2]:stack[-2] + 0x20] // } 0111 5B JUMPDEST 0112 81 DUP2 0113 01 ADD 0114 90 SWAP1 0115 80 DUP1 0116 80 DUP1 0117 35 CALLDATALOAD 0118 90 SWAP1 0119 60 PUSH1 0x20 011B 01 ADD 011C 90 SWAP1 011D 92 SWAP3 011E 91 SWAP2 011F 90 SWAP1 0120 50 POP 0121 50 POP 0122 50 POP 0123 61 PUSH2 0x023c 0126 56 *JUMP // Stack delta = -1 // Outputs[1] { @011D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x023c label_0127: // Incoming return from call to 0x0111 at 0x010C 0127 5B JUMPDEST 0128 00 *STOP // Stack delta = +0 // Outputs[1] { @0128 stop(); } // Block terminates label_0129: // Incoming jump from 0x003D, if 0x70a08231 == stack[-1] // Inputs[1] { @012A msg.value } 0129 5B JUMPDEST 012A 34 CALLVALUE 012B 80 DUP1 012C 15 ISZERO 012D 61 PUSH2 0x0135 0130 57 *JUMPI // Stack delta = +1 // Outputs[1] { @012A stack[0] = msg.value } // Block ends with conditional jump to 0x0135, if !msg.value label_0131: // Incoming jump from 0x0130, if not !msg.value // Inputs[1] { @0134 memory[0x00:0x00] } 0131 60 PUSH1 0x00 0133 80 DUP1 0134 FD *REVERT // Stack delta = +0 // Outputs[1] { @0134 revert(memory[0x00:0x00]); } // Block terminates label_0135: // Incoming jump from 0x0130, if !msg.value // Inputs[1] { @013D msg.data.length } 0135 5B JUMPDEST 0136 50 POP 0137 61 PUSH2 0x0178 013A 60 PUSH1 0x04 013C 80 DUP1 013D 36 CALLDATASIZE 013E 03 SUB 013F 60 PUSH1 0x20 0141 81 DUP2 0142 10 LT 0143 15 ISZERO 0144 61 PUSH2 0x014c 0147 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0137 stack[-1] = 0x0178 // @013A stack[0] = 0x04 // @013E stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x014c, returns to 0x0178, if !(msg.data.length - 0x04 < 0x20) label_0148: // Incoming jump from 0x0147, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @014B memory[0x00:0x00] } 0148 60 PUSH1 0x00 014A 80 DUP1 014B FD *REVERT // Stack delta = +0 // Outputs[1] { @014B revert(memory[0x00:0x00]); } // Block terminates label_014C: // Incoming call from 0x0147, returns to 0x0178, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @014D stack[-2] // @014E stack[-1] // @0152 msg.data[stack[-2]:stack[-2] + 0x20] // } 014C 5B JUMPDEST 014D 81 DUP2 014E 01 ADD 014F 90 SWAP1 0150 80 DUP1 0151 80 DUP1 0152 35 CALLDATALOAD 0153 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0168 16 AND 0169 90 SWAP1 016A 60 PUSH1 0x20 016C 01 ADD 016D 90 SWAP1 016E 92 SWAP3 016F 91 SWAP2 0170 90 SWAP1 0171 50 POP 0172 50 POP 0173 50 POP 0174 61 PUSH2 0x033f 0177 56 *JUMP // Stack delta = -1 // Outputs[1] { @016E stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x033f label_0178: // Incoming return from call to 0x014C at 0x0147 // Inputs[4] // { // @017B memory[0x40:0x60] // @017D stack[-1] // @0188 memory[0x40:0x60] // @018D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0178 5B JUMPDEST 0179 60 PUSH1 0x40 017B 51 MLOAD 017C 80 DUP1 017D 82 DUP3 017E 81 DUP2 017F 52 MSTORE 0180 60 PUSH1 0x20 0182 01 ADD 0183 91 SWAP2 0184 50 POP 0185 50 POP 0186 60 PUSH1 0x40 0188 51 MLOAD 0189 80 DUP1 018A 91 SWAP2 018B 03 SUB 018C 90 SWAP1 018D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @017F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @018D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_018E: // Incoming jump from 0x0086 // Inputs[4] // { // @0192 msg.value // @0196 stack[-1] // @01D0 memory[0x00:0x40] // @01D1 storage[keccak256(memory[0x00:0x40])] // } 018E 5B JUMPDEST 018F 61 PUSH2 0x01df 0192 34 CALLVALUE 0193 60 PUSH1 0x00 0195 80 DUP1 0196 84 DUP5 0197 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01AC 16 AND 01AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01C2 16 AND 01C3 81 DUP2 01C4 52 MSTORE 01C5 60 PUSH1 0x20 01C7 01 ADD 01C8 90 SWAP1 01C9 81 DUP2 01CA 52 MSTORE 01CB 60 PUSH1 0x20 01CD 01 ADD 01CE 60 PUSH1 0x00 01D0 20 SHA3 01D1 54 SLOAD 01D2 61 PUSH2 0x0387 01D5 90 SWAP1 01D6 91 SWAP2 01D7 90 SWAP1 01D8 63 PUSH4 0xffffffff 01DD 16 AND 01DE 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @018F stack[0] = 0x01df // @01C4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @01CA memory[0x20:0x40] = 0x00 // @01D6 stack[1] = storage[keccak256(memory[0x00:0x40])] // @01D7 stack[2] = msg.value // } // Block ends with call to 0xffffffff & 0x0387, returns to 0x01DF label_01DF: // Incoming return from call to 0x0387 at 0x01DE // Inputs[4] // { // @01E3 stack[-2] // @021D memory[0x00:0x40] // @021E stack[-1] // @0223 stack[-3] // } 01DF 5B JUMPDEST 01E0 60 PUSH1 0x00 01E2 80 DUP1 01E3 83 DUP4 01E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01F9 16 AND 01FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 020F 16 AND 0210 81 DUP2 0211 52 MSTORE 0212 60 PUSH1 0x20 0214 01 ADD 0215 90 SWAP1 0216 81 DUP2 0217 52 MSTORE 0218 60 PUSH1 0x20 021A 01 ADD 021B 60 PUSH1 0x00 021D 20 SHA3 021E 81 DUP2 021F 90 SWAP1 0220 55 SSTORE 0221 50 POP 0222 50 POP 0223 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0211 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0217 memory[0x20:0x40] = 0x00 // @0220 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_0224: // Incoming jump from 0x00D7 // Inputs[4] // { // @022A stack[-1] // @0232 memory[0x00:0x40] // @0239 storage[keccak256(memory[0x00:0x40])] // @023A stack[-2] // } 0224 5B JUMPDEST 0225 60 PUSH1 0x00 0227 60 PUSH1 0x20 0229 52 MSTORE 022A 80 DUP1 022B 60 PUSH1 0x00 022D 52 MSTORE 022E 60 PUSH1 0x40 0230 60 PUSH1 0x00 0232 20 SHA3 0233 60 PUSH1 0x00 0235 91 SWAP2 0236 50 POP 0237 90 SWAP1 0238 50 POP 0239 54 SLOAD 023A 81 DUP2 023B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0229 memory[0x20:0x40] = 0x00 // @022D memory[0x00:0x20] = stack[-1] // @0239 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_023C: // Incoming jump from 0x0126 // Inputs[4] // { // @023D stack[-1] // @0241 msg.sender // @027B memory[0x00:0x40] // @027C storage[keccak256(memory[0x00:0x40])] // } 023C 5B JUMPDEST 023D 80 DUP1 023E 60 PUSH1 0x00 0240 80 DUP1 0241 33 CALLER 0242 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0257 16 AND 0258 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 026D 16 AND 026E 81 DUP2 026F 52 MSTORE 0270 60 PUSH1 0x20 0272 01 ADD 0273 90 SWAP1 0274 81 DUP2 0275 52 MSTORE 0276 60 PUSH1 0x20 0278 01 ADD 0279 60 PUSH1 0x00 027B 20 SHA3 027C 54 SLOAD 027D 10 LT 027E 61 PUSH2 0x033c 0281 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @026F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0275 memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x033c, if storage[keccak256(memory[0x00:0x40])] < stack[-1] label_0282: // Incoming jump from 0x0281, if not storage[keccak256(memory[0x00:0x40])] < stack[-1] // Inputs[8] // { // @0286 msg.sender // @029D stack[-1] // @02A0 memory[0x40:0x60] // @02AB memory[0x40:0x60] // @02B2 msg.gas // @02B3 address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x00 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @02B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x00 + memory[0x40:0x60]) - memory[0x40:0x60]] // @02B8 returndata.length // } 0282 60 PUSH1 0x00 0284 60 PUSH1 0x60 0286 33 CALLER 0287 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 029C 16 AND 029D 83 DUP4 029E 60 PUSH1 0x40 02A0 51 MLOAD 02A1 80 DUP1 02A2 60 PUSH1 0x00 02A4 01 ADD 02A5 90 SWAP1 02A6 50 POP 02A7 60 PUSH1 0x00 02A9 60 PUSH1 0x40 02AB 51 MLOAD 02AC 80 DUP1 02AD 83 DUP4 02AE 03 SUB 02AF 81 DUP2 02B0 85 DUP6 02B1 87 DUP8 02B2 5A GAS 02B3 F1 CALL 02B4 92 SWAP3 02B5 50 POP 02B6 50 POP 02B7 50 POP 02B8 3D RETURNDATASIZE 02B9 80 DUP1 02BA 60 PUSH1 0x00 02BC 81 DUP2 02BD 14 EQ 02BE 61 PUSH2 0x02e3 02C1 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @0282 stack[0] = 0x00 // @0284 stack[1] = 0x60 // @02B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x00 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @02B4 stack[2] = address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x00 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @02B8 stack[3] = returndata.length // @02B9 stack[4] = returndata.length // } // Block ends with conditional jump to 0x02e3, if returndata.length == 0x00 label_02C2: // Incoming jump from 0x02C1, if not returndata.length == 0x00 // Inputs[6] // { // @02C4 memory[0x40:0x60] // @02C5 stack[-2] // @02CC returndata.length // @02D4 returndata.length // @02D7 returndata.length // @02DE returndata[0x00:0x00 + returndata.length] // } 02C2 60 PUSH1 0x40 02C4 51 MLOAD 02C5 91 SWAP2 02C6 50 POP 02C7 60 PUSH1 0x1f 02C9 19 NOT 02CA 60 PUSH1 0x3f 02CC 3D RETURNDATASIZE 02CD 01 ADD 02CE 16 AND 02CF 82 DUP3 02D0 01 ADD 02D1 60 PUSH1 0x40 02D3 52 MSTORE 02D4 3D RETURNDATASIZE 02D5 82 DUP3 02D6 52 MSTORE 02D7 3D RETURNDATASIZE 02D8 60 PUSH1 0x00 02DA 60 PUSH1 0x20 02DC 84 DUP5 02DD 01 ADD 02DE 3E RETURNDATACOPY 02DF 61 PUSH2 0x02e8 02E2 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @02C5 stack[-2] = memory[0x40:0x60] // @02D3 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @02D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @02DE memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x02e8 label_02E3: // Incoming jump from 0x02C1, if returndata.length == 0x00 // Inputs[8] // { // @02E6 stack[-2] // @02EA stack[-4] // @02EC stack[-3] // @02EC stack[-5] // @02EE stack[-6] // @02F2 msg.sender // @032C memory[0x00:0x40] // @0331 storage[keccak256(memory[0x00:0x40])] // } 02E3 5B JUMPDEST 02E4 60 PUSH1 0x60 02E6 91 SWAP2 02E7 50 POP 02E8 5B JUMPDEST 02E9 50 POP 02EA 91 SWAP2 02EB 50 POP 02EC 91 SWAP2 02ED 50 POP 02EE 82 DUP3 02EF 60 PUSH1 0x00 02F1 80 DUP1 02F2 33 CALLER 02F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0308 16 AND 0309 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 031E 16 AND 031F 81 DUP2 0320 52 MSTORE 0321 60 PUSH1 0x20 0323 01 ADD 0324 90 SWAP1 0325 81 DUP2 0326 52 MSTORE 0327 60 PUSH1 0x20 0329 01 ADD 032A 60 PUSH1 0x00 032C 20 SHA3 032D 60 PUSH1 0x00 032F 82 DUP3 0330 82 DUP3 0331 54 SLOAD 0332 03 SUB 0333 92 SWAP3 0334 50 POP 0335 50 POP 0336 81 DUP2 0337 90 SWAP1 0338 55 SSTORE 0339 50 POP 033A 50 POP 033B 50 POP // Stack delta = -5 // Outputs[3] // { // @0320 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0326 memory[0x20:0x40] = 0x00 // @0338 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-6] // } // Block continues label_033C: // Incoming jump from 0x033B // Incoming jump from 0x033B // Incoming jump from 0x0281, if storage[keccak256(memory[0x00:0x40])] < stack[-1] // Inputs[1] { @033E stack[-2] } 033C 5B JUMPDEST 033D 50 POP 033E 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_033F: // Incoming jump from 0x0177 // Inputs[4] // { // @0345 stack[-1] // @037F memory[0x00:0x40] // @0380 storage[keccak256(memory[0x00:0x40])] // @0383 stack[-2] // } 033F 5B JUMPDEST 0340 60 PUSH1 0x00 0342 80 DUP1 0343 60 PUSH1 0x00 0345 83 DUP4 0346 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 035B 16 AND 035C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0371 16 AND 0372 81 DUP2 0373 52 MSTORE 0374 60 PUSH1 0x20 0376 01 ADD 0377 90 SWAP1 0378 81 DUP2 0379 52 MSTORE 037A 60 PUSH1 0x20 037C 01 ADD 037D 60 PUSH1 0x00 037F 20 SHA3 0380 54 SLOAD 0381 90 SWAP1 0382 50 POP 0383 91 SWAP2 0384 90 SWAP1 0385 50 POP 0386 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0373 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0379 memory[0x20:0x40] = 0x00 // @0383 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0387: // Incoming call from 0x01DE, returns to 0x01DF // Inputs[2] // { // @038B stack[-1] // @038C stack[-2] // } 0387 5B JUMPDEST 0388 60 PUSH1 0x00 038A 80 DUP1 038B 82 DUP3 038C 84 DUP5 038D 01 ADD 038E 90 SWAP1 038F 50 POP 0390 83 DUP4 0391 81 DUP2 0392 10 LT 0393 15 ISZERO 0394 61 PUSH2 0x0405 0397 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0388 stack[0] = 0x00 // @038E stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x0405, if !(stack[-2] + stack[-1] < stack[-2]) label_0398: // Incoming jump from 0x0397, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @039A memory[0x40:0x60] // @03FF memory[0x40:0x60] // @0404 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0398 60 PUSH1 0x40 039A 51 MLOAD 039B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 03BC 81 DUP2 03BD 52 MSTORE 03BE 60 PUSH1 0x04 03C0 01 ADD 03C1 80 DUP1 03C2 80 DUP1 03C3 60 PUSH1 0x20 03C5 01 ADD 03C6 82 DUP3 03C7 81 DUP2 03C8 03 SUB 03C9 82 DUP3 03CA 52 MSTORE 03CB 60 PUSH1 0x1b 03CD 81 DUP2 03CE 52 MSTORE 03CF 60 PUSH1 0x20 03D1 01 ADD 03D2 80 DUP1 03D3 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 03F4 81 DUP2 03F5 52 MSTORE 03F6 50 POP 03F7 60 PUSH1 0x20 03F9 01 ADD 03FA 91 SWAP2 03FB 50 POP 03FC 50 POP 03FD 60 PUSH1 0x40 03FF 51 MLOAD 0400 80 DUP1 0401 91 SWAP2 0402 03 SUB 0403 90 SWAP1 0404 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @03BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @03CA memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @03CE memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1b // @03F5 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @0404 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0405: // Incoming jump from 0x0397, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @0406 stack[-1] // @0407 stack[-2] // @040A stack[-5] // @040B stack[-4] // } 0405 5B JUMPDEST 0406 80 DUP1 0407 91 SWAP2 0408 50 POP 0409 50 POP 040A 92 SWAP3 040B 91 SWAP2 040C 50 POP 040D 50 POP 040E 56 *JUMP // Stack delta = -4 // Outputs[1] { @040A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 040F FE *ASSERT 0410 A2 LOG2 0411 64 PUSH5 0x6970667358 0417 22 22 0418 12 SLT 0419 20 SHA3 041A C4 C4 041B 3E RETURNDATACOPY 041C B0 PUSH 041D 0F 0F 041E DB DB 041F 1A BYTE 0420 AC AC 0421 83 DUP4 0422 82 DUP3 0423 17 OR 0424 57 *JUMPI 0425 E1 E1 0426 36 CALLDATASIZE 0427 16 AND 0428 6D PUSH14 0xd020118197c411f63acfa6b8caa7 0437 6C PUSH13 0x534964736f6c63430006030033
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]