Online Solidity Decompiler

« Decompile another contract

Address

0xa43028c702c3b119c749306461582bf647fd770a [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0xded0677d Unknown

Internal Methods

func_0051(arg0, arg1)
func_0089(arg0, arg1) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; var var0 = msg.value; if (var0) { revert(memory[0x00:0x00]); } if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var0 = msg.data[0x00:0x20] >> 0xe0; if (var0 == 0x7fbf5e5a) { // Dispatch table entry for 0x7fbf5e5a (unknown) var var1 = 0x0071; var var2 = 0x04; var var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } func_0051(var2, var3); stop(); } else if (var0 == 0xded0677d) { // Dispatch table entry for 0xded0677d (unknown) var1 = 0x009f; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = func_0089(var2, var3); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = !!var1; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else { revert(memory[0x00:0x00]); } } function func_0051(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20]; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var temp1 = memory[0x40:0x60] + 0x20; memory[temp1:temp1 + 0x20] = msg.sender; var temp2 = temp1 + 0x20; var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = temp2 - temp3 - 0x20; memory[0x40:0x60] = temp2; var var0 = keccak256(memory[temp3 + 0x20:temp3 + 0x20 + memory[temp3:temp3 + 0x20]]) >> 0x00; var temp4 = memory[0x40:0x60] + 0x20; memory[temp4:temp4 + 0x20] = tx.origin; var temp5 = temp4 + 0x20; var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = temp5 - temp6 - 0x20; memory[0x40:0x60] = temp5; var var1 = keccak256(memory[temp6 + 0x20:temp6 + 0x20 + memory[temp6:temp6 + 0x20]]) >> 0x00; var var2 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender; if (!var2) { var2 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == tx.origin; if (var2) { goto label_0220; } else { goto label_021A; } } else if (var2) { label_0220: if (var2) { label_022C: if (var2) { label_029E: storage[0x02] = arg0; storage[0x03] = arg1; return; } else { label_0231: var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x14; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x20] = 0x63616c6c6572206d757374206265206f776e6572000000000000000000000000; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x20) - temp11]); } } else { label_0226: if (storage[0x01] == var1) { goto label_029E; } else { goto label_0231; } } } else { label_021A: var2 = storage[0x01] == var0; if (var2) { goto label_022C; } else { goto label_0226; } } } function func_0089(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20]; arg1 = 0x00; var var0 = 0x00; var var1 = 0x00; if (var1 >= 0x40) { label_0301: if (var0 == storage[0x03]) { return 0x01; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x1a; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = 0x74686973206973206e6f7420746865207265616c20666c616721000000000000; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x20) - temp4]); } else { label_02C9: var temp5 = var1; var0 = var0 | (((arg0 >> temp5 * 0x04) + temp5 * 0x05 + (storage[0x02] >> temp5 * 0x04) * 0x07 & 0x0f) << temp5 * 0x04); var1 = temp5 + 0x01; if (var1 >= 0x40) { goto label_0301; } else { goto label_02C9; } } } }

Disassembly

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x0036 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0036, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x7fbf5e5a 0026 14 EQ 0027 61 PUSH2 0x003b 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x003b, if 0x7fbf5e5a == msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x7fbf5e5a == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xded0677d 0031 14 EQ 0032 61 PUSH2 0x0073 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0073, if 0xded0677d == stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xded0677d == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @003A memory[0x00:0x00] } 0036 5B JUMPDEST 0037 60 PUSH1 0x00 0039 80 DUP1 003A FD *REVERT // Stack delta = +0 // Outputs[1] { @003A revert(memory[0x00:0x00]); } // Block terminates label_003B: // Incoming jump from 0x002A, if 0x7fbf5e5a == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0042 msg.data.length } 003B 5B JUMPDEST 003C 61 PUSH2 0x0071 003F 60 PUSH1 0x04 0041 80 DUP1 0042 36 CALLDATASIZE 0043 03 SUB 0044 60 PUSH1 0x40 0046 81 DUP2 0047 10 LT 0048 15 ISZERO 0049 61 PUSH2 0x0051 004C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @003C stack[0] = 0x0071 // @003F stack[1] = 0x04 // @0043 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0051, returns to 0x0071, if !(msg.data.length - 0x04 < 0x40) label_004D: // Incoming jump from 0x004C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0050 memory[0x00:0x00] } 004D 60 PUSH1 0x00 004F 80 DUP1 0050 FD *REVERT // Stack delta = +0 // Outputs[1] { @0050 revert(memory[0x00:0x00]); } // Block terminates label_0051: // Incoming call from 0x004C, returns to 0x0071, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0052 stack[-2] // @0053 stack[-1] // @0057 msg.data[stack[-2]:stack[-2] + 0x20] // @0061 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0051 5B JUMPDEST 0052 81 DUP2 0053 01 ADD 0054 90 SWAP1 0055 80 DUP1 0056 80 DUP1 0057 35 CALLDATALOAD 0058 90 SWAP1 0059 60 PUSH1 0x20 005B 01 ADD 005C 90 SWAP1 005D 92 SWAP3 005E 91 SWAP2 005F 90 SWAP1 0060 80 DUP1 0061 35 CALLDATALOAD 0062 90 SWAP1 0063 60 PUSH1 0x20 0065 01 ADD 0066 90 SWAP1 0067 92 SWAP3 0068 91 SWAP2 0069 90 SWAP1 006A 50 POP 006B 50 POP 006C 50 POP 006D 61 PUSH2 0x00b9 0070 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @005D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0067 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x00b9 label_0071: // Incoming return from call to 0x0051 at 0x004C 0071 5B JUMPDEST 0072 00 *STOP // Stack delta = +0 // Outputs[1] { @0072 stop(); } // Block terminates label_0073: // Incoming jump from 0x0035, if 0xded0677d == stack[-1] // Inputs[1] { @007A msg.data.length } 0073 5B JUMPDEST 0074 61 PUSH2 0x009f 0077 60 PUSH1 0x04 0079 80 DUP1 007A 36 CALLDATASIZE 007B 03 SUB 007C 60 PUSH1 0x20 007E 81 DUP2 007F 10 LT 0080 15 ISZERO 0081 61 PUSH2 0x0089 0084 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0074 stack[0] = 0x009f // @0077 stack[1] = 0x04 // @007B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0089, returns to 0x009F, if !(msg.data.length - 0x04 < 0x20) label_0085: // Incoming jump from 0x0084, if not !(msg.data.length - 0x04 < 0x20) // 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 call from 0x0084, returns to 0x009F, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @008A stack[-2] // @008B stack[-1] // @008F msg.data[stack[-2]:stack[-2] + 0x20] // } 0089 5B JUMPDEST 008A 81 DUP2 008B 01 ADD 008C 90 SWAP1 008D 80 DUP1 008E 80 DUP1 008F 35 CALLDATALOAD 0090 90 SWAP1 0091 60 PUSH1 0x20 0093 01 ADD 0094 90 SWAP1 0095 92 SWAP3 0096 91 SWAP2 0097 90 SWAP1 0098 50 POP 0099 50 POP 009A 50 POP 009B 61 PUSH2 0x02b2 009E 56 *JUMP // Stack delta = -1 // Outputs[1] { @0095 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x02b2 label_009F: // Incoming return from call to 0x0089 at 0x0084 // Inputs[4] // { // @00A2 memory[0x40:0x60] // @00A4 stack[-1] // @00B3 memory[0x40:0x60] // @00B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 009F 5B JUMPDEST 00A0 60 PUSH1 0x40 00A2 51 MLOAD 00A3 80 DUP1 00A4 82 DUP3 00A5 15 ISZERO 00A6 15 ISZERO 00A7 15 ISZERO 00A8 15 ISZERO 00A9 81 DUP2 00AA 52 MSTORE 00AB 60 PUSH1 0x20 00AD 01 ADD 00AE 91 SWAP2 00AF 50 POP 00B0 50 POP 00B1 60 PUSH1 0x40 00B3 51 MLOAD 00B4 80 DUP1 00B5 91 SWAP2 00B6 03 SUB 00B7 90 SWAP1 00B8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @00B8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00B9: // Incoming jump from 0x0070 // Inputs[12] // { // @00BC msg.sender // @00BF memory[0x40:0x60] // @00FB memory[0x40:0x60] // @0109 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @010E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @0116 tx.origin // @0119 memory[0x40:0x60] // @0155 memory[0x40:0x60] // @0163 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0168 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @016E msg.sender // @0189 storage[0x00] // } 00B9 5B JUMPDEST 00BA 60 PUSH1 0x00 00BC 33 CALLER 00BD 60 PUSH1 0x40 00BF 51 MLOAD 00C0 60 PUSH1 0x20 00C2 01 ADD 00C3 80 DUP1 00C4 82 DUP3 00C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00DA 16 AND 00DB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00F0 16 AND 00F1 81 DUP2 00F2 52 MSTORE 00F3 60 PUSH1 0x20 00F5 01 ADD 00F6 91 SWAP2 00F7 50 POP 00F8 50 POP 00F9 60 PUSH1 0x40 00FB 51 MLOAD 00FC 60 PUSH1 0x20 00FE 81 DUP2 00FF 83 DUP4 0100 03 SUB 0101 03 SUB 0102 81 DUP2 0103 52 MSTORE 0104 90 SWAP1 0105 60 PUSH1 0x40 0107 52 MSTORE 0108 80 DUP1 0109 51 MLOAD 010A 90 SWAP1 010B 60 PUSH1 0x20 010D 01 ADD 010E 20 SHA3 010F 60 PUSH1 0x00 0111 1C SHR 0112 90 SWAP1 0113 50 POP 0114 60 PUSH1 0x00 0116 32 ORIGIN 0117 60 PUSH1 0x40 0119 51 MLOAD 011A 60 PUSH1 0x20 011C 01 ADD 011D 80 DUP1 011E 82 DUP3 011F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0134 16 AND 0135 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 014A 16 AND 014B 81 DUP2 014C 52 MSTORE 014D 60 PUSH1 0x20 014F 01 ADD 0150 91 SWAP2 0151 50 POP 0152 50 POP 0153 60 PUSH1 0x40 0155 51 MLOAD 0156 60 PUSH1 0x20 0158 81 DUP2 0159 83 DUP4 015A 03 SUB 015B 03 SUB 015C 81 DUP2 015D 52 MSTORE 015E 90 SWAP1 015F 60 PUSH1 0x40 0161 52 MSTORE 0162 80 DUP1 0163 51 MLOAD 0164 90 SWAP1 0165 60 PUSH1 0x20 0167 01 ADD 0168 20 SHA3 0169 60 PUSH1 0x00 016B 1C SHR 016C 90 SWAP1 016D 50 POP 016E 33 CALLER 016F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0184 16 AND 0185 60 PUSH1 0x00 0187 80 DUP1 0188 90 SWAP1 0189 54 SLOAD 018A 90 SWAP1 018B 61 PUSH2 0x0100 018E 0A EXP 018F 90 SWAP1 0190 04 DIV 0191 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01A6 16 AND 01A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01BC 16 AND 01BD 14 EQ 01BE 80 DUP1 01BF 61 PUSH2 0x0214 01C2 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @00F2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0103 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @0107 memory[0x40:0x60] = 0x20 + 0x20 + memory[0x40:0x60] // @0112 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) >> 0x00 // @014C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & tx.origin // @015D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @0161 memory[0x40:0x60] = 0x20 + 0x20 + memory[0x40:0x60] // @016C stack[1] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) >> 0x00 // @01BD stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // } // Block ends with conditional jump to 0x0214, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender label_01C3: // Incoming jump from 0x01C2, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[2] // { // @01C4 tx.origin // @01DF storage[0x00] // } 01C3 50 POP 01C4 32 ORIGIN 01C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01DA 16 AND 01DB 60 PUSH1 0x00 01DD 80 DUP1 01DE 90 SWAP1 01DF 54 SLOAD 01E0 90 SWAP1 01E1 61 PUSH2 0x0100 01E4 0A EXP 01E5 90 SWAP1 01E6 04 DIV 01E7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01FC 16 AND 01FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0212 16 AND 0213 14 EQ 0214 5B JUMPDEST 0215 80 DUP1 0216 61 PUSH2 0x0220 0219 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0213 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & tx.origin } // Block ends with conditional jump to 0x0220, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & tx.origin label_021A: // Incoming jump from 0x0219, if not stack[-1] // Incoming jump from 0x0219, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & tx.origin // Inputs[2] // { // @021B stack[-3] // @021E storage[0x01] // } 021A 50 POP 021B 81 DUP2 021C 60 PUSH1 0x01 021E 54 SLOAD 021F 14 EQ 0220 5B JUMPDEST 0221 80 DUP1 0222 61 PUSH2 0x022c 0225 57 *JUMPI // Stack delta = +0 // Outputs[1] { @021F stack[-1] = storage[0x01] == stack[-3] } // Block ends with conditional jump to 0x022c, if storage[0x01] == stack[-3] label_0226: // Incoming jump from 0x0225, if not stack[-1] // Incoming jump from 0x0225, if not storage[0x01] == stack[-3] // Inputs[2] // { // @0227 stack[-2] // @022A storage[0x01] // } 0226 50 POP 0227 80 DUP1 0228 60 PUSH1 0x01 022A 54 SLOAD 022B 14 EQ 022C 5B JUMPDEST 022D 61 PUSH2 0x029e 0230 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x029e, if storage[0x01] == stack[-2] label_0231: // Incoming jump from 0x0230, if not stack[-1] // Incoming jump from 0x0230, if not storage[0x01] == stack[-2] // Inputs[3] // { // @0233 memory[0x40:0x60] // @0298 memory[0x40:0x60] // @029D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0231 60 PUSH1 0x40 0233 51 MLOAD 0234 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0255 81 DUP2 0256 52 MSTORE 0257 60 PUSH1 0x04 0259 01 ADD 025A 80 DUP1 025B 80 DUP1 025C 60 PUSH1 0x20 025E 01 ADD 025F 82 DUP3 0260 81 DUP2 0261 03 SUB 0262 82 DUP3 0263 52 MSTORE 0264 60 PUSH1 0x14 0266 81 DUP2 0267 52 MSTORE 0268 60 PUSH1 0x20 026A 01 ADD 026B 80 DUP1 026C 7F PUSH32 0x63616c6c6572206d757374206265206f776e6572000000000000000000000000 028D 81 DUP2 028E 52 MSTORE 028F 50 POP 0290 60 PUSH1 0x20 0292 01 ADD 0293 91 SWAP2 0294 50 POP 0295 50 POP 0296 60 PUSH1 0x40 0298 51 MLOAD 0299 80 DUP1 029A 91 SWAP2 029B 03 SUB 029C 90 SWAP1 029D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0256 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0263 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0267 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x14 // @028E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x63616c6c6572206d757374206265206f776e6572000000000000000000000000 // @029D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_029E: // Incoming jump from 0x0230, if stack[-1] // Incoming jump from 0x0230, if storage[0x01] == stack[-2] // Inputs[3] // { // @029F stack[-4] // @02A6 stack[-3] // @02B1 stack[-5] // } 029E 5B JUMPDEST 029F 83 DUP4 02A0 60 PUSH1 0x02 02A2 81 DUP2 02A3 90 SWAP1 02A4 55 SSTORE 02A5 50 POP 02A6 82 DUP3 02A7 60 PUSH1 0x03 02A9 81 DUP2 02AA 90 SWAP1 02AB 55 SSTORE 02AC 50 POP 02AD 50 POP 02AE 50 POP 02AF 50 POP 02B0 50 POP 02B1 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @02A4 storage[0x02] = stack[-4] // @02AB storage[0x03] = stack[-3] // } // Block ends with unconditional jump to stack[-5] label_02B2: // Incoming jump from 0x009E 02B2 5B JUMPDEST 02B3 60 PUSH1 0x00 02B5 80 DUP1 02B6 60 PUSH1 0x00 02B8 90 SWAP1 02B9 50 POP 02BA 60 PUSH1 0x00 02BC 80 DUP1 02BD 90 SWAP1 02BE 50 POP 02BF 5B JUMPDEST 02C0 60 PUSH1 0x40 02C2 81 DUP2 02C3 10 LT 02C4 15 ISZERO 02C5 61 PUSH2 0x0301 02C8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02B3 stack[0] = 0x00 // @02B8 stack[1] = 0x00 // @02BD stack[2] = 0x00 // } // Block ends with conditional jump to 0x0301, if !(0x00 < 0x40) label_02C9: // Incoming jump from 0x02C8, if not !(0x00 < 0x40) // Incoming jump from 0x02C8, if not !(stack[-1] < 0x40) // Inputs[4] // { // @02CD stack[-1] // @02D3 storage[0x02] // @02E1 stack[-4] // @02F0 stack[-2] // } 02C9 60 PUSH1 0x00 02CB 60 PUSH1 0x0f 02CD 82 DUP3 02CE 60 PUSH1 0x04 02D0 02 MUL 02D1 60 PUSH1 0x02 02D3 54 SLOAD 02D4 90 SWAP1 02D5 1C SHR 02D6 60 PUSH1 0x07 02D8 02 MUL 02D9 83 DUP4 02DA 60 PUSH1 0x05 02DC 02 MUL 02DD 84 DUP5 02DE 60 PUSH1 0x04 02E0 02 MUL 02E1 88 DUP9 02E2 90 SWAP1 02E3 1C SHR 02E4 01 ADD 02E5 01 ADD 02E6 16 AND 02E7 90 SWAP1 02E8 50 POP 02E9 81 DUP2 02EA 60 PUSH1 0x04 02EC 02 MUL 02ED 81 DUP2 02EE 90 SWAP1 02EF 1B SHL 02F0 83 DUP4 02F1 17 OR 02F2 92 SWAP3 02F3 50 POP 02F4 50 POP 02F5 80 DUP1 02F6 80 DUP1 02F7 60 PUSH1 0x01 02F9 01 ADD 02FA 91 SWAP2 02FB 50 POP 02FC 50 POP 02FD 61 PUSH2 0x02bf 0300 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02F2 stack[-2] = stack[-2] | (((stack[-4] >> 0x04 * stack[-1]) + 0x05 * stack[-1] + 0x07 * (storage[0x02] >> 0x04 * stack[-1]) & 0x0f) << 0x04 * stack[-1]) // @02FA stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x02bf label_0301: // Incoming jump from 0x02C8, if !(0x00 < 0x40) // Incoming jump from 0x02C8, if !(stack[-1] < 0x40) // Inputs[2] // { // @0305 storage[0x03] // @0306 stack[-2] // } 0301 5B JUMPDEST 0302 50 POP 0303 60 PUSH1 0x03 0305 54 SLOAD 0306 81 DUP2 0307 14 EQ 0308 61 PUSH2 0x0379 030B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0379, if stack[-2] == storage[0x03] label_030C: // Incoming jump from 0x030B, if not stack[-2] == storage[0x03] // Inputs[3] // { // @030E memory[0x40:0x60] // @0373 memory[0x40:0x60] // @0378 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 030C 60 PUSH1 0x40 030E 51 MLOAD 030F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0330 81 DUP2 0331 52 MSTORE 0332 60 PUSH1 0x04 0334 01 ADD 0335 80 DUP1 0336 80 DUP1 0337 60 PUSH1 0x20 0339 01 ADD 033A 82 DUP3 033B 81 DUP2 033C 03 SUB 033D 82 DUP3 033E 52 MSTORE 033F 60 PUSH1 0x1a 0341 81 DUP2 0342 52 MSTORE 0343 60 PUSH1 0x20 0345 01 ADD 0346 80 DUP1 0347 7F PUSH32 0x74686973206973206e6f7420746865207265616c20666c616721000000000000 0368 81 DUP2 0369 52 MSTORE 036A 50 POP 036B 60 PUSH1 0x20 036D 01 ADD 036E 91 SWAP2 036F 50 POP 0370 50 POP 0371 60 PUSH1 0x40 0373 51 MLOAD 0374 80 DUP1 0375 91 SWAP2 0376 03 SUB 0377 90 SWAP1 0378 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0331 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @033E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0342 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1a // @0369 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x74686973206973206e6f7420746865207265616c20666c616721000000000000 // @0378 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0379: // Incoming jump from 0x030B, if stack[-2] == storage[0x03] // Inputs[3] // { // @037C stack[-2] // @037F stack[-4] // @0380 stack[-3] // } 0379 5B JUMPDEST 037A 60 PUSH1 0x01 037C 91 SWAP2 037D 50 POP 037E 50 POP 037F 91 SWAP2 0380 90 SWAP1 0381 50 POP 0382 56 *JUMP // Stack delta = -3 // Outputs[1] { @037F stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] 0383 FE *ASSERT 0384 A2 LOG2 0385 65 PUSH6 0x627a7a723158 038C 20 SHA3 038D 42 TIMESTAMP 038E EC EC 038F 26 26 0390 D2 D2 0391 3D RETURNDATASIZE 0392 96 SWAP7 0393 0B SIGNEXTEND 0394 ED ED 0395 82 DUP3 0396 D1 D1 0397 2E 2E 0398 B8 B8 0399 AA AA 039A B7 B7 039B 18 XOR 039C 38 CODESIZE 039D FC FC 039E 53 MSTORE8 039F 15 ISZERO 03A0 0D 0D 03A1 05 SDIV 03A2 65 PUSH6 0x92bad6fc6681 03A9 83 DUP4 03AA 83 DUP4 03AB 0B SIGNEXTEND 03AC 6A PUSH11 0x64736f6c63430005110032
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]