Online Solidity Decompiler

« Decompile another contract

Address

0x552743c9a07d7f16715f3a4509502c60d2783d25 [etherscan.io | etherchain.org]

Public Methods

No public methods detected.

Internal Methods

func_003E(arg0, arg1) returns (r0)

func_00C9(arg0, arg1) returns (r0, r1)

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 != 0x1626ba7e) { revert(memory[0x00:0x00]); }
    
        var var1 = 0x0065;
        var var2 = 0x003e;
        var var3 = msg.data.length;
        var var4 = 0x04;
        var2, var3 = func_00C9(var3, var4);
        var1 = func_003E(var2, var3);
        var temp0 = memory[0x40:0x60];
        memory[temp0:temp0 + 0x20] = var1 & 0xffffffff00000000000000000000000000000000000000000000000000000000;
        var temp1 = memory[0x40:0x60];
        return memory[temp1:temp1 + (temp0 + 0x20) - temp1];
    }
    
    function func_003E(var arg0, var arg1) returns (var r0) { return 0x1626ba7e00000000000000000000000000000000000000000000000000000000; }
    
    function func_00C9(var arg0, var arg1) returns (var r0, var arg0) {
        var var0 = 0x00;
        var var1 = var0;
    
        if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); }
    
        var temp0 = arg1;
        var0 = msg.data[temp0:temp0 + 0x20];
        var var2 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20];
        var var3 = 0xffffffffffffffff;
    
        if (var2 > var3) { revert(memory[0x00:0x00]); }
    
        var temp1 = arg1 + var2;
        var2 = temp1;
    
        if (var2 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); }
    
        var var4 = msg.data[var2:var2 + 0x20];
    
        if (var4 <= var3) {
            var temp2 = memory[0x40:0x60];
            var temp3 = temp2 + ((var4 + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x3f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0);
            var var5 = temp3;
            var var6 = temp2;
        
            if (!((var5 < var6) | (var5 > var3))) {
                memory[0x40:0x60] = var5;
                var temp4 = var4;
                memory[var6:var6 + 0x20] = temp4;
            
                if (var2 + temp4 + 0x20 > arg0) { revert(memory[0x00:0x00]); }
            
                var temp5 = var4;
                var temp6 = var6;
                memory[temp6 + 0x20:temp6 + 0x20 + temp5] = msg.data[var2 + 0x20:var2 + 0x20 + temp5];
                memory[temp6 + temp5 + 0x20:temp6 + temp5 + 0x20 + 0x20] = 0x00;
                arg0 = temp6;
                r0 = var0;
                return r0, arg0;
            } else {
                var var7 = 0x0167;
            
            label_009A:
                memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                memory[0x04:0x24] = 0x41;
                revert(memory[0x00:0x24]);
            }
        } else {
            var5 = 0x0121;
            goto label_009A;
        }
    }
}

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 0x002b
	0019    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x002b, 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 0x1626ba7e
	0026    14  EQ
	0027    61  PUSH2 0x0030
	002A    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @001F  stack[0] = msg.data[0x00:0x20] >> 0xe0 }
	// Block ends with conditional jump to 0x0030, if 0x1626ba7e == msg.data[0x00:0x20] >> 0xe0

label_002B:
	// Incoming jump from 0x002A, if not 0x1626ba7e == msg.data[0x00:0x20] >> 0xe0
	// Incoming jump from 0x0019, if msg.data.length < 0x04
	// Inputs[1] { @002F  memory[0x00:0x00] }
	002B    5B  JUMPDEST
	002C    60  PUSH1 0x00
	002E    80  DUP1
	002F    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @002F  revert(memory[0x00:0x00]); }
	// Block terminates

label_0030:
	// Incoming jump from 0x002A, if 0x1626ba7e == msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @0037  msg.data.length }
	0030    5B  JUMPDEST
	0031    61  PUSH2 0x0065
	0034    61  PUSH2 0x003e
	0037    36  CALLDATASIZE
	0038    60  PUSH1 0x04
	003A    61  PUSH2 0x00c9
	003D    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0031  stack[0] = 0x0065
	//     @0034  stack[1] = 0x003e
	//     @0037  stack[2] = msg.data.length
	//     @0038  stack[3] = 0x04
	// }
	// Block ends with call to 0x00c9, returns to 0x003E

