Online Solidity Decompiler

« Decompile another contract

Address

0x9e235630025bed4d8b772c677bad712bceb86628 [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x52334d98 Unknown
0xe4a3d784 Unknown

Internal Methods

func_00A4(arg0, arg1)
func_00B7(arg0)
func_01E3() returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x60; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 == 0x52334d98) { // Dispatch table entry for 0x52334d98 (unknown) if (msg.value) { revert(memory[0x00:0x00]); } var var1 = 0x007b; var var2 = msg.data[0x04:0x24]; var var3 = msg.data[0x24:0x44]; func_00A4(var2, var3); stop(); } else if (var0 == 0xe4a3d784) { // Dispatch table entry for 0xe4a3d784 (unknown) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x00a2; var2 = msg.data[0x04:0x24]; func_00B7(var2); stop(); } else { revert(memory[0x00:0x00]); } } function func_00A4(var arg0, var arg1) { if (arg0 == arg1) { return; } else { return; } } function func_00B7(var arg0) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; var var3 = 0x00c4; var3 = func_01E3(); var var4 = 0x00; var0 = 0x4854427b31613462323065633137330000000000000000000000000000000000; var1 = 0x3233663230393039633232343631000000000000000000000000000000000000; var2 = 0x343330386630397d000000000000000000000000000000000000000000000000; var var5 = 0x20; var var6 = memory[0x40:0x60]; if (MSIZE() < var6) { var temp0 = var6; var temp1 = var5; memory[temp0:temp0 + 0x20] = temp1; memory[0x40:0x60] = temp0 + (temp1 + 0x1f & ~0x1f) + 0x20; var3 = temp0; if (var4 >= 0x20) { label_01DB: return; } else { label_0160: var5 = arg0; var6 = var4; if (var6 >= 0x20) { assert(); } var5 = byte(var5, var6) * 0x0100000000000000000000000000000000000000000000000000000000000000; var6 = var3; var var7 = var4; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } memory[var6 + 0x20 + var7:var6 + 0x20 + var7 + 0x01] = byte(var5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, 0x00); var4 = var4 + 0x01; if (var4 >= 0x20) { goto label_01DB; } else { goto label_0160; } } } else { var temp2 = MSIZE(); var temp3 = var5; memory[temp2:temp2 + 0x20] = temp3; memory[0x40:0x60] = temp2 + (temp3 + 0x1f & ~0x1f) + 0x20; var3 = temp2; if (var4 >= 0x20) { goto label_01DB; } else { goto label_0160; } } } function func_01E3() returns (var r0) { var temp0 = memory[0x40:0x60]; memory[0x40:0x60] = temp0 + 0x20; memory[temp0:temp0 + 0x20] = 0x00; return temp0; } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x60 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x004c 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x60 } // Block ends with conditional jump to 0x004c, 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 0x52334d98 003C 14 EQ 003D 61 PUSH2 0x0051 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0051, if 0x52334d98 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x52334d98 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe4a3d784 0047 14 EQ 0048 61 PUSH2 0x007d 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007d, if 0xe4a3d784 == stack[-1] label_004C: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x004B, if not 0xe4a3d784 == stack[-1] // Inputs[1] { @0050 memory[0x00:0x00] } 004C 5B JUMPDEST 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 jump from 0x0040, if 0x52334d98 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0052 msg.value } 0051 5B JUMPDEST 0052 34 CALLVALUE 0053 15 ISZERO 0054 61 PUSH2 0x005c 0057 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x005c, if !msg.value label_0058: // Incoming jump from 0x0057, if not !msg.value // Inputs[1] { @005B memory[0x00:0x00] } 0058 60 PUSH1 0x00 005A 80 DUP1 005B FD *REVERT // Stack delta = +0 // Outputs[1] { @005B revert(memory[0x00:0x00]); } // Block terminates label_005C: // Incoming jump from 0x0057, if !msg.value // Inputs[2] // { // @0064 msg.data[0x04:0x24] // @006D msg.data[0x24:0x44] // } 005C 5B JUMPDEST 005D 61 PUSH2 0x007b 0060 60 PUSH1 0x04 0062 80 DUP1 0063 80 DUP1 0064 35 CALLDATALOAD 0065 90 SWAP1 0066 60 PUSH1 0x20 0068 01 ADD 0069 90 SWAP1 006A 91 SWAP2 006B 90 SWAP1 006C 80 DUP1 006D 35 CALLDATALOAD 006E 90 SWAP1 006F 60 PUSH1 0x20 0071 01 ADD 0072 90 SWAP1 0073 91 SWAP2 0074 90 SWAP1 0075 50 POP 0076 50 POP 0077 61 PUSH2 0x00a4 007A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @005D stack[0] = 0x007b // @006A stack[1] = msg.data[0x04:0x24] // @0073 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x00a4, returns to 0x007B label_007B: // Incoming return from call to 0x00A4 at 0x007A 007B 5B JUMPDEST 007C 00 *STOP // Stack delta = +0 // Outputs[1] { @007C stop(); } // Block terminates label_007D: // Incoming jump from 0x004B, if 0xe4a3d784 == stack[-1] // Inputs[1] { @007E msg.value } 007D 5B JUMPDEST 007E 34 CALLVALUE 007F 15 ISZERO 0080 61 PUSH2 0x0088 0083 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0088, if !msg.value label_0084: // Incoming jump from 0x0083, if not !msg.value // Inputs[1] { @0087 memory[0x00:0x00] } 0084 60 PUSH1 0x00 0086 80 DUP1 0087 FD *REVERT // Stack delta = +0 // Outputs[1] { @0087 revert(memory[0x00:0x00]); } // Block terminates label_0088: // Incoming jump from 0x0083, if !msg.value // Inputs[1] { @0090 msg.data[0x04:0x24] } 0088 5B JUMPDEST 0089 61 PUSH2 0x00a2 008C 60 PUSH1 0x04 008E 80 DUP1 008F 80 DUP1 0090 35 CALLDATALOAD 0091 60 PUSH1 0x00 0093 19 NOT 0094 16 AND 0095 90 SWAP1 0096 60 PUSH1 0x20 0098 01 ADD 0099 90 SWAP1 009A 91 SWAP2 009B 90 SWAP1 009C 50 POP 009D 50 POP 009E 61 PUSH2 0x00b7 00A1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0089 stack[0] = 0x00a2 // @009A stack[1] = ~0x00 & msg.data[0x04:0x24] // } // Block ends with call to 0x00b7, returns to 0x00A2 label_00A2: // Incoming return from call to 0x00B7 at 0x00A1 00A2 5B JUMPDEST 00A3 00 *STOP // Stack delta = +0 // Outputs[1] { @00A3 stop(); } // Block terminates label_00A4: // Incoming call from 0x007A, returns to 0x007B // Inputs[2] // { // @00A5 stack[-1] // @00A6 stack[-2] // } 00A4 5B JUMPDEST 00A5 80 DUP1 00A6 82 DUP3 00A7 14 EQ 00A8 15 ISZERO 00A9 15 ISZERO 00AA 61 PUSH2 0x00b2 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b2, if !!(stack[-2] == stack[-1]) label_00AE: // Incoming jump from 0x00AD, if not !!(stack[-2] == stack[-1]) 00AE 61 PUSH2 0x00b3 00B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00b3 label_00B2: // Incoming jump from 0x00AD, if !!(stack[-2] == stack[-1]) // Inputs[1] { @00B6 stack[-3] } 00B2 5B JUMPDEST 00B3 5B JUMPDEST 00B4 50 POP 00B5 50 POP 00B6 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_00B7: // Incoming call from 0x00A1, returns to 0x00A2 00B7 5B JUMPDEST 00B8 60 PUSH1 0x00 00BA 80 DUP1 00BB 60 PUSH1 0x00 00BD 61 PUSH2 0x00c4 00C0 61 PUSH2 0x01e3 00C3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00B8 stack[0] = 0x00 // @00BA stack[1] = 0x00 // @00BB stack[2] = 0x00 // @00BD stack[3] = 0x00c4 // } // Block ends with call to 0x01e3, returns to 0x00C4 label_00C4: // Incoming return from call to 0x01E3 at 0x00C3 // Inputs[5] // { // @00E8 stack[-4] // @010B stack[-3] // @012E stack[-2] // @0134 memory[0x40:0x60] // @0136 MSIZE() // } 00C4 5B JUMPDEST 00C5 60 PUSH1 0x00 00C7 7F PUSH32 0x4854427b31613462323065633137330000000000000000000000000000000000 00E8 94 SWAP5 00E9 50 POP 00EA 7F PUSH32 0x3233663230393039633232343631000000000000000000000000000000000000 010B 93 SWAP4 010C 50 POP 010D 7F PUSH32 0x343330386630397d000000000000000000000000000000000000000000000000 012E 92 SWAP3 012F 50 POP 0130 60 PUSH1 0x20 0132 60 PUSH1 0x40 0134 51 MLOAD 0135 80 DUP1 0136 59 MSIZE 0137 10 LT 0138 61 PUSH2 0x013e 013B 57 *JUMPI // Stack delta = +3 // Outputs[6] // { // @00C5 stack[0] = 0x00 // @00E8 stack[-4] = 0x4854427b31613462323065633137330000000000000000000000000000000000 // @010B stack[-3] = 0x3233663230393039633232343631000000000000000000000000000000000000 // @012E stack[-2] = 0x343330386630397d000000000000000000000000000000000000000000000000 // @0130 stack[1] = 0x20 // @0134 stack[2] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x013e, if MSIZE() < memory[0x40:0x60] label_013C: // Incoming jump from 0x013B, if not MSIZE() < memory[0x40:0x60] // Inputs[4] // { // @013D MSIZE() // @013F stack[-2] // @0154 stack[-4] // @0159 stack[-3] // } 013C 50 POP 013D 59 MSIZE 013E 5B JUMPDEST 013F 90 SWAP1 0140 80 DUP1 0141 82 DUP3 0142 52 MSTORE 0143 80 DUP1 0144 60 PUSH1 0x1f 0146 01 ADD 0147 60 PUSH1 0x1f 0149 19 NOT 014A 16 AND 014B 60 PUSH1 0x20 014D 01 ADD 014E 82 DUP3 014F 01 ADD 0150 60 PUSH1 0x40 0152 52 MSTORE 0153 50 POP 0154 91 SWAP2 0155 50 POP 0156 5B JUMPDEST 0157 60 PUSH1 0x20 0159 81 DUP2 015A 10 LT 015B 15 ISZERO 015C 61 PUSH2 0x01db 015F 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @0142 memory[MSIZE():MSIZE() + 0x20] = stack[-2] // @0152 memory[0x40:0x60] = MSIZE() + 0x20 + (~0x1f & 0x1f + stack[-2]) // @0154 stack[-4] = MSIZE() // } // Block ends with conditional jump to 0x01db, if !(stack[-3] < 0x20) label_0160: // Incoming jump from 0x015F, if not !(stack[-3] < 0x20) // Incoming jump from 0x015F, if not !(stack[-1] < 0x20) // Incoming jump from 0x015F, if not !(stack[-3] < 0x20) // Inputs[2] // { // @0160 stack[-6] // @0161 stack[-1] // } 0160 85 DUP6 0161 81 DUP2 0162 60 PUSH1 0x20 0164 81 DUP2 0165 10 LT 0166 15 ISZERO 0167 15 ISZERO 0168 61 PUSH2 0x016d 016B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0160 stack[0] = stack[-6] // @0161 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x016d, if !!(stack[-1] < 0x20) label_016C: // Incoming jump from 0x016B, if not !!(stack[-1] < 0x20) 016C FE *ASSERT // Stack delta = +0 // Outputs[1] { @016C assert(); } // Block terminates label_016D: // Incoming jump from 0x016B, if !!(stack[-1] < 0x20) // Inputs[5] // { // @016E stack[-2] // @016E stack[-1] // @0191 stack[-4] // @0192 stack[-3] // @0194 memory[stack[-4]:stack[-4] + 0x20] // } 016D 5B JUMPDEST 016E 1A BYTE 016F 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0190 02 MUL 0191 82 DUP3 0192 82 DUP3 0193 81 DUP2 0194 51 MLOAD 0195 81 DUP2 0196 10 LT 0197 15 ISZERO 0198 15 ISZERO 0199 61 PUSH2 0x019e 019C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0190 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * byte(stack[-2], stack[-1]) // @0191 stack[-1] = stack[-4] // @0192 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x019e, if !!(stack[-3] < memory[stack[-4]:stack[-4] + 0x20]) label_019D: // Incoming jump from 0x019C, if not !!(stack[-3] < memory[stack[-4]:stack[-4] + 0x20]) 019D FE *ASSERT // Stack delta = +0 // Outputs[1] { @019D assert(); } // Block terminates label_019E: // Incoming jump from 0x019C, if !!(stack[-3] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @019F stack[-2] // @019F stack[-1] // @01A4 stack[-3] // @01CF stack[-4] // } 019E 5B JUMPDEST 019F 90 SWAP1 01A0 60 PUSH1 0x20 01A2 01 ADD 01A3 01 ADD 01A4 90 SWAP1 01A5 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 01C5 19 NOT 01C6 16 AND 01C7 90 SWAP1 01C8 81 DUP2 01C9 60 PUSH1 0x00 01CB 1A BYTE 01CC 90 SWAP1 01CD 53 MSTORE8 01CE 50 POP 01CF 80 DUP1 01D0 80 DUP1 01D1 60 PUSH1 0x01 01D3 01 ADD 01D4 91 SWAP2 01D5 50 POP 01D6 50 POP 01D7 61 PUSH2 0x0156 01DA 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @01CD memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @01D4 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x0156 label_01DB: // Incoming jump from 0x015F, if !(stack[-3] < 0x20) // Incoming jump from 0x015F, if !(stack[-1] < 0x20) // Incoming jump from 0x015F, if !(stack[-3] < 0x20) // Inputs[1] { @01E2 stack[-7] } 01DB 5B JUMPDEST 01DC 50 POP 01DD 50 POP 01DE 50 POP 01DF 50 POP 01E0 50 POP 01E1 50 POP 01E2 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_01E3: // Incoming call from 0x00C3, returns to 0x00C4 // Inputs[2] // { // @01E8 memory[0x40:0x60] // @01F5 stack[-1] // } 01E3 5B JUMPDEST 01E4 60 PUSH1 0x20 01E6 60 PUSH1 0x40 01E8 51 MLOAD 01E9 90 SWAP1 01EA 81 DUP2 01EB 01 ADD 01EC 60 PUSH1 0x40 01EE 52 MSTORE 01EF 80 DUP1 01F0 60 PUSH1 0x00 01F2 81 DUP2 01F3 52 MSTORE 01F4 50 POP 01F5 90 SWAP1 01F6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @01EE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @01F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @01F5 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] 01F7 00 *STOP 01F8 A1 LOG1 01F9 65 PUSH6 0x627a7a723058 0200 20 SHA3 0201 F4 DELEGATECALL 0202 FD *REVERT 0203 10 LT 0204 0D 0D 0205 D9 D9 0206 8D DUP14 0207 ED ED 0208 4B 4B 0209 17 OR 020A 77 PUSH24 0xa72fe1edad860729fa6a09c43d26ab004360d0100c3a0029
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]