Online Solidity Decompiler

« Decompile another contract

Address

0x6516298e1c94769432ef6d5f450579094e8c21fa [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x0f59f83a go()

Internal Methods

func_00B2() returns (r0)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x60;
        var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000;
    
        if (var0 != 0x0f59f83a) { stop(); }
    
        var var1 = 0x0044;
        var1 = func_00B2();
        var temp0 = memory[0x40:0x60];
        var var2 = temp0;
        var var3 = var2;
        var temp1 = var3 + 0x20;
        memory[var3:var3 + 0x20] = temp1 - var3;
        var temp2 = var1;
        memory[temp1:temp1 + 0x20] = memory[temp2:temp2 + 0x20];
        var temp3 = temp1 + 0x20;
        var temp4 = memory[temp2:temp2 + 0x20];
        memory[temp3:temp3 + temp4] = address(0x04).call.gas((temp4 + 0x1f) / 0x20 * 0x03 + 0x0f)(memory[temp2 + 0x20:temp2 + 0x20 + temp4]);
        var var4 = temp4 + temp3;
        var var5 = temp4 & 0x1f;
    
        if (!var5) {
            var temp5 = memory[0x40:0x60];
            return memory[temp5:temp5 + var4 - temp5];
        } else {
            var temp6 = var5;
            var temp7 = var4 - temp6;
            memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20];
            var temp8 = memory[0x40:0x60];
            return memory[temp8:temp8 + (temp7 + 0x20) - temp8];
        }
    }
    
    function func_00B2() returns (var r0) {
        var temp0 = memory[0x40:0x60];
        memory[0x40:0x60] = temp0 + 0x20;
        memory[temp0:temp0 + 0x20] = 0x00;
        var temp1 = memory[0x40:0x60];
        memory[0x40:0x60] = temp1 + 0x40;
        memory[temp1:temp1 + 0x20] = 0x03;
        memory[temp1 + 0x20:temp1 + 0x20 + 0x20] = 0x6574680000000000000000000000000000000000000000000000000000000000;
        var var0 = temp1;
        return var0;
    }
}

Disassembly

label_0000:
	// Inputs[1] { @0007  msg.data[0x00:0x20] }
	0000    60  PUSH1 0x60
	0002    60  PUSH1 0x40
	0004    52  MSTORE
	0005    60  PUSH1 0x00
	0007    35  CALLDATALOAD
	0008    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	0026    90  SWAP1
	0027    04  DIV
	0028    80  DUP1
	0029    63  PUSH4 0x0f59f83a
	002E    14  EQ
	002F    61  PUSH2 0x0039
	0032    57  *JUMPI
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @0004  memory[0x40:0x60] = 0x60
	//     @0027  stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000
	// }
	// Block ends with conditional jump to 0x0039, if 0x0f59f83a == msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000

label_0033:
	// Incoming jump from 0x0032, if not 0x0f59f83a == msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000
	0033    61  PUSH2 0x0037
	0036    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0037

label_0037:
	// Incoming jump from 0x0036
	0037    5B  JUMPDEST
	0038    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0038  stop(); }
	// Block terminates

label_0039:
	// Incoming jump from 0x0032, if 0x0f59f83a == msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000
	0039    5B  JUMPDEST
	003A    61  PUSH2 0x0044
	003D    60  PUSH1 0x04
	003F    50  POP
	0040    61  PUSH2 0x00b2
	0043    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @003A  stack[0] = 0x0044 }
	// Block ends with call to 0x00b2, returns to 0x0044

label_0044:
	// Incoming return from call to 0x00B2 at 0x0043
	// Inputs[6]
	// {
	//     @0047  memory[0x40:0x60]
	//     @0052  stack[-1]
	//     @0055  memory[stack[-1]:stack[-1] + 0x20]
	//     @005E  memory[stack[-1]:stack[-1] + 0x20]
	//     @007A  memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]
	//     @007A  address(0x04).call.gas(0x0f + 0x03 * ((0x1f + memory[stack[-1]:stack[-1] + 0x20]) / 0x20))(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]])
	// }
	0044    5B  JUMPDEST
	0045    60  PUSH1 0x40
	0047    51  MLOAD
	0048    80  DUP1
	0049    80  DUP1
	004A    60  PUSH1 0x20
	004C    01  ADD
	004D    82  DUP3
	004E    81  DUP2
	004F    03  SUB
	0050    82  DUP3
	0051    52  MSTORE
	0052    83  DUP4
	0053    81  DUP2
	0054    81  DUP2
	0055    51  MLOAD
	0056    81  DUP2
	0057    52  MSTORE
	0058    60  PUSH1 0x20
	005A    01  ADD
	005B    91  SWAP2
	005C    50  POP
	005D    80  DUP1
	005E    51  MLOAD
	005F    90  SWAP1
	0060    60  PUSH1 0x20
	0062    01  ADD
	0063    90  SWAP1
	0064    80  DUP1
	0065    83  DUP4
	0066    83  DUP4
	0067    82  DUP3
	0068    90  SWAP1
	0069    60  PUSH1 0x00
	006B    60  PUSH1 0x04
	006D    60  PUSH1 0x20
	006F    84  DUP5
	0070    60  PUSH1 0x1f
	0072    01  ADD
	0073    04  DIV
	0074    60  PUSH1 0x03
	0076    02  MUL
	0077    60  PUSH1 0x0f
	0079    01  ADD
	007A    F1  CALL
	007B    50  POP
	007C    90  SWAP1
	007D    50  POP
	007E    90  SWAP1
	007F    81  DUP2
	0080    01  ADD
	0081    90  SWAP1
	0082    60  PUSH1 0x1f
	0084    16  AND
	0085    80  DUP1
	0086    15  ISZERO
	0087    61  PUSH2 0x00a4
	008A    57  *JUMPI
	// Stack delta = +4
	// Outputs[7]
	// {
	//     @0047  stack[0] = memory[0x40:0x60]
	//     @0048  stack[1] = memory[0x40:0x60]
	//     @0051  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0057  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @007A  memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + memory[stack[-1]:stack[-1] + 0x20]] = address(0x04).call.gas(0x0f + 0x03 * ((0x1f + memory[stack[-1]:stack[-1] + 0x20]) / 0x20))(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]])
	//     @0081  stack[2] = memory[stack[-1]:stack[-1] + 0x20] + 0x20 + 0x20 + memory[0x40:0x60]
	//     @0084  stack[3] = 0x1f & memory[stack[-1]:stack[-1] + 0x20]
	// }
	// Block ends with conditional jump to 0x00a4, if !(0x1f & memory[stack[-1]:stack[-1] + 0x20])