label_003E:
	// Incoming return from call to 0x00C9 at 0x003D
	// Inputs[2]
	// {
	//     @0060  stack[-3]
	//     @0061  stack[-2]
	// }
	003E    5B  JUMPDEST
	003F    7F  PUSH32 0x1626ba7e00000000000000000000000000000000000000000000000000000000
	0060    92  SWAP3
	0061    91  SWAP2
	0062    50  POP
	0063    50  POP
	0064    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @0060  stack[-3] = 0x1626ba7e00000000000000000000000000000000000000000000000000000000 }
	// Block ends with unconditional jump to stack[-3]

label_0065:
	// Incoming return from call to 0x003E at 0x003D
	// Inputs[4]
	// {
	//     @0068  memory[0x40:0x60]
	//     @008B  stack[-1]
	//     @0094  memory[0x40:0x60]
	//     @0099  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0065    5B  JUMPDEST
	0066    60  PUSH1 0x40
	0068    51  MLOAD
	0069    7F  PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000
	008A    90  SWAP1
	008B    91  SWAP2
	008C    16  AND
	008D    81  DUP2
	008E    52  MSTORE
	008F    60  PUSH1 0x20
	0091    01  ADD
	0092    60  PUSH1 0x40
	0094    51  MLOAD
	0095    80  DUP1
	0096    91  SWAP2
	0097    03  SUB
	0098    90  SWAP1
	0099    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @008E  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000
	//     @0099  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_009A:
	// Incoming jump from 0x0166
	// Incoming jump from 0x0120
	// Inputs[1] { @00C8  memory[0x00:0x24] }
	009A    5B  JUMPDEST
	009B    7F  PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000
	00BC    60  PUSH1 0x00
	00BE    52  MSTORE
	00BF    60  PUSH1 0x41
	00C1    60  PUSH1 0x04
	00C3    52  MSTORE
	00C4    60  PUSH1 0x24
	00C6    60  PUSH1 0x00
	00C8    FD  *REVERT
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @00BE  memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000
	//     @00C3  memory[0x04:0x24] = 0x41
	//     @00C8  revert(memory[0x00:0x24]);
	// }
	// Block terminates

label_00C9:
	// Incoming call from 0x003D, returns to 0x003E
	// Inputs[2]
	// {
	//     @00CF  stack[-1]
	//     @00D0  stack[-2]
	// }
	00C9    5B  JUMPDEST
	00CA    60  PUSH1 0x00
	00CC    80  DUP1
	00CD    60  PUSH1 0x40
	00CF    83  DUP4
	00D0    85  DUP6
	00D1    03  SUB
	00D2    12  SLT
	00D3    15  ISZERO
	00D4    61  PUSH2 0x00dc
	00D7    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @00CA  stack[0] = 0x00
	//     @00CC  stack[1] = 0x00
	// }
	// Block ends with conditional jump to 0x00dc, if !(stack[-2] - stack[-1] i< 0x40)

label_00D8:
	// Incoming jump from 0x00D7, if not !(stack[-2] - stack[-1] i< 0x40)
	// Inputs[1] { @00DB  memory[0x00:0x00] }
	00D8    60  PUSH1 0x00
	00DA    80  DUP1
	00DB    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @00DB  revert(memory[0x00:0x00]); }
	// Block terminates

label_00DC:
	// Incoming jump from 0x00D7, if !(stack[-2] - stack[-1] i< 0x40)
	// Inputs[4]
	// {
	//     @00DD  stack[-3]
	//     @00DE  msg.data[stack[-3]:stack[-3] + 0x20]
	//     @00DF  stack[-2]
	//     @00E5  msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]
	// }
	00DC    5B  JUMPDEST
	00DD    82  DUP3
	00DE    35  CALLDATALOAD
	00DF    91  SWAP2
	00E0    50  POP
	00E1    60  PUSH1 0x20
	00E3    83  DUP4
	00E4    01  ADD
	00E5    35  CALLDATALOAD
	00E6    67  PUSH8 0xffffffffffffffff
	00EF    80  DUP1
	00F0    82  DUP3
	00F1    11  GT
	00F2    15  ISZERO
	00F3    61  PUSH2 0x00fb
	00F6    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @00DF  stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20]
	//     @00E5  stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]
	//     @00E6  stack[1] = 0xffffffffffffffff
	// }
	// Block ends with conditional jump to 0x00fb, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff)

