Online Solidity Decompiler

« Decompile another contract

Address

0x6c0cdee7a6e6ef6b82f168608985e146c01fb09c [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x27e235e3 balances(address)
0x44df8e70 burn()
0x61cb5a01 testString(string)
0x8da5cb5b owner()
0xbee8a5f8 Unknown
0xcbfc4bce gift(address)

Internal Methods

balances(arg1) returns (r0)
burn()
testString(arg0)
owner(arg0) returns (r0)
func_02DE(arg0, arg1, arg2)
gift(arg0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 == 0x27e235e3) { // Dispatch table entry for balances(address) var var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00be; var var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var2 = balances(var2); 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 == 0x44df8e70) { // Dispatch table entry for burn() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00e9; burn(); stop(); } else if (var0 == 0x61cb5a01) { // Dispatch table entry for testString(string) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0152; var temp2 = msg.data[0x04:0x24] + 0x04; var temp3 = msg.data[temp2:temp2 + 0x20]; var temp4 = memory[0x40:0x60]; memory[0x40:0x60] = temp4 + (temp3 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp4:temp4 + 0x20] = temp3; memory[temp4 + 0x20:temp4 + 0x20 + temp3] = msg.data[temp2 + 0x20:temp2 + 0x20 + temp3]; var2 = temp4; testString(var2); stop(); } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0169; var2 = owner(); var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff; var temp6 = memory[0x40:0x60]; return memory[temp6:temp6 + (temp5 + 0x20) - temp6]; } else if (var0 == 0xbee8a5f8) { // Dispatch table entry for 0xbee8a5f8 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0202; var2 = !!msg.data[0x04:0x24]; var var3 = msg.data[0x24:0x44] & 0xffffffffffffffffffffffffffffffffffffffff; var var4 = msg.data[0x44:0x64]; func_02DE(var2, var3, var4); stop(); } else if (var0 == 0xcbfc4bce) { // Dispatch table entry for gift(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0245; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; gift(var2); stop(); } else { revert(memory[0x00:0x00]); } } function balances(var arg0) returns (var arg0) { memory[0x20:0x40] = 0x01; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])]; } function burn() { memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x01; var temp0 = keccak256(memory[0x00:0x40]); storage[temp0] = storage[temp0] - 0x0de0b6b3a7640000; } function testString(var arg0) {} function owner() returns (var r0) { return storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_02DE(var arg0, var arg1, var arg2) {} function gift(var arg0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x01; var temp0 = keccak256(memory[0x00:0x40]); storage[temp0] = storage[temp0] + 0x0de0b6b3a7640000; } }

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 0x0078 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0078, 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 0x27e235e3 003C 14 EQ 003D 61 PUSH2 0x007d 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x007d, if 0x27e235e3 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x27e235e3 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x44df8e70 0047 14 EQ 0048 61 PUSH2 0x00d4 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d4, if 0x44df8e70 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x44df8e70 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x61cb5a01 0052 14 EQ 0053 61 PUSH2 0x00eb 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00eb, if 0x61cb5a01 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x61cb5a01 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x8da5cb5b 005D 14 EQ 005E 61 PUSH2 0x0154 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0154, if 0x8da5cb5b == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xbee8a5f8 0068 14 EQ 0069 61 PUSH2 0x01ab 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ab, if 0xbee8a5f8 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xbee8a5f8 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xcbfc4bce 0073 14 EQ 0074 61 PUSH2 0x0204 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0204, if 0xcbfc4bce == stack[-1] label_0078: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0077, if not 0xcbfc4bce == stack[-1] // Inputs[1] { @007C memory[0x00:0x00] } 0078 5B JUMPDEST 0079 60 PUSH1 0x00 007B 80 DUP1 007C FD *REVERT // Stack delta = +0 // Outputs[1] { @007C revert(memory[0x00:0x00]); } // Block terminates label_007D: // Incoming jump from 0x0040, if 0x27e235e3 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @007E msg.value } 007D 5B JUMPDEST 007E 34 CALLVALUE 007F 80 DUP1 0080 15 ISZERO 0081 61 PUSH2 0x0089 0084 57 *JUMPI // Stack delta = +1 // Outputs[1] { @007E stack[0] = msg.value } // Block ends with conditional jump to 0x0089, if !msg.value label_0085: // Incoming jump from 0x0084, if not !msg.value // Inputs[1] { @0088 memory[0x00:0x00] } 0085 60 PUSH1 0x00 0087 80 DUP1 0088 FD *REVERT // Stack delta = +0 // Outputs[1] { @0088 revert(memory[0x00:0x00]); } // Block terminates label_0089: // Incoming jump from 0x0084, if !msg.value // Inputs[2] // { // @0091 msg.data.length // @0098 msg.data[0x04:0x24] // } 0089 5B JUMPDEST 008A 50 POP 008B 61 PUSH2 0x00be 008E 60 PUSH1 0x04 0090 80 DUP1 0091 36 CALLDATASIZE 0092 03 SUB 0093 81 DUP2 0094 01 ADD 0095 90 SWAP1 0096 80 DUP1 0097 80 DUP1 0098 35 CALLDATALOAD 0099 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00AE 16 AND 00AF 90 SWAP1 00B0 60 PUSH1 0x20 00B2 01 ADD 00B3 90 SWAP1 00B4 92 SWAP3 00B5 91 SWAP2 00B6 90 SWAP1 00B7 50 POP 00B8 50 POP 00B9 50 POP 00BA 61 PUSH2 0x0247 00BD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @008B stack[-1] = 0x00be // @00B4 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0247, returns to 0x00BE label_00BE: // Incoming return from call to 0x0247 at 0x00BD // Inputs[4] // { // @00C1 memory[0x40:0x60] // @00C3 stack[-1] // @00CE memory[0x40:0x60] // @00D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00BE 5B JUMPDEST 00BF 60 PUSH1 0x40 00C1 51 MLOAD 00C2 80 DUP1 00C3 82 DUP3 00C4 81 DUP2 00C5 52 MSTORE 00C6 60 PUSH1 0x20 00C8 01 ADD 00C9 91 SWAP2 00CA 50 POP 00CB 50 POP 00CC 60 PUSH1 0x40 00CE 51 MLOAD 00CF 80 DUP1 00D0 91 SWAP2 00D1 03 SUB 00D2 90 SWAP1 00D3 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @00D3 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00D4: // Incoming jump from 0x004B, if 0x44df8e70 == stack[-1] // Inputs[1] { @00D5 msg.value } 00D4 5B JUMPDEST 00D5 34 CALLVALUE 00D6 80 DUP1 00D7 15 ISZERO 00D8 61 PUSH2 0x00e0 00DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00D5 stack[0] = msg.value } // Block ends with conditional jump to 0x00e0, if !msg.value label_00DC: // Incoming jump from 0x00DB, if not !msg.value // Inputs[1] { @00DF memory[0x00:0x00] } 00DC 60 PUSH1 0x00 00DE 80 DUP1 00DF FD *REVERT // Stack delta = +0 // Outputs[1] { @00DF revert(memory[0x00:0x00]); } // Block terminates label_00E0: // Incoming jump from 0x00DB, if !msg.value 00E0 5B JUMPDEST 00E1 50 POP 00E2 61 PUSH2 0x00e9 00E5 61 PUSH2 0x025f 00E8 56 *JUMP // Stack delta = +0 // Outputs[1] { @00E2 stack[-1] = 0x00e9 } // Block ends with call to 0x025f, returns to 0x00E9 label_00E9: // Incoming return from call to 0x025F at 0x00E8 00E9 5B JUMPDEST 00EA 00 *STOP // Stack delta = +0 // Outputs[1] { @00EA stop(); } // Block terminates label_00EB: // Incoming jump from 0x0056, if 0x61cb5a01 == stack[-1] // Inputs[1] { @00EC msg.value } 00EB 5B JUMPDEST 00EC 34 CALLVALUE 00ED 80 DUP1 00EE 15 ISZERO 00EF 61 PUSH2 0x00f7 00F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00EC stack[0] = msg.value } // Block ends with conditional jump to 0x00f7, if !msg.value label_00F3: // Incoming jump from 0x00F2, if not !msg.value // Inputs[1] { @00F6 memory[0x00:0x00] } 00F3 60 PUSH1 0x00 00F5 80 DUP1 00F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F6 revert(memory[0x00:0x00]); } // Block terminates label_00F7: // Incoming jump from 0x00F2, if !msg.value // Inputs[5] // { // @00FF msg.data.length // @0106 msg.data[0x04:0x24] // @010F msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @0125 memory[0x40:0x60] // @013C msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 00F7 5B JUMPDEST 00F8 50 POP 00F9 61 PUSH2 0x0152 00FC 60 PUSH1 0x04 00FE 80 DUP1 00FF 36 CALLDATASIZE 0100 03 SUB 0101 81 DUP2 0102 01 ADD 0103 90 SWAP1 0104 80 DUP1 0105 80 DUP1 0106 35 CALLDATALOAD 0107 90 SWAP1 0108 60 PUSH1 0x20 010A 01 ADD 010B 90 SWAP1 010C 82 DUP3 010D 01 ADD 010E 80 DUP1 010F 35 CALLDATALOAD 0110 90 SWAP1 0111 60 PUSH1 0x20 0113 01 ADD 0114 90 SWAP1 0115 80 DUP1 0116 80 DUP1 0117 60 PUSH1 0x1f 0119 01 ADD 011A 60 PUSH1 0x20 011C 80 DUP1 011D 91 SWAP2 011E 04 DIV 011F 02 MUL 0120 60 PUSH1 0x20 0122 01 ADD 0123 60 PUSH1 0x40 0125 51 MLOAD 0126 90 SWAP1 0127 81 DUP2 0128 01 ADD 0129 60 PUSH1 0x40 012B 52 MSTORE 012C 80 DUP1 012D 93 SWAP4 012E 92 SWAP3 012F 91 SWAP2 0130 90 SWAP1 0131 81 DUP2 0132 81 DUP2 0133 52 MSTORE 0134 60 PUSH1 0x20 0136 01 ADD 0137 83 DUP4 0138 83 DUP4 0139 80 DUP1 013A 82 DUP3 013B 84 DUP5 013C 37 CALLDATACOPY 013D 82 DUP3 013E 01 ADD 013F 91 SWAP2 0140 50 POP 0141 50 POP 0142 50 POP 0143 50 POP 0144 50 POP 0145 50 POP 0146 91 SWAP2 0147 92 SWAP3 0148 91 SWAP2 0149 92 SWAP3 014A 90 SWAP1 014B 50 POP 014C 50 POP 014D 50 POP 014E 61 PUSH2 0x02b6 0151 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @00F9 stack[-1] = 0x0152 // @012B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20 // @0133 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @013C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @0149 stack[0] = memory[0x40:0x60] // } // Block ends with call to 0x02b6, returns to 0x0152 label_0152: // Incoming return from call to 0x02B6 at 0x0151 0152 5B JUMPDEST 0153 00 *STOP // Stack delta = +0 // Outputs[1] { @0153 stop(); } // Block terminates label_0154: // Incoming jump from 0x0061, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0155 msg.value } 0154 5B JUMPDEST 0155 34 CALLVALUE 0156 80 DUP1 0157 15 ISZERO 0158 61 PUSH2 0x0160 015B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0155 stack[0] = msg.value } // Block ends with conditional jump to 0x0160, if !msg.value label_015C: // Incoming jump from 0x015B, if not !msg.value // Inputs[1] { @015F memory[0x00:0x00] } 015C 60 PUSH1 0x00 015E 80 DUP1 015F FD *REVERT // Stack delta = +0 // Outputs[1] { @015F revert(memory[0x00:0x00]); } // Block terminates label_0160: // Incoming jump from 0x015B, if !msg.value 0160 5B JUMPDEST 0161 50 POP 0162 61 PUSH2 0x0169 0165 61 PUSH2 0x02b9 0168 56 *JUMP // Stack delta = +0 // Outputs[1] { @0162 stack[-1] = 0x0169 } // Block ends with call to 0x02b9, returns to 0x0169 label_0169: // Incoming return from call to 0x02B9 at 0x0168 // Inputs[4] // { // @016C memory[0x40:0x60] // @016E stack[-1] // @01A5 memory[0x40:0x60] // @01AA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0169 5B JUMPDEST 016A 60 PUSH1 0x40 016C 51 MLOAD 016D 80 DUP1 016E 82 DUP3 016F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0184 16 AND 0185 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 019A 16 AND 019B 81 DUP2 019C 52 MSTORE 019D 60 PUSH1 0x20 019F 01 ADD 01A0 91 SWAP2 01A1 50 POP 01A2 50 POP 01A3 60 PUSH1 0x40 01A5 51 MLOAD 01A6 80 DUP1 01A7 91 SWAP2 01A8 03 SUB 01A9 90 SWAP1 01AA F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @019C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @01AA return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01AB: // Incoming jump from 0x006C, if 0xbee8a5f8 == stack[-1] // Inputs[1] { @01AC msg.value } 01AB 5B JUMPDEST 01AC 34 CALLVALUE 01AD 80 DUP1 01AE 15 ISZERO 01AF 61 PUSH2 0x01b7 01B2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01AC stack[0] = msg.value } // Block ends with conditional jump to 0x01b7, if !msg.value label_01B3: // Incoming jump from 0x01B2, if not !msg.value // Inputs[1] { @01B6 memory[0x00:0x00] } 01B3 60 PUSH1 0x00 01B5 80 DUP1 01B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B6 revert(memory[0x00:0x00]); } // Block terminates label_01B7: // Incoming jump from 0x01B2, if !msg.value // Inputs[4] // { // @01BF msg.data.length // @01C6 msg.data[0x04:0x24] // @01D2 msg.data[0x24:0x44] // @01F2 msg.data[0x44:0x64] // } 01B7 5B JUMPDEST 01B8 50 POP 01B9 61 PUSH2 0x0202 01BC 60 PUSH1 0x04 01BE 80 DUP1 01BF 36 CALLDATASIZE 01C0 03 SUB 01C1 81 DUP2 01C2 01 ADD 01C3 90 SWAP1 01C4 80 DUP1 01C5 80 DUP1 01C6 35 CALLDATALOAD 01C7 15 ISZERO 01C8 15 ISZERO 01C9 90 SWAP1 01CA 60 PUSH1 0x20 01CC 01 ADD 01CD 90 SWAP1 01CE 92 SWAP3 01CF 91 SWAP2 01D0 90 SWAP1 01D1 80 DUP1 01D2 35 CALLDATALOAD 01D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01E8 16 AND 01E9 90 SWAP1 01EA 60 PUSH1 0x20 01EC 01 ADD 01ED 90 SWAP1 01EE 92 SWAP3 01EF 91 SWAP2 01F0 90 SWAP1 01F1 80 DUP1 01F2 35 CALLDATALOAD 01F3 90 SWAP1 01F4 60 PUSH1 0x20 01F6 01 ADD 01F7 90 SWAP1 01F8 92 SWAP3 01F9 91 SWAP2 01FA 90 SWAP1 01FB 50 POP 01FC 50 POP 01FD 50 POP 01FE 61 PUSH2 0x02de 0201 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01B9 stack[-1] = 0x0202 // @01CE stack[0] = !!msg.data[0x04:0x24] // @01EE stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // @01F8 stack[2] = msg.data[0x44:0x64] // } // Block ends with call to 0x02de, returns to 0x0202 label_0202: // Incoming return from call to 0x02DE at 0x0201 0202 5B JUMPDEST 0203 00 *STOP // Stack delta = +0 // Outputs[1] { @0203 stop(); } // Block terminates label_0204: // Incoming jump from 0x0077, if 0xcbfc4bce == stack[-1] // Inputs[1] { @0205 msg.value } 0204 5B JUMPDEST 0205 34 CALLVALUE 0206 80 DUP1 0207 15 ISZERO 0208 61 PUSH2 0x0210 020B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0205 stack[0] = msg.value } // Block ends with conditional jump to 0x0210, if !msg.value label_020C: // Incoming jump from 0x020B, if not !msg.value // Inputs[1] { @020F memory[0x00:0x00] } 020C 60 PUSH1 0x00 020E 80 DUP1 020F FD *REVERT // Stack delta = +0 // Outputs[1] { @020F revert(memory[0x00:0x00]); } // Block terminates label_0210: // Incoming jump from 0x020B, if !msg.value // Inputs[2] // { // @0218 msg.data.length // @021F msg.data[0x04:0x24] // } 0210 5B JUMPDEST 0211 50 POP 0212 61 PUSH2 0x0245 0215 60 PUSH1 0x04 0217 80 DUP1 0218 36 CALLDATASIZE 0219 03 SUB 021A 81 DUP2 021B 01 ADD 021C 90 SWAP1 021D 80 DUP1 021E 80 DUP1 021F 35 CALLDATALOAD 0220 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0235 16 AND 0236 90 SWAP1 0237 60 PUSH1 0x20 0239 01 ADD 023A 90 SWAP1 023B 92 SWAP3 023C 91 SWAP2 023D 90 SWAP1 023E 50 POP 023F 50 POP 0240 50 POP 0241 61 PUSH2 0x02e3 0244 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0212 stack[-1] = 0x0245 // @023B stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x02e3, returns to 0x0245 label_0245: // Incoming return from call to 0x02E3 at 0x0244 0245 5B JUMPDEST 0246 00 *STOP // Stack delta = +0 // Outputs[1] { @0246 stop(); } // Block terminates label_0247: // Incoming call from 0x00BD, returns to 0x00BE // Inputs[4] // { // @024D stack[-1] // @0255 memory[0x00:0x40] // @025C storage[keccak256(memory[0x00:0x40])] // @025D stack[-2] // } 0247 5B JUMPDEST 0248 60 PUSH1 0x01 024A 60 PUSH1 0x20 024C 52 MSTORE 024D 80 DUP1 024E 60 PUSH1 0x00 0250 52 MSTORE 0251 60 PUSH1 0x40 0253 60 PUSH1 0x00 0255 20 SHA3 0256 60 PUSH1 0x00 0258 91 SWAP2 0259 50 POP 025A 90 SWAP1 025B 50 POP 025C 54 SLOAD 025D 81 DUP2 025E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @024C memory[0x20:0x40] = 0x01 // @0250 memory[0x00:0x20] = stack[-1] // @025C stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_025F: // Incoming call from 0x00E8, returns to 0x00E9 // Inputs[4] // { // @026D msg.sender // @02A7 memory[0x00:0x40] // @02AC storage[keccak256(memory[0x00:0x40])] // @02B5 stack[-1] // } 025F 5B JUMPDEST 0260 67 PUSH8 0x0de0b6b3a7640000 0269 60 PUSH1 0x01 026B 60 PUSH1 0x00 026D 33 CALLER 026E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0283 16 AND 0284 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0299 16 AND 029A 81 DUP2 029B 52 MSTORE 029C 60 PUSH1 0x20 029E 01 ADD 029F 90 SWAP1 02A0 81 DUP2 02A1 52 MSTORE 02A2 60 PUSH1 0x20 02A4 01 ADD 02A5 60 PUSH1 0x00 02A7 20 SHA3 02A8 60 PUSH1 0x00 02AA 82 DUP3 02AB 82 DUP3 02AC 54 SLOAD 02AD 03 SUB 02AE 92 SWAP3 02AF 50 POP 02B0 50 POP 02B1 81 DUP2 02B2 90 SWAP1 02B3 55 SSTORE 02B4 50 POP 02B5 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @029B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @02A1 memory[0x20:0x40] = 0x01 // @02B3 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - 0x0de0b6b3a7640000 // } // Block ends with unconditional jump to stack[-1] label_02B6: // Incoming call from 0x0151, returns to 0x0152 // Inputs[1] { @02B8 stack[-2] } 02B6 5B JUMPDEST 02B7 50 POP 02B8 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_02B9: // Incoming call from 0x0168, returns to 0x0169 // Inputs[2] // { // @02BE storage[0x00] // @02DC stack[-1] // } 02B9 5B JUMPDEST 02BA 60 PUSH1 0x00 02BC 80 DUP1 02BD 90 SWAP1 02BE 54 SLOAD 02BF 90 SWAP1 02C0 61 PUSH2 0x0100 02C3 0A EXP 02C4 90 SWAP1 02C5 04 DIV 02C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02DB 16 AND 02DC 81 DUP2 02DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @02DB stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_02DE: // Incoming call from 0x0201, returns to 0x0202 // Inputs[1] { @02E2 stack[-4] } 02DE 5B JUMPDEST 02DF 50 POP 02E0 50 POP 02E1 50 POP 02E2 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_02E3: // Incoming call from 0x0244, returns to 0x0245 // Inputs[4] // { // @02F1 stack[-1] // @032B memory[0x00:0x40] // @0330 storage[keccak256(memory[0x00:0x40])] // @033A stack[-2] // } 02E3 5B JUMPDEST 02E4 67 PUSH8 0x0de0b6b3a7640000 02ED 60 PUSH1 0x01 02EF 60 PUSH1 0x00 02F1 83 DUP4 02F2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0307 16 AND 0308 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 031D 16 AND 031E 81 DUP2 031F 52 MSTORE 0320 60 PUSH1 0x20 0322 01 ADD 0323 90 SWAP1 0324 81 DUP2 0325 52 MSTORE 0326 60 PUSH1 0x20 0328 01 ADD 0329 60 PUSH1 0x00 032B 20 SHA3 032C 60 PUSH1 0x00 032E 82 DUP3 032F 82 DUP3 0330 54 SLOAD 0331 01 ADD 0332 92 SWAP3 0333 50 POP 0334 50 POP 0335 81 DUP2 0336 90 SWAP1 0337 55 SSTORE 0338 50 POP 0339 50 POP 033A 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @031F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0325 memory[0x20:0x40] = 0x01 // @0337 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x0de0b6b3a7640000 // } // Block ends with unconditional jump to stack[-2] 033B 00 *STOP 033C A1 LOG1 033D 65 PUSH6 0x627a7a723058 0344 20 SHA3 0345 AA AA 0346 58 PC 0347 F2 CALLCODE 0348 54 SLOAD 0349 74 PUSH21 0xb82b8fa431029e152204656fc370cc3802a3fa353d 035F F2 CALLCODE 0360 67 PUSH8 0xeda180750029
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]