label_008B:
	// Incoming jump from 0x008A, if not !(0x1f & memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[6]
	// {
	//     @008B  stack[-1]
	//     @008C  stack[-2]
	//     @008F  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @00A6  stack[-5]
	//     @00AC  memory[0x40:0x60]
	//     @00B1  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	008B    80  DUP1
	008C    82  DUP3
	008D    03  SUB
	008E    80  DUP1
	008F    51  MLOAD
	0090    60  PUSH1 0x01
	0092    83  DUP4
	0093    60  PUSH1 0x20
	0095    03  SUB
	0096    61  PUSH2 0x0100
	0099    0A  EXP
	009A    03  SUB
	009B    19  NOT
	009C    16  AND
	009D    81  DUP2
	009E    52  MSTORE
	009F    60  PUSH1 0x20
	00A1    01  ADD
	00A2    91  SWAP2
	00A3    50  POP
	00A4    5B  JUMPDEST
	00A5    50  POP
	00A6    92  SWAP3
	00A7    50  POP
	00A8    50  POP
	00A9    50  POP
	00AA    60  PUSH1 0x40
	00AC    51  MLOAD
	00AD    80  DUP1
	00AE    91  SWAP2
	00AF    03  SUB
	00B0    90  SWAP1
	00B1    F3  *RETURN
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @009E  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @00B1  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]];
	// }
	// Block terminates

label_00B2:
	// Incoming call from 0x0043, returns to 0x0044
	// Inputs[2]
	// {
	//     @00B7  memory[0x40:0x60]
	//     @00CB  memory[0x40:0x60]
	// }
	00B2    5B  JUMPDEST
	00B3    60  PUSH1 0x20
	00B5    60  PUSH1 0x40
	00B7    51  MLOAD
	00B8    90  SWAP1
	00B9    81  DUP2
	00BA    01  ADD
	00BB    60  PUSH1 0x40
	00BD    52  MSTORE
	00BE    80  DUP1
	00BF    60  PUSH1 0x00
	00C1    81  DUP2
	00C2    52  MSTORE
	00C3    60  PUSH1 0x20
	00C5    01  ADD
	00C6    50  POP
	00C7    60  PUSH1 0x40
	00C9    60  PUSH1 0x40
	00CB    51  MLOAD
	00CC    90  SWAP1
	00CD    81  DUP2
	00CE    01  ADD
	00CF    60  PUSH1 0x40
	00D1    52  MSTORE
	00D2    80  DUP1
	00D3    60  PUSH1 0x03
	00D5    81  DUP2
	00D6    52  MSTORE
	00D7    60  PUSH1 0x20
	00D9    01  ADD
	00DA    7F  PUSH32 0x6574680000000000000000000000000000000000000000000000000000000000
	00FB    81  DUP2
	00FC    52  MSTORE
	00FD    60  PUSH1 0x20
	00FF    01  ADD
	0100    50  POP
	0101    90  SWAP1
	0102    50  POP
	0103    61  PUSH2 0x0107
	0106    56  *JUMP
	// Stack delta = +1
	// Outputs[6]
	// {
	//     @00BD  memory[0x40:0x60] = memory[0x40:0x60] + 0x20
	//     @00C2  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00
	//     @00D1  memory[0x40:0x60] = memory[0x40:0x60] + 0x40
	//     @00D6  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03
	//     @00FC  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x6574680000000000000000000000000000000000000000000000000000000000
	//     @0101  stack[0] = memory[0x40:0x60]
	// }
	// Block ends with unconditional jump to 0x0107

label_0107:
	// Incoming jump from 0x0106
	// Inputs[2]
	// {
	//     @0108  stack[-1]
	//     @0108  stack[-2]
	// }
	0107    5B  JUMPDEST
	0108    90  SWAP1
	0109    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @0108  stack[-2] = stack[-1] }
	// Block ends with unconditional jump to stack[-2]