label_00F7:
	// Incoming jump from 0x00F6, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff)
	// Inputs[1] { @00FA  memory[0x00:0x00] }
	00F7    60  PUSH1 0x00
	00F9    80  DUP1
	00FA    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @00FA  revert(memory[0x00:0x00]); }
	// Block terminates

label_00FB:
	// Incoming jump from 0x00F6, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff)
	// Inputs[3]
	// {
	//     @00FC  stack[-2]
	//     @00FD  stack[-5]
	//     @0101  stack[-6]
	// }
	00FB    5B  JUMPDEST
	00FC    81  DUP2
	00FD    85  DUP6
	00FE    01  ADD
	00FF    91  SWAP2
	0100    50  POP
	0101    85  DUP6
	0102    60  PUSH1 0x1f
	0104    83  DUP4
	0105    01  ADD
	0106    12  SLT
	0107    61  PUSH2 0x010f
	010A    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @00FF  stack[-2] = stack[-5] + stack[-2] }
	// Block ends with conditional jump to 0x010f, if stack[-5] + stack[-2] + 0x1f i< stack[-6]

label_010B:
	// Incoming jump from 0x010A, if not stack[-5] + stack[-2] + 0x1f i< stack[-6]
	// Inputs[1] { @010E  memory[0x00:0x00] }
	010B    60  PUSH1 0x00
	010D    80  DUP1
	010E    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @010E  revert(memory[0x00:0x00]); }
	// Block terminates

label_010F:
	// Incoming jump from 0x010A, if stack[-5] + stack[-2] + 0x1f i< stack[-6]
	// Inputs[3]
	// {
	//     @0110  stack[-2]
	//     @0111  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0112  stack[-1]
	// }
	010F    5B  JUMPDEST
	0110    81  DUP2
	0111    35  CALLDATALOAD
	0112    81  DUP2
	0113    81  DUP2
	0114    11  GT
	0115    15  ISZERO
	0116    61  PUSH2 0x0121
	0119    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0111  stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with conditional jump to 0x0121, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1])

label_011A:
	// Incoming jump from 0x0119, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1])
	011A    61  PUSH2 0x0121
	011D    61  PUSH2 0x009a
	0120    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @011A  stack[0] = 0x0121 }
	// Block ends with unconditional jump to 0x009a

label_0121:
	// Incoming jump from 0x0119, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1])
	// Inputs[3]
	// {
	//     @0124  memory[0x40:0x60]
	//     @0127  stack[-1]
	//     @0154  stack[-2]
	// }
	0121    5B  JUMPDEST
	0122    60  PUSH1 0x40
	0124    51  MLOAD
	0125    60  PUSH1 0x1f
	0127    82  DUP3
	0128    01  ADD
	0129    7F  PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0
	014A    90  SWAP1
	014B    81  DUP2
	014C    16  AND
	014D    60  PUSH1 0x3f
	014F    01  ADD
	0150    16  AND
	0151    81  DUP2
	0152    01  ADD
	0153    90  SWAP1
	0154    83  DUP4
	0155    82  DUP3
	0156    11  GT
	0157    81  DUP2
	0158    83  DUP4
	0159    10  LT
	015A    17  OR
	015B    15  ISZERO
	015C    61  PUSH2 0x0167
	015F    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0153  stack[0] = memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-1] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)
	//     @0153  stack[1] = memory[0x40:0x60]
	// }
	// Block ends with conditional jump to 0x0167, if !((memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-1] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-1] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > stack[-2]))

label_0160:
	// Incoming jump from 0x015F, if not !((memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-1] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-1] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > stack[-2]))
	0160    61  PUSH2 0x0167
	0163    61  PUSH2 0x009a
	0166    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0160  stack[0] = 0x0167 }
	// Block ends with unconditional jump to 0x009a

