Online Solidity Decompiler

« Decompile another contract

Address

0x81816043e17a90d3cdc09aac61e433f0ec0dab5f [etherscan.io | etherchain.org]

Public Methods

No public methods detected.

Internal Methods

func_004B(arg0) returns (r0)
func_00D6(arg0) returns (r0)
func_00E0(arg0, arg1) returns (r0)
func_00F0(arg0, arg1, arg2)
func_0118(arg0) returns (r0)
func_0128(arg0, arg1) returns (r0)
func_0160(arg0, arg1) returns (r0)
func_01AD(arg0) returns (r0)

Decompilation

This might be constructor bytecode - to get at the deployed contract, go back and remove the constructor prefix, usually up to the next 6060 or 6080.
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 != 0xcfae3217) { revert(memory[0x00:0x00]); } var var1 = 0x0035; var var2 = func_004B(); var temp0 = var2; var2 = 0x0042; var var3 = temp0; var var4 = memory[0x40:0x60]; var2 = func_0160(var3, var4); var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + var2 - temp1]; } function func_004B() returns (var r0) { r0 = 0x00; var var1 = 0x0057; var var2 = storage[r0]; var1 = func_01AD(var2); var temp0 = var1; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + (temp0 + 0x1f) / 0x20 * 0x20 + 0x20; var temp2 = r0; r0 = temp1; var1 = temp2; var2 = temp0; memory[r0:r0 + 0x20] = var2; var var3 = r0 + 0x20; var var4 = var1; var var5 = 0x0083; var var6 = storage[var4]; var5 = func_01AD(var6); if (!var5) { label_00CE: return r0; } else if (0x1f < var5) { var temp3 = var3; var temp4 = temp3 + var5; var3 = temp4; memory[0x00:0x20] = var4; var temp5 = keccak256(memory[0x00:0x20]); memory[temp3:temp3 + 0x20] = storage[temp5]; var4 = temp5 + 0x01; var5 = temp3 + 0x20; if (var3 <= var5) { goto label_00C5; } label_00B1: var temp6 = var4; var temp7 = var5; memory[temp7:temp7 + 0x20] = storage[temp6]; var4 = temp6 + 0x01; var5 = temp7 + 0x20; if (var3 > var5) { goto label_00B1; } label_00C5: var temp8 = var3; var temp9 = temp8 + (var5 - temp8 & 0x1f); var5 = temp8; var3 = temp9; goto label_00CE; } else { var temp10 = var3; memory[temp10:temp10 + 0x20] = storage[var4] / 0x0100 * 0x0100; var3 = temp10 + 0x20; var5 = var5; goto label_00CE; } } function func_00D6(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_00E0(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_00F0(var arg0, var arg1, var arg2) { var var0 = 0x00; if (var0 >= arg0) { label_010D: memory[arg1 + arg0:arg1 + arg0 + 0x20] = 0x00; return; } else { label_00FB: var temp0 = var0; memory[arg1 + temp0:arg1 + temp0 + 0x20] = memory[arg2 + temp0:arg2 + temp0 + 0x20]; var0 = temp0 + 0x20; if (var0 >= arg0) { goto label_010D; } else { goto label_00FB; } } } function func_0118(var arg0) returns (var r0) { return arg0 + 0x1f & ~0x1f; } function func_0128(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x0132; var var2 = arg1; var1 = func_00D6(var2); var2 = 0x013c; var var3 = var1; var var4 = arg0; var2 = func_00E0(var3, var4); var temp0 = var2; arg0 = temp0; var2 = 0x014c; var3 = var1; var4 = arg0; var var5 = arg1 + 0x20; func_00F0(var3, var4, var5); var2 = 0x0155; var3 = var1; var2 = func_0118(var3); return arg0 + var2; } function func_0160(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x0178; var var2 = var0; var var3 = arg0; return func_0128(var2, var3); } function func_01AD(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 / 0x02; var var1 = temp0 & 0x01; if (!var1) { var temp1 = var0 & 0x7f; var0 = temp1; if (var1 - (var0 < 0x20)) { goto label_01D7; } else { goto label_01CF; } } else if (var1 - (var0 < 0x20)) { label_01D7: return var0; } else { label_01CF: var var2 = 0x01d6; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x22; revert(memory[0x00:0x24]); } } }

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 0x000f 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x000f, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000E memory[0x00:0x00] } 000C 5F PUSH0 000D 80 DUP1 000E FD *REVERT // Stack delta = +0 // Outputs[1] { @000E revert(memory[0x00:0x00]); } // Block terminates label_000F: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0013 msg.data.length } 000F 5B JUMPDEST 0010 50 POP 0011 60 PUSH1 0x04 0013 36 CALLDATASIZE 0014 10 LT 0015 61 PUSH2 0x0029 0018 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0029, if msg.data.length < 0x04 label_0019: // Incoming jump from 0x0018, if not msg.data.length < 0x04 // Inputs[1] { @001A msg.data[0x00:0x20] } 0019 5F PUSH0 001A 35 CALLDATALOAD 001B 60 PUSH1 0xe0 001D 1C SHR 001E 80 DUP1 001F 63 PUSH4 0xcfae3217 0024 14 EQ 0025 61 PUSH2 0x002d 0028 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001D stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x002d, if 0xcfae3217 == msg.data[0x00:0x20] >> 0xe0 label_0029: // Incoming jump from 0x0018, if msg.data.length < 0x04 // Incoming jump from 0x0028, if not 0xcfae3217 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002C memory[0x00:0x00] } 0029 5B JUMPDEST 002A 5F PUSH0 002B 80 DUP1 002C FD *REVERT // Stack delta = +0 // Outputs[1] { @002C revert(memory[0x00:0x00]); } // Block terminates label_002D: // Incoming jump from 0x0028, if 0xcfae3217 == msg.data[0x00:0x20] >> 0xe0 002D 5B JUMPDEST 002E 61 PUSH2 0x0035 0031 61 PUSH2 0x004b 0034 56 *JUMP // Stack delta = +1 // Outputs[1] { @002E stack[0] = 0x0035 } // Block ends with call to 0x004b, returns to 0x0035 label_0035: // Incoming return from call to 0x004B at 0x0034 // Inputs[2] // { // @0038 memory[0x40:0x60] // @003C stack[-1] // } 0035 5B JUMPDEST 0036 60 PUSH1 0x40 0038 51 MLOAD 0039 61 PUSH2 0x0042 003C 91 SWAP2 003D 90 SWAP1 003E 61 PUSH2 0x0160 0041 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @003C stack[-1] = 0x0042 // @003D stack[1] = memory[0x40:0x60] // @003D stack[0] = stack[-1] // } // Block ends with call to 0x0160, returns to 0x0042 label_0042: // Incoming return from call to 0x0160 at 0x0041 // Inputs[3] // { // @0045 memory[0x40:0x60] // @0047 stack[-1] // @004A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0042 5B JUMPDEST 0043 60 PUSH1 0x40 0045 51 MLOAD 0046 80 DUP1 0047 91 SWAP2 0048 03 SUB 0049 90 SWAP1 004A F3 *RETURN // Stack delta = -1 // Outputs[1] { @004A return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_004B: // Incoming call from 0x0034, returns to 0x0035 // Inputs[1] { @004E storage[0x00] } 004B 5B JUMPDEST 004C 5F PUSH0 004D 80 DUP1 004E 54 SLOAD 004F 61 PUSH2 0x0057 0052 90 SWAP1 0053 61 PUSH2 0x01ad 0056 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @004C stack[0] = 0x00 // @0052 stack[1] = 0x0057 // @0052 stack[2] = storage[0x00] // } // Block ends with call to 0x01ad, returns to 0x0057 label_0057: // Incoming return from call to 0x01AD at 0x0056 // Inputs[4] // { // @0058 stack[-1] // @0067 memory[0x40:0x60] // @006F stack[-2] // @007A storage[stack[-2]] // } 0057 5B JUMPDEST 0058 80 DUP1 0059 60 PUSH1 0x1f 005B 01 ADD 005C 60 PUSH1 0x20 005E 80 DUP1 005F 91 SWAP2 0060 04 DIV 0061 02 MUL 0062 60 PUSH1 0x20 0064 01 ADD 0065 60 PUSH1 0x40 0067 51 MLOAD 0068 90 SWAP1 0069 81 DUP2 006A 01 ADD 006B 60 PUSH1 0x40 006D 52 MSTORE 006E 80 DUP1 006F 92 SWAP3 0070 91 SWAP2 0071 90 SWAP1 0072 81 DUP2 0073 81 DUP2 0074 52 MSTORE 0075 60 PUSH1 0x20 0077 01 ADD 0078 82 DUP3 0079 80 DUP1 007A 54 SLOAD 007B 61 PUSH2 0x0083 007E 90 SWAP1 007F 61 PUSH2 0x01ad 0082 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @006D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @006F stack[-2] = memory[0x40:0x60] // @0070 stack[-1] = stack[-2] // @0071 stack[0] = stack[-1] // @0074 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0077 stack[1] = 0x20 + memory[0x40:0x60] // @0078 stack[2] = stack[-2] // @007E stack[4] = storage[stack[-2]] // @007E stack[3] = 0x0083 // } // Block ends with call to 0x01ad, returns to 0x0083 label_0083: // Incoming return from call to 0x01AD at 0x0082 // Inputs[1] { @0084 stack[-1] } 0083 5B JUMPDEST 0084 80 DUP1 0085 15 ISZERO 0086 61 PUSH2 0x00ce 0089 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ce, if !stack[-1] label_008A: // Incoming jump from 0x0089, if not !stack[-1] // Inputs[1] { @008A stack[-1] } 008A 80 DUP1 008B 60 PUSH1 0x1f 008D 10 LT 008E 61 PUSH2 0x00a5 0091 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a5, if 0x1f < stack[-1] label_0092: // Incoming jump from 0x0091, if not 0x1f < stack[-1] // Inputs[4] // { // @0096 stack[-2] // @0097 storage[stack[-2]] // @009A stack[-3] // @009C stack[-1] // } 0092 61 PUSH2 0x0100 0095 80 DUP1 0096 83 DUP4 0097 54 SLOAD 0098 04 DIV 0099 02 MUL 009A 83 DUP4 009B 52 MSTORE 009C 91 SWAP2 009D 60 PUSH1 0x20 009F 01 ADD 00A0 91 SWAP2 00A1 61 PUSH2 0x00ce 00A4 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @009B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @00A0 stack[-1] = stack[-1] // @00A0 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x00ce label_00A5: // Incoming jump from 0x0091, if 0x1f < stack[-1] // Inputs[5] // { // @00A6 stack[-3] // @00A7 stack[-1] // @00A9 stack[-2] // @00AF memory[0x00:0x20] // @00B3 storage[keccak256(memory[0x00:0x20])] // } 00A5 5B JUMPDEST 00A6 82 DUP3 00A7 01 ADD 00A8 91 SWAP2 00A9 90 SWAP1 00AA 5F PUSH0 00AB 52 MSTORE 00AC 60 PUSH1 0x20 00AE 5F PUSH0 00AF 20 SHA3 00B0 90 SWAP1 00B1 5B JUMPDEST 00B2 81 DUP2 00B3 54 SLOAD 00B4 81 DUP2 00B5 52 MSTORE 00B6 90 SWAP1 00B7 60 PUSH1 0x01 00B9 01 ADD 00BA 90 SWAP1 00BB 60 PUSH1 0x20 00BD 01 ADD 00BE 80 DUP1 00BF 83 DUP4 00C0 11 GT 00C1 61 PUSH2 0x00b1 00C4 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @00A8 stack[-3] = stack[-3] + stack[-1] // @00AB memory[0x00:0x20] = stack[-2] // @00B5 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @00BA stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @00BD stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x00b1, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_00C5: // Incoming jump from 0x00C4, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x00C4, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @00C5 stack[-3] // @00C6 stack[-1] // } 00C5 82 DUP3 00C6 90 SWAP1 00C7 03 SUB 00C8 60 PUSH1 0x1f 00CA 16 AND 00CB 82 DUP3 00CC 01 ADD 00CD 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @00CD stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @00CD stack[-1] = stack[-3] // } // Block continues label_00CE: // Incoming jump from 0x00CD // Incoming jump from 0x00A4 // Incoming jump from 0x0089, if !stack[-1] // Inputs[1] { @00D4 stack[-7] } 00CE 5B JUMPDEST 00CF 50 POP 00D0 50 POP 00D1 50 POP 00D2 50 POP 00D3 50 POP 00D4 81 DUP2 00D5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_00D6: // Incoming call from 0x0131, returns to 0x0132 // Inputs[3] // { // @00D8 stack[-1] // @00D9 memory[stack[-1]:stack[-1] + 0x20] // @00DC stack[-2] // } 00D6 5B JUMPDEST 00D7 5F PUSH0 00D8 81 DUP2 00D9 51 MLOAD 00DA 90 SWAP1 00DB 50 POP 00DC 91 SWAP2 00DD 90 SWAP1 00DE 50 POP 00DF 56 *JUMP // Stack delta = -1 // Outputs[1] { @00DC stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_00E0: // Incoming call from 0x013B, returns to 0x013C // Inputs[3] // { // @00E2 stack[-2] // @00E3 stack[-1] // @00EB stack[-3] // } 00E0 5B JUMPDEST 00E1 5F PUSH0 00E2 82 DUP3 00E3 82 DUP3 00E4 52 MSTORE 00E5 60 PUSH1 0x20 00E7 82 DUP3 00E8 01 ADD 00E9 90 SWAP1 00EA 50 POP 00EB 92 SWAP3 00EC 91 SWAP2 00ED 50 POP 00EE 50 POP 00EF 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @00E4 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @00EB stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_00F0: // Incoming call from 0x014B, returns to 0x014C // Inputs[1] { @00F3 stack[-3] } 00F0 5B JUMPDEST 00F1 5F PUSH0 00F2 5B JUMPDEST 00F3 83 DUP4 00F4 81 DUP2 00F5 10 LT 00F6 15 ISZERO 00F7 61 PUSH2 0x010d 00FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00F1 stack[0] = 0x00 } // Block ends with conditional jump to 0x010d, if !(0x00 < stack[-3]) label_00FB: // Incoming jump from 0x00FA, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x00FA, if not !(0x00 < stack[-3]) // Inputs[4] // { // @00FB stack[-1] // @00FC stack[-2] // @00FE memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0100 stack[-3] // } 00FB 80 DUP1 00FC 82 DUP3 00FD 01 ADD 00FE 51 MLOAD 00FF 81 DUP2 0100 84 DUP5 0101 01 ADD 0102 52 MSTORE 0103 60 PUSH1 0x20 0105 81 DUP2 0106 01 ADD 0107 90 SWAP1 0108 50 POP 0109 61 PUSH2 0x00f2 010C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0102 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0107 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x00f2 label_010D: // Incoming jump from 0x00FA, if !(stack[-1] < stack[-4]) // Incoming jump from 0x00FA, if !(0x00 < stack[-3]) // Inputs[3] // { // @010F stack[-4] // @0110 stack[-3] // @0117 stack[-5] // } 010D 5B JUMPDEST 010E 5F PUSH0 010F 84 DUP5 0110 84 DUP5 0111 01 ADD 0112 52 MSTORE 0113 50 POP 0114 50 POP 0115 50 POP 0116 50 POP 0117 56 *JUMP // Stack delta = -5 // Outputs[1] { @0112 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_0118: // Incoming call from 0x0154, returns to 0x0155 // Inputs[2] // { // @011F stack[-1] // @0124 stack[-2] // } 0118 5B JUMPDEST 0119 5F PUSH0 011A 60 PUSH1 0x1f 011C 19 NOT 011D 60 PUSH1 0x1f 011F 83 DUP4 0120 01 ADD 0121 16 AND 0122 90 SWAP1 0123 50 POP 0124 91 SWAP2 0125 90 SWAP1 0126 50 POP 0127 56 *JUMP // Stack delta = -1 // Outputs[1] { @0124 stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_0128: // Incoming call from 0x0177, returns to 0x0178 // Inputs[1] { @012D stack[-1] } 0128 5B JUMPDEST 0129 5F PUSH0 012A 61 PUSH2 0x0132 012D 82 DUP3 012E 61 PUSH2 0x00d6 0131 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0129 stack[0] = 0x00 // @012A stack[1] = 0x0132 // @012D stack[2] = stack[-1] // } // Block ends with call to 0x00d6, returns to 0x0132 label_0132: // Incoming return from call to 0x00D6 at 0x0131 // Inputs[2] // { // @0136 stack[-1] // @0137 stack[-4] // } 0132 5B JUMPDEST 0133 61 PUSH2 0x013c 0136 81 DUP2 0137 85 DUP6 0138 61 PUSH2 0x00e0 013B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0133 stack[0] = 0x013c // @0136 stack[1] = stack[-1] // @0137 stack[2] = stack[-4] // } // Block ends with call to 0x00e0, returns to 0x013C label_013C: // Incoming return from call to 0x00E0 at 0x013B // Inputs[4] // { // @013D stack[-1] // @013D stack[-5] // @0142 stack[-2] // @0146 stack[-4] // } 013C 5B JUMPDEST 013D 93 SWAP4 013E 50 POP 013F 61 PUSH2 0x014c 0142 81 DUP2 0143 85 DUP6 0144 60 PUSH1 0x20 0146 86 DUP7 0147 01 ADD 0148 61 PUSH2 0x00f0 014B 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @013D stack[-5] = stack[-1] // @013F stack[-1] = 0x014c // @0142 stack[0] = stack[-2] // @0143 stack[1] = stack[-1] // @0147 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x00f0, returns to 0x014C label_014C: // Incoming return from call to 0x00F0 at 0x014B // Inputs[1] { @0150 stack[-1] } 014C 5B JUMPDEST 014D 61 PUSH2 0x0155 0150 81 DUP2 0151 61 PUSH2 0x0118 0154 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @014D stack[0] = 0x0155 // @0150 stack[1] = stack[-1] // } // Block ends with call to 0x0118, returns to 0x0155 label_0155: // Incoming return from call to 0x0118 at 0x0154 // Inputs[4] // { // @0156 stack[-5] // @0157 stack[-1] // @0158 stack[-3] // @015B stack[-6] // } 0155 5B JUMPDEST 0156 84 DUP5 0157 01 ADD 0158 91 SWAP2 0159 50 POP 015A 50 POP 015B 92 SWAP3 015C 91 SWAP2 015D 50 POP 015E 50 POP 015F 56 *JUMP // Stack delta = -5 // Outputs[1] { @015B stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_0160: // Incoming call from 0x0041, returns to 0x0042 // Inputs[2] // { // @0164 stack[-1] // @0173 stack[-2] // } 0160 5B JUMPDEST 0161 5F PUSH0 0162 60 PUSH1 0x20 0164 82 DUP3 0165 01 ADD 0166 90 SWAP1 0167 50 POP 0168 81 DUP2 0169 81 DUP2 016A 03 SUB 016B 5F PUSH0 016C 83 DUP4 016D 01 ADD 016E 52 MSTORE 016F 61 PUSH2 0x0178 0172 81 DUP2 0173 84 DUP5 0174 61 PUSH2 0x0128 0177 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0166 stack[0] = stack[-1] + 0x20 // @016E memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @016F stack[1] = 0x0178 // @0172 stack[2] = stack[-1] + 0x20 // @0173 stack[3] = stack[-2] // } // Block ends with call to 0x0128, returns to 0x0178 label_0178: // Incoming return from call to 0x0128 at 0x0177 // Inputs[4] // { // @0179 stack[-1] // @0179 stack[-2] // @017B stack[-5] // @017C stack[-4] // } 0178 5B JUMPDEST 0179 90 SWAP1 017A 50 POP 017B 92 SWAP3 017C 91 SWAP2 017D 50 POP 017E 50 POP 017F 56 *JUMP // Stack delta = -4 // Outputs[1] { @017B stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0180: // Incoming jump from 0x01D5 // Inputs[1] { @01AC memory[0x00:0x24] } 0180 5B JUMPDEST 0181 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 01A2 5F PUSH0 01A3 52 MSTORE 01A4 60 PUSH1 0x22 01A6 60 PUSH1 0x04 01A8 52 MSTORE 01A9 60 PUSH1 0x24 01AB 5F PUSH0 01AC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @01A3 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @01A8 memory[0x04:0x24] = 0x22 // @01AC revert(memory[0x00:0x24]); // } // Block terminates label_01AD: // Incoming call from 0x0056, returns to 0x0057 // Incoming call from 0x0082, returns to 0x0083 // Inputs[1] { @01B1 stack[-1] } 01AD 5B JUMPDEST 01AE 5F PUSH0 01AF 60 PUSH1 0x02 01B1 82 DUP3 01B2 04 DIV 01B3 90 SWAP1 01B4 50 POP 01B5 60 PUSH1 0x01 01B7 82 DUP3 01B8 16 AND 01B9 80 DUP1 01BA 61 PUSH2 0x01c4 01BD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @01B3 stack[0] = stack[-1] / 0x02 // @01B8 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x01c4, if stack[-1] & 0x01 label_01BE: // Incoming jump from 0x01BD, if not stack[-1] & 0x01 // Inputs[2] // { // @01C0 stack[-2] // @01C9 stack[-1] // } 01BE 60 PUSH1 0x7f 01C0 82 DUP3 01C1 16 AND 01C2 91 SWAP2 01C3 50 POP 01C4 5B JUMPDEST 01C5 60 PUSH1 0x20 01C7 82 DUP3 01C8 10 LT 01C9 81 DUP2 01CA 03 SUB 01CB 61 PUSH2 0x01d7 01CE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @01C2 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x01d7, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_01CF: // Incoming jump from 0x01CE, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x01CE, if not stack[-1] - (stack[-2] < 0x20) 01CF 61 PUSH2 0x01d6 01D2 61 PUSH2 0x0180 01D5 56 *JUMP // Stack delta = +1 // Outputs[1] { @01CF stack[0] = 0x01d6 } // Block ends with unconditional jump to 0x0180 01D6 5B JUMPDEST label_01D7: // Incoming jump from 0x01CE, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x01CE, if stack[-1] - (stack[-2] < 0x20) // Inputs[3] // { // @01D9 stack[-2] // @01D9 stack[-4] // @01DA stack[-3] // } 01D7 5B JUMPDEST 01D8 50 POP 01D9 91 SWAP2 01DA 90 SWAP1 01DB 50 POP 01DC 56 *JUMP // Stack delta = -3 // Outputs[1] { @01D9 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] 01DD FE *ASSERT 01DE A2 LOG2 01DF 64 PUSH5 0x6970667358 01E5 22 22 01E6 12 SLT 01E7 20 SHA3 01E8 F9 F9 01E9 1A BYTE 01EA EB EB 01EB A9 A9 01EC E4 E4 01ED FD *REVERT 01EE 0C 0C 01EF 45 GASLIMIT 01F0 51 MLOAD 01F1 2C 2C 01F2 F5 CREATE2 01F3 30 ADDRESS 01F4 CD CD 01F5 9B SWAP12 01F6 7E PUSH31 0xa08747c6a4fc39c4650fba8004742b60bb64736f6c63430008150033
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]