label_0167:
	// Incoming jump from 0x015F, if !((memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-1] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-1] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > stack[-2]))
	// Inputs[5]
	// {
	//     @0168  stack[-2]
	//     @016C  stack[-3]
	//     @016D  stack[-1]
	//     @016F  stack[-9]
	//     @0173  stack[-5]
	// }
	0167    5B  JUMPDEST
	0168    81  DUP2
	0169    60  PUSH1 0x40
	016B    52  MSTORE
	016C    82  DUP3
	016D    81  DUP2
	016E    52  MSTORE
	016F    88  DUP9
	0170    60  PUSH1 0x20
	0172    84  DUP5
	0173    87  DUP8
	0174    01  ADD
	0175    01  ADD
	0176    11  GT
	0177    15  ISZERO
	0178    61  PUSH2 0x0180
	017B    57  *JUMPI
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @016B  memory[0x40:0x60] = stack[-2]
	//     @016E  memory[stack[-1]:stack[-1] + 0x20] = stack[-3]
	// }
	// Block ends with conditional jump to 0x0180, if !(stack[-5] + stack[-3] + 0x20 > stack[-9])

label_017C:
	// Incoming jump from 0x017B, if not !(stack[-5] + stack[-3] + 0x20 > stack[-9])
	// Inputs[1] { @017F  memory[0x00:0x00] }
	017C    60  PUSH1 0x00
	017E    80  DUP1
	017F    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @017F  revert(memory[0x00:0x00]); }
	// Block terminates

label_0180:
	// Incoming jump from 0x017B, if !(stack[-5] + stack[-3] + 0x20 > stack[-9])
	// Inputs[9]
	// {
	//     @0181  stack[-3]
	//     @0184  stack[-5]
	//     @0188  stack[-1]
	//     @018A  msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]]
	//     @0195  stack[-6]
	//     @019C  stack[-9]
	//     @019E  stack[-7]
	//     @019E  stack[-10]
	//     @019F  stack[-8]
	// }
	0180    5B  JUMPDEST
	0181    82  DUP3
	0182    60  PUSH1 0x20
	0184    86  DUP7
	0185    01  ADD
	0186    60  PUSH1 0x20
	0188    83  DUP4
	0189    01  ADD
	018A    37  CALLDATACOPY
	018B    60  PUSH1 0x00
	018D    60  PUSH1 0x20
	018F    84  DUP5
	0190    83  DUP4
	0191    01  ADD
	0192    01  ADD
	0193    52  MSTORE
	0194    80  DUP1
	0195    95  SWAP6
	0196    50  POP
	0197    50  POP
	0198    50  POP
	0199    50  POP
	019A    50  POP
	019B    50  POP
	019C    92  SWAP3
	019D    50  POP
	019E    92  SWAP3
	019F    90  SWAP1
	01A0    50  POP
	01A1    56  *JUMP
	// Stack delta = -8
	// Outputs[4]
	// {
	//     @018A  memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]]
	//     @0193  memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00
	//     @019C  stack[-9] = stack[-1]
	//     @019E  stack[-10] = stack[-7]
	// }
	// Block ends with unconditional jump to stack[-10]

	01A2    FE    *ASSERT
	01A3    A2    LOG2
	01A4    64    PUSH5 0x6970667358
	01AA    22    22
	01AB    12    SLT
	01AC    20    SHA3
	01AD    C8    C8
	01AE    4E    4E
	01AF    ED    ED
	01B0    3E    RETURNDATACOPY
	01B1    E8    E8
	01B2    82    DUP3
	01B3    04    DIV
	01B4    A6    A6
	01B5    1C    SHR
	01B6    6D    PUSH14 0x673aa561ff38b6b4430c9518de20
	01C5    F4    DELEGATECALL
	01C6    30    ADDRESS
	01C7    8A    DUP11
	01C8    14    EQ
	01C9    17    OR
	01CA    9B    SWAP12
	01CB    37    CALLDATACOPY
	01CC    D0    D0
	01CD    64    PUSH5 0x736f6c6343
	01D3    00    *STOP
	01D4    08    ADDMOD
	01D5    0B    SIGNEXTEND
	01D6    00    *STOP
	01D7    33    CALLER