LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zerolfx[P]P-Machine/out.cpp
// Function: Out::print(std::ostream&) const
ostream& Out::print(ostream &os) const
{
	if(fPrecisionMarker)
		os << "out r i";
	else
		os << "out " << printStackElementType(fType);
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0xc(%rax)
je 0x25250
movq -0x10(%rbp), %rdi
leaq 0x14fcf(%rip), %rsi     # 0x3a218
callq 0x7250
jmp 0x252ac
movq -0x10(%rbp), %rdi
leaq 0x14fc5(%rip), %rsi     # 0x3a220
callq 0x7250
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x58(%rbp)
movl 0x8(%rax), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x8750
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x7240
jmp 0x2528a
leaq -0x30(%rbp), %rdi
callq 0x7170
jmp 0x252ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7170
jmp 0x252b6
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x74e0
nop
// File: zerolfx[P]P-Machine/stackaddress.cpp
// Function: StackAddress::equ(StackElement const*) const
bool StackAddress::equ(const StackElement *kOp) const
{
	const StackAddress *op1 = dynamic_cast<const StackAddress*>(kOp);
	if(fAddress == op1->fAddress)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x26a97
movq -0x28(%rbp), %rdi
leaq 0x23fa7(%rip), %rsi     # 0x4aa28
leaq 0x23ed0(%rip), %rdx     # 0x4a958
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x26a9f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x26a9f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x26abd
movb $0x1, -0x1(%rbp)
jmp 0x26ac1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackaddress.cpp
// Function: StackAddress::les(StackElement const*) const
bool StackAddress::les(const StackElement *kOp) const
{
	const StackAddress *op1 = dynamic_cast<const StackAddress*>(kOp);
	if(fAddress < op1->fAddress)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x26b17
movq -0x28(%rbp), %rdi
leaq 0x23f27(%rip), %rsi     # 0x4aa28
leaq 0x23e50(%rip), %rdx     # 0x4a958
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x26b1f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x26b1f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x26b3d
movb $0x1, -0x1(%rbp)
jmp 0x26b41
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackaddress.cpp
// Function: StackAddress::grt(StackElement const*) const
bool StackAddress::grt(const StackElement *kOp) const
{
	const StackAddress *op1 = dynamic_cast<const StackAddress*>(kOp);
	if(fAddress > op1->fAddress)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x26b97
movq -0x28(%rbp), %rdi
leaq 0x23ea7(%rip), %rsi     # 0x4aa28
leaq 0x23dd0(%rip), %rdx     # 0x4a958
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x26b9f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x26b9f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x26bbd
movb $0x1, -0x1(%rbp)
jmp 0x26bc1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackinteger.cpp
// Function: StackInteger::equ(StackElement const*) const
bool StackInteger::equ(const StackElement *kOp) const
{
	const StackInteger *op1 = dynamic_cast<const StackInteger*>(kOp);
	if(fInteger == op1->fInteger)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x27657
movq -0x28(%rbp), %rdi
leaq 0x233e7(%rip), %rsi     # 0x4aa28
leaq 0x234a8(%rip), %rdx     # 0x4aaf0
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x2765f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2765f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x2767d
movb $0x1, -0x1(%rbp)
jmp 0x27681
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackinteger.cpp
// Function: StackInteger::les(StackElement const*) const
bool StackInteger::les(const StackElement *kOp) const
{
	const StackInteger *op1 = dynamic_cast<const StackInteger*>(kOp);
	if(fInteger < op1->fInteger)
		return true;
	else
		return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x276d7
movq -0x28(%rbp), %rdi
leaq 0x23367(%rip), %rsi     # 0x4aa28
leaq 0x23428(%rip), %rdx     # 0x4aaf0
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x276df
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x276df
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x276fd
movb $0x1, -0x1(%rbp)
jmp 0x27701
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackinteger.cpp
// Function: StackInteger::grt(StackElement const*) const
bool StackInteger::grt(const StackElement *kOp) const
{
	const StackInteger *op1 = dynamic_cast<const StackInteger*>(kOp);
	if(fInteger > op1->fInteger)
		return true;
	else
		return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x27757
movq -0x28(%rbp), %rdi
leaq 0x232e7(%rip), %rsi     # 0x4aa28
leaq 0x233a8(%rip), %rdx     # 0x4aaf0
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x2775f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2775f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x2777d
movb $0x1, -0x1(%rbp)
jmp 0x27781
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackreal.cpp
// Function: StackReal::equ(StackElement const*) const
bool StackReal::equ(const StackElement *kOp) const
{
	const StackReal *op1 = dynamic_cast<const StackReal*>(kOp);
	if(fReal == op1->fReal)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x27b17
movq -0x28(%rbp), %rdi
leaq 0x22f27(%rip), %rsi     # 0x4aa28
leaq 0x230b8(%rip), %rdx     # 0x4abc0
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x27b1f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x27b1f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x27b43
jp 0x27b43
movb $0x1, -0x1(%rbp)
jmp 0x27b47
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zerolfx[P]P-Machine/stackreal.cpp
// Function: StackReal::les(StackElement const*) const
bool StackReal::les(const StackElement *kOp) const
{
	const StackReal *op1 = dynamic_cast<const StackReal*>(kOp);
	if(fReal < op1->fReal)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x27ba7
movq -0x28(%rbp), %rdi
leaq 0x22e97(%rip), %rsi     # 0x4aa28
leaq 0x23028(%rip), %rdx     # 0x4abc0
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x27baf
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x27baf
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movsd 0x8(%rax), %xmm1
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x27bd5
movb $0x1, -0x1(%rbp)
jmp 0x27bd9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zerolfx[P]P-Machine/stackboolean.cpp
// Function: StackBoolean::equ(StackElement const*) const
bool StackBoolean::equ(const StackElement *kOp) const
{
	const StackBoolean *op1 = dynamic_cast<const StackBoolean*>(kOp);
	if(fBoolean == op1->fBoolean)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x27dd7
movq -0x28(%rbp), %rdi
leaq 0x22c67(%rip), %rsi     # 0x4aa28
leaq 0x22ec8(%rip), %rdx     # 0x4ac90
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x27ddf
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x27ddf
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x27dfd
movb $0x1, -0x1(%rbp)
jmp 0x27e01
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackboolean.cpp
// Function: StackBoolean::les(StackElement const*) const
bool StackBoolean::les(const StackElement *kOp) const
{
	const StackBoolean *op1 = dynamic_cast<const StackBoolean*>(kOp);
	if(fBoolean < op1->fBoolean)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x27e57
movq -0x28(%rbp), %rdi
leaq 0x22be7(%rip), %rsi     # 0x4aa28
leaq 0x22e48(%rip), %rdx     # 0x4ac90
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x27e5f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x27e5f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x27e7d
movb $0x1, -0x1(%rbp)
jmp 0x27e81
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackboolean.cpp
// Function: StackBoolean::grt(StackElement const*) const
bool StackBoolean::grt(const StackElement *kOp) const
{
	const StackBoolean *op1 = dynamic_cast<const StackBoolean*>(kOp);
	if(fBoolean > op1->fBoolean)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x27ed7
movq -0x28(%rbp), %rdi
leaq 0x22b67(%rip), %rsi     # 0x4aa28
leaq 0x22dc8(%rip), %rdx     # 0x4ac90
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x27edf
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x27edf
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x27efd
movb $0x1, -0x1(%rbp)
jmp 0x27f01
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackboolean.cpp
// Function: StackBoolean::print(std::ostream&) const
ostream& StackBoolean::print(ostream &os) const
{
	if(fBoolean)
		os << 't';
	else
		os << 'f';
	return os;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x2813a
movq -0x10(%rbp), %rdi
movl $0x74, %esi
callq 0x7330
jmp 0x28148
movq -0x10(%rbp), %rdi
movl $0x66, %esi
callq 0x7330
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zerolfx[P]P-Machine/stackcharacter.cpp
// Function: StackCharacter::equ(StackElement const*) const
bool StackCharacter::equ(const StackElement *kOp) const
{
	const StackCharacter *op1 = dynamic_cast<const StackCharacter*>(kOp);
	if(fCharacter == op1->fCharacter)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x28217
movq -0x28(%rbp), %rdi
leaq 0x22827(%rip), %rsi     # 0x4aa28
leaq 0x22b58(%rip), %rdx     # 0x4ad60
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x2821f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2821f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movsbl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x28241
movb $0x1, -0x1(%rbp)
jmp 0x28245
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: zerolfx[P]P-Machine/stackcharacter.cpp
// Function: StackCharacter::les(StackElement const*) const
bool StackCharacter::les(const StackElement *kOp) const
{
	const StackCharacter *op1 = dynamic_cast<const StackCharacter*>(kOp);
	if(fCharacter < op1->fCharacter)
		return true;
	else
		return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x28297
movq -0x28(%rbp), %rdi
leaq 0x227a7(%rip), %rsi     # 0x4aa28
leaq 0x22ad8(%rip), %rdx     # 0x4ad60
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x2829f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2829f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movsbl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x282c1
movb $0x1, -0x1(%rbp)
jmp 0x282c5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: zerolfx[P]P-Machine/stackcharacter.cpp
// Function: StackCharacter::grt(StackElement const*) const
bool StackCharacter::grt(const StackElement *kOp) const
{
	const StackCharacter *op1 = dynamic_cast<const StackCharacter*>(kOp);
	if(fCharacter > op1->fCharacter)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x28317
movq -0x28(%rbp), %rdi
leaq 0x22727(%rip), %rsi     # 0x4aa28
leaq 0x22a58(%rip), %rdx     # 0x4ad60
xorl %eax, %eax
movl %eax, %ecx
callq 0x7320
movq %rax, -0x38(%rbp)
jmp 0x2831f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2831f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movsbl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jle 0x28341
movb $0x1, -0x1(%rbp)
jmp 0x28345
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: zerolfx[P]P-Machine/labelcenter.cpp
// Function: LabelCenter::getAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int LabelCenter::getAddress(const string &kLabel)
{
	map<string, int>::iterator it = fLabels.find(kLabel);
	
	if(it == fLabels.end())
	{
		throw ExecutionError("label " + kLabel + " was not defined");
	}
	
	return fLabels[kLabel] - 1;	/* correction of "-1" because of the fact that the machine
						automatically increments the PC */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rsi
callq 0x288f0
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x28950
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x28920
testb $0x1, %al
jne 0x2855b
jmp 0x28612
movb $0x1, -0x6d(%rbp)
movl $0x20, %edi
callq 0x7110
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x1224d(%rip), %rsi     # 0x3a7c5
leaq -0x60(%rbp), %rdi
callq 0x289d0
jmp 0x28583
leaq 0x12242(%rip), %rdx     # 0x3a7cc
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x28980
jmp 0x28599
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x283d0
jmp 0x285a8
movq -0x80(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0x214c9(%rip), %rsi     # 0x49a80
leaq -0x1be(%rip), %rdx      # 0x28400
callq 0x74a0
jmp 0x28636
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x285ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x285f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7170
leaq -0x60(%rbp), %rdi
callq 0x7170
testb $0x1, -0x6d(%rbp)
jne 0x28607
jmp 0x28610
movq -0x80(%rbp), %rdi
callq 0x71c0
jmp 0x2862d
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x28ae0
movl (%rax), %eax
subl $0x1, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x74e0
nopw %cs:(%rax,%rax)
// File: zerolfx[P]P-Machine/labelcenter.cpp
// Function: LabelCenter::addAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void LabelCenter::addAddress(const string &kLabel, int location)
{
	map<string, int>::iterator it = fLabels.find(kLabel);
	
	if(it != fLabels.end())
	{
		throw CompileTimeError("Label " + kLabel + " is being redeclared");
	}
	
	fLabels.insert(map<string, int>::value_type(kLabel, location));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x288f0
movq -0xb8(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x28950
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x28bc0
testb $0x1, %al
jne 0x28694
jmp 0x2875d
movb $0x1, -0x75(%rbp)
movl $0x20, %edi
callq 0x7110
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x12129(%rip), %rsi     # 0x3a7dd
leaq -0x68(%rbp), %rdi
callq 0x289d0
jmp 0x286bf
leaq 0x1211e(%rip), %rdx     # 0x3a7e4
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x28980
jmp 0x286d5
movq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x28450
jmp 0x286e7
movq -0xc0(%rbp), %rdi
movb $0x0, -0x75(%rbp)
leaq 0x2267f(%rip), %rsi     # 0x4ad78
leaq -0x280(%rip), %rdx      # 0x28480
callq 0x74a0
jmp 0x287ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x28744
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2873b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7170
leaq -0x68(%rbp), %rdi
callq 0x7170
testb $0x1, -0x75(%rbp)
jne 0x2874c
jmp 0x28758
movq -0xc0(%rbp), %rdi
callq 0x71c0
jmp 0x287e1
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x14(%rbp), %rdx
callq 0x28c30
movq -0xb8(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x28bf0
movb %dl, -0xc9(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x2879a
movb -0xc9(%rbp), %al
movq -0xc8(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movb %al, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x28c70
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x28c70
movq -0x70(%rbp), %rdi
callq 0x74e0
nopw (%rax,%rax)
// File: zerolfx[P]P-Machine/timecounter.cpp
// Function: TimeCounter::count(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void TimeCounter::count(const string &kInstruction)
{
	map<string, int>::iterator it = fWeights.find(kInstruction);
	
	if(it == fWeights.end())
	{
		cerr << "illegal instruction entered for counting purposes" << endl;
	}

	fCounter += fWeights[kInstruction];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x288f0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x28950
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x28920
testb $0x1, %al
jne 0x2c515
jmp 0x2c537
movq 0x1ead4(%rip), %rdi     # 0x4aff0
leaq 0xe2f4(%rip), %rsi      # 0x3a817
callq 0x7250
movq %rax, %rdi
movq 0x1ea76(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x28ae0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
addl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::run()
void StackMachine::run()
{
	fPC = 0;
	while(fHaltrequested == false)
	{
		if(fPC >= fIC)
		{
			throw ExecutionError("PC has exceeded maximum number of instructions.");
			cerr << "End reached" << endl;
			return;
		}
		else
		{
			if(fStepping)
			{
				printCurrentInstruction();
			}
			fCode[fPC]->execute(this);
			if(fStepping)
			{
				showStack();
				showHeap();
				showParameters();
				continueStep();
			}
			++fPC;
			++fStepCounter;
		}
	}
	
	// print the execution-time
	cout << endl << "--> Execution time: " << fTime.getTime() << endl << endl;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, 0xb0(%rax)
movq -0x48(%rbp), %rax
movb 0xc4(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2ca7d
movq -0x48(%rbp), %rcx
movl 0xb0(%rcx), %eax
cmpl 0xc8(%rcx), %eax
jl 0x2c9f2
movb $0x1, -0x3d(%rbp)
movl $0x20, %edi
callq 0x7110
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x74f0
movq -0x50(%rbp), %rdx
leaq 0xded3(%rip), %rsi      # 0x3a849
leaq -0x28(%rbp), %rdi
callq 0x8940
jmp 0x2c981
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x283d0
jmp 0x2c990
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x1d0e1(%rip), %rsi     # 0x49a80
leaq -0x45a6(%rip), %rdx     # 0x28400
callq 0x74a0
jmp 0x2cae8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2c9d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7170
leaq -0x29(%rbp), %rdi
callq 0x72e0
testb $0x1, -0x3d(%rbp)
jne 0x2c9e4
jmp 0x2c9ed
movq -0x58(%rbp), %rdi
callq 0x71c0
jmp 0x2cadf
movq -0x48(%rbp), %rax
testb $0x1, 0xcc(%rax)
je 0x2ca08
movq -0x48(%rbp), %rdi
callq 0x2caf0
movq -0x48(%rbp), %rdi
movslq 0xb0(%rdi), %rsi
callq 0x2d400
movq -0x48(%rbp), %rsi
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x48(%rbp), %rax
testb $0x1, 0xcc(%rax)
je 0x2ca56
movq -0x48(%rbp), %rdi
callq 0x2cb50
movq -0x48(%rbp), %rdi
callq 0x2ccc0
movq -0x48(%rbp), %rdi
callq 0x2cde0
movq -0x48(%rbp), %rdi
callq 0x2cf10
movq -0x48(%rbp), %rax
movl 0xb0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb0(%rax)
movl 0xd8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xd8(%rax)
jmp 0x2c91e
movq 0x1e53c(%rip), %rdi     # 0x4afc0
movq 0x1e51d(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq %rax, %rdi
leaq 0xdddf(%rip), %rsi      # 0x3a879
callq 0x7250
movq -0x48(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x78, %rdi
callq 0x2c560
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0x74c0
movq %rax, %rdi
movq 0x1e4e3(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq %rax, %rdi
movq 0x1e4d4(%rip), %rsi     # 0x4afa8
callq 0x72b0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x74e0
nopl (%rax,%rax)
// File: zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::showStack()
void StackMachine::showStack()
{
	int beginvalue;
	
	if(fStackSize == 0)
	{
		beginvalue = 0;
	}
	else
	{
		if(fStore.size() - fStackSize < 0)
		{
			beginvalue = 0;
		}
		else
		{
			beginvalue = fStore.size() - fStackSize;
		}
	}
	
	for(int i = beginvalue; i < fStore.size(); ++i)
	{
		cout << "\t[" << i << "]\t\t" << "[" << fStore[i]->getType() << "]\t" << *fStore[i] << endl;
	}
	cout << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0xd4(%rax)
jne 0x2cb76
movl $0x0, -0xc(%rbp)
jmp 0x2cbc0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xd9b0
movq -0x18(%rbp), %rcx
movslq 0xd4(%rcx), %rcx
subq %rcx, %rax
cmpq $0x0, %rax
jae 0x2cba0
movl $0x0, -0xc(%rbp)
jmp 0x2cbbe
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xd9b0
movq -0x18(%rbp), %rcx
movslq 0xd4(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0xc(%rbp)
jmp 0x2cbc0
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0xd9b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2cca1
movq 0x1e3ce(%rip), %rdi     # 0x4afc0
leaq 0xdccd(%rip), %rsi      # 0x3a8c6
callq 0x7250
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x74c0
movq %rax, %rdi
leaq 0xdcb6(%rip), %rsi      # 0x3a8c9
callq 0x7250
movq %rax, %rdi
leaq 0xdca5(%rip), %rsi      # 0x3a8c7
callq 0x7250
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8e70
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movq -0x30(%rbp), %rdi
movsbl %al, %esi
callq 0x7330
movq %rax, %rdi
leaq 0xdc6f(%rip), %rsi      # 0x3a8cd
callq 0x7250
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8e70
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x27170
movq %rax, %rdi
movq 0x1e31a(%rip), %rsi     # 0x4afa8
callq 0x72b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2cbc6
movq 0x1e318(%rip), %rdi     # 0x4afc0
movq 0x1e2f9(%rip), %rsi     # 0x4afa8
callq 0x72b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::showHeap()
void StackMachine::showHeap()
{
	if(fShowHeap)
	{
		for(int i = -1; i >= fNP; --i)
		{
			cout << "\t[" << i << "]\t\t" << "[" << fHeap[-i-1]->getType() << "]\t" << *fHeap[-i-1] << endl;
		}
		cout << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0xcd(%rax)
je 0x2cdd2
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xb8(%rcx), %eax
jl 0x2cdbf
movq 0x1e2be(%rip), %rdi     # 0x4afc0
leaq 0xdbbd(%rip), %rsi      # 0x3a8c6
callq 0x7250
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x74c0
movq %rax, %rdi
leaq 0xdba6(%rip), %rsi      # 0x3a8c9
callq 0x7250
movq %rax, %rdi
leaq 0xdb95(%rip), %rsi      # 0x3a8c7
callq 0x7250
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
xorl %eax, %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8e70
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movq -0x28(%rbp), %rdi
movsbl %al, %esi
callq 0x7330
movq %rax, %rdi
leaq 0xdb58(%rip), %rsi      # 0x3a8cd
callq 0x7250
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
xorl %eax, %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8e70
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x27170
movq %rax, %rdi
movq 0x1e1fc(%rip), %rsi     # 0x4afa8
callq 0x72b0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2cce8
movq 0x1e1fa(%rip), %rdi     # 0x4afc0
movq 0x1e1db(%rip), %rsi     # 0x4afa8
callq 0x72b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::continueStep()
void StackMachine::continueStep()
{
	if(fStepCounter == fStepSize)
	{
		cout << "Press [c] + [Enter] to continue. Other key to end." << endl;
		char space;
		cin >> space;
		switch(space)
		{
			case 'c': 
			case 'C': break;
			default: exit(0);
		}
		fStepCounter = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0xd8(%rcx), %eax
cmpl 0xd0(%rcx), %eax
jne 0x2cf89
movq 0x1e087(%rip), %rdi     # 0x4afc0
leaq 0xd94e(%rip), %rsi      # 0x3a88e
callq 0x7250
movq %rax, %rdi
movq 0x1e059(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq 0x1e07d(%rip), %rdi     # 0x4afd8
leaq -0x9(%rbp), %rsi
callq 0x73b0
movsbl -0x9(%rbp), %eax
orl $0x20, %eax
subl $0x63, %eax
je 0x2cf72
jmp 0x2cf74
jmp 0x2cf7b
xorl %edi, %edi
callq 0x7360
movq -0x18(%rbp), %rax
movl $0x0, 0xd8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::base(int, int)
int StackMachine::base(int p, int a)
{
	if (p == 0)
		return a;
	else
	{
		if(a+1 > fSP)
		{
			strstream errormessage;
			errormessage << "base(" << p << "," << a << ") is trying to access a memorylocation above STORE[SP]";
			throw ExecutionError(errormessage.str());
		}
		else
		{
			return base(p - 1, fStore[a+1]->getValue());
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2d081
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2d276
movq -0x1d0(%rbp), %rcx
movl -0x18(%rbp), %eax
addl $0x1, %eax
cmpl 0xb4(%rcx), %eax
jle 0x2d231
leaq -0x190(%rbp), %rdi
callq 0x73d0
leaq -0x180(%rbp), %rdi
leaq 0xd846(%rip), %rsi      # 0x3a8fa
callq 0x7250
movq %rax, -0x1d8(%rbp)
jmp 0x2d0c2
movq -0x1d8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x74c0
movq %rax, -0x1e0(%rbp)
jmp 0x2d0da
movq -0x1e0(%rbp), %rdi
leaq 0xd7fc(%rip), %rsi      # 0x3a8e4
callq 0x7250
movq %rax, -0x1e8(%rbp)
jmp 0x2d0f6
movq -0x1e8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x74c0
movq %rax, -0x1f0(%rbp)
jmp 0x2d10e
movq -0x1f0(%rbp), %rdi
leaq 0xd7e4(%rip), %rsi      # 0x3a900
callq 0x7250
jmp 0x2d123
movb $0x1, -0x1c2(%rbp)
movl $0x20, %edi
callq 0x7110
movq %rax, -0x208(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x7410
movq %rax, -0x200(%rbp)
leaq -0x1c1(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x74f0
movq -0x200(%rbp), %rsi
movq -0x1f8(%rbp), %rdx
leaq -0x1c0(%rbp), %rdi
callq 0x8940
jmp 0x2d17d
movq -0x208(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x283d0
jmp 0x2d192
movq -0x208(%rbp), %rdi
movb $0x0, -0x1c2(%rbp)
leaq 0x1c8d9(%rip), %rsi     # 0x49a80
leaq -0x4dae(%rip), %rdx     # 0x28400
callq 0x74a0
jmp 0x2d28e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x2d223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x2d1fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x7170
leaq -0x1c1(%rbp), %rdi
callq 0x72e0
testb $0x1, -0x1c2(%rbp)
jne 0x2d215
jmp 0x2d221
movq -0x208(%rbp), %rdi
callq 0x71c0
jmp 0x2d223
leaq -0x190(%rbp), %rdi
callq 0x7520
jmp 0x2d282
movq -0x1d0(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20c(%rbp)
addq $0x18, %rdi
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x8e70
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x1d0(%rbp), %rdi
movl -0x20c(%rbp), %esi
movl %eax, %edx
callq 0x2d050
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x74e0
nop
// File: zerolfx[P]P-Machine/main.cpp
// Function: usage()
void usage()
{
	cout << "USAGE: Pmachine [filename] <-s [numeric value]> <-t [numeric value]> <-h>" << endl << endl;
	cout << "\t -s: stepsize" << endl;
	cout << "\t -t: number of stackplaces to show\t(by default all)" << endl;
	cout << "\t -h: show heap" << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1d0c5(%rip), %rdi     # 0x4afc0
leaq 0xca35(%rip), %rsi      # 0x3a937
callq 0x7250
movq %rax, %rdi
movq 0x1d097(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq %rax, %rdi
movq 0x1d088(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq 0x1d094(%rip), %rdi     # 0x4afc0
leaq 0xca4e(%rip), %rsi      # 0x3a981
callq 0x7250
movq %rax, %rdi
movq 0x1d066(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq 0x1d072(%rip), %rdi     # 0x4afc0
leaq 0xca3b(%rip), %rsi      # 0x3a990
callq 0x7250
movq %rax, %rdi
movq 0x1d044(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq 0x1d050(%rip), %rdi     # 0x4afc0
leaq 0xca4e(%rip), %rsi      # 0x3a9c5
callq 0x7250
movq %rax, %rdi
movq 0x1d022(%rip), %rsi     # 0x4afa8
callq 0x72b0
movq %rax, %rdi
movq 0x1d013(%rip), %rsi     # 0x4afa8
callq 0x72b0
popq %rbp
retq
nopl (%rax)
// File: calebstewart[P]md5/./examples/iterative.cpp
// Function: main
int main(int argc, char** argv)
{
  char digest[33];
  unsigned char hash[16];
  char chunk[512];
  MD5 md5;
  std::fstream data_file;

  // Open the executable itself for reading
  data_file.open(argv[0], std::ios::in);

  // Read until there's no more data and add it to the hash
  do {
    data_file.read(chunk, 512);
    md5.update(chunk, data_file.gcount());
  } while ( ! data_file.eof() );

  // Retrieve the final hash
  md5.finalize(hash);

  // If you'd like to reuse the MD5 object to calculate new hashes,
  // you must call reset to ensure you don't continue calculating from
  // the previous data.
  // md5.reset();

  // Output a hex digest
  MD5::digest(hash, digest);
  std::cout << "md5sum " << argv[0] << " => \"" << digest << "\"\n";

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x5a0, %rsp            # imm = 0x5A0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x340(%rbp), %rdi
callq 0x1230
leaq -0x550(%rbp), %rdi
movq %rdi, -0x568(%rbp)
callq 0x1090
movq -0x568(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x8, %edx
callq 0x1070
jmp 0x2f72
jmp 0x2f74
leaq -0x550(%rbp), %rdi
leaq -0x250(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x10a0
jmp 0x2f8e
leaq -0x250(%rbp), %rax
movq %rax, -0x578(%rbp)
leaq -0x550(%rbp), %rdi
callq 0x10e0
movq %rax, -0x570(%rbp)
jmp 0x2fb1
movq -0x570(%rbp), %rdx
movq -0x578(%rbp), %rsi
leaq -0x340(%rbp), %rdi
callq 0x12c0
jmp 0x2fcd
jmp 0x2fcf
movq -0x550(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x550(%rbp,%rax), %rdi
callq 0x10d0
movb %al, -0x579(%rbp)
jmp 0x2fef
movb -0x579(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f74
leaq -0x340(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2bb0
jmp 0x3011
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2e90
jmp 0x3020
movq 0x2fb1(%rip), %rdi      # 0x5fd8
leaq 0xff3(%rip), %rsi       # 0x4021
callq 0x1080
movq %rax, -0x588(%rbp)
jmp 0x303c
movq -0x588(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1080
movq %rax, -0x590(%rbp)
jmp 0x3058
movq -0x590(%rbp), %rdi
leaq 0xfc3(%rip), %rsi       # 0x4029
callq 0x1080
movq %rax, -0x598(%rbp)
jmp 0x3074
movq -0x598(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1080
movq %rax, -0x5a0(%rbp)
jmp 0x308d
movq -0x5a0(%rbp), %rdi
leaq 0xf94(%rip), %rsi       # 0x402f
callq 0x1080
jmp 0x30a2
movl $0x0, -0x4(%rbp)
leaq -0x550(%rbp), %rdi
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x5a0, %rsp            # imm = 0x5A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x558(%rbp)
movl %eax, -0x55c(%rbp)
leaq -0x550(%rbp), %rdi
callq 0x1030
movq -0x558(%rbp), %rdi
callq 0x10c0
// File: pstuifzand[P]magento-tools/src/position.cpp
// Function: root_start_element_handler(void*, char const*, char const**)
void root_start_element_handler(void* udata, const XML_Char* name, const XML_Char** atts)
{
    user_data* data = (user_data*)udata;
    data->stack.push_back(std::string(name));

    if (data->state == State::NOT_FOUND) {
        if (XML_GetCurrentLineNumber(data->parser->handle()) >= data->line
         && XML_GetCurrentColumnNumber(data->parser->handle()) >= data->col) {
            data->state = State::FOUND;
            print_stack(data->stack.begin(), data->stack.end());
            std::cout << "\n";
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2320
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x2d80
jmp 0x2603
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2d50
jmp 0x2612
leaq -0x40(%rbp), %rdi
callq 0x2110
leaq -0x41(%rbp), %rdi
callq 0x2220
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x26f9
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2e30
movq %rax, %rdi
callq 0x2120
movq -0x20(%rbp), %rcx
movslq 0x28(%rcx), %rcx
cmpq %rcx, %rax
jb 0x26f7
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2e30
movq %rax, %rdi
callq 0x21d0
movq -0x20(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
cmpq %rcx, %rax
jb 0x26f7
movq -0x20(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x2ef0
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x2f20
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2e50
movq 0x590d(%rip), %rdi      # 0x7fc8
leaq 0x2952(%rip), %rsi      # 0x5014
callq 0x21e0
jmp 0x26f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x26ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2110
leaq -0x41(%rbp), %rdi
callq 0x2220
jmp 0x2702
jmp 0x26f9
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: pstuifzand[P]magento-tools/src/position.cpp
// Function: root_end_element_handler(void*, char const*)
void root_end_element_handler(void* udata, const XML_Char* name)
{
    user_data* data = (user_data*)udata;
    if (data->state == State::NOT_FOUND) {
        if (XML_GetCurrentLineNumber(data->parser->handle()) >= data->line
         && XML_GetCurrentColumnNumber(data->parser->handle()) >= data->col) {
            data->state = State::FOUND;
            print_stack(data->stack.begin(), data->stack.end());
            std::cout << "\n";
        }
    }
    data->stack.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x27c9
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2e30
movq %rax, %rdi
callq 0x2120
movq -0x18(%rbp), %rcx
movslq 0x28(%rcx), %rcx
cmpq %rcx, %rax
jb 0x27c7
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2e30
movq %rax, %rdi
callq 0x21d0
movq -0x18(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
cmpq %rcx, %rax
jb 0x27c7
movq -0x18(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2ef0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2f20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2e50
movq 0x580d(%rip), %rdi      # 0x7fc8
leaq 0x2852(%rip), %rsi      # 0x5014
callq 0x21e0
jmp 0x27c9
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2f50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: pstuifzand[P]magento-tools/src/position.cpp
// Function: character_data_handler(void*, char const*, int)
void character_data_handler(void* udata, const XML_Char* s, int len)
{
    user_data* data = (user_data*)udata;
    if (data->state == State::NOT_FOUND) {
        if (XML_GetCurrentLineNumber(data->parser->handle()) >= data->line
         && XML_GetCurrentColumnNumber(data->parser->handle()) >= data->col) {
            data->state = State::FOUND;
            print_stack(data->stack.begin(), data->stack.end());
            std::cout << "\n";
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x289c
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2e30
movq %rax, %rdi
callq 0x2120
movq -0x20(%rbp), %rcx
movslq 0x28(%rcx), %rcx
cmpq %rcx, %rax
jb 0x289a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2e30
movq %rax, %rdi
callq 0x21d0
movq -0x20(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
cmpq %rcx, %rax
jb 0x289a
movq -0x20(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x2ef0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x2f20
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2e50
movq 0x573a(%rip), %rdi      # 0x7fc8
leaq 0x277f(%rip), %rsi      # 0x5014
callq 0x21e0
jmp 0x289c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pstuifzand[P]magento-tools/src/position.cpp
// Function: void print_stack<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>)
void print_stack(I p, I l)
{
    if (p != l) { std::cout << *p; ++p; }
    while (p != l) {
        std::cout << "/" << *p;
        ++p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x49b0
testb $0x1, %al
jne 0x2e73
jmp 0x2e94
leaq -0x8(%rbp), %rdi
callq 0x4970
movq %rax, %rsi
movq 0x5142(%rip), %rdi      # 0x7fc8
callq 0x21a0
leaq -0x8(%rbp), %rdi
callq 0x49f0
jmp 0x2e96
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x49b0
testb $0x1, %al
jne 0x2ea9
jmp 0x2ee0
movq 0x5118(%rip), %rdi      # 0x7fc8
leaq 0x21a8(%rip), %rsi      # 0x505f
callq 0x21e0
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4970
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x21a0
leaq -0x8(%rbp), %rdi
callq 0x49f0
jmp 0x2e96
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pstuifzand[P]magento-tools/src/position.cpp
// Function: _gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> find_backward_if_not<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int (*)(int) noexcept>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int (*)(int) noexcept)
I find_backward_if_not(I f, I l, P p)
{
    if (f == l) return l;
    while (f != l) {
        --l;
        if (!isspace(*l)) break;
    }
    return ++l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3ba0
testb $0x1, %al
jne 0x3b37
jmp 0x3b41
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b89
jmp 0x3b43
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3be0
testb $0x1, %al
jne 0x3b56
jmp 0x3b79
leaq -0x18(%rbp), %rdi
callq 0x3c20
leaq -0x18(%rbp), %rdi
callq 0x3ab0
movsbl (%rax), %edi
callq 0x2390
cmpl $0x0, %eax
jne 0x3b77
jmp 0x3b79
jmp 0x3b43
leaq -0x18(%rbp), %rdi
callq 0x3a80
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: guoxuanhan[P]NetServer/channel.cpp
// Function: Channel::HandleEvent()
void Channel::HandleEvent()
{
    if(events_ & EPOLLRDHUP)
    {
        //对方异常关闭事件
        std::cout<< "Event EPOLLRDHUP!" << std::endl;
        closehandler_();
    } else if(events_ & (EPOLLIN | EPOLLPRI))
    {
        //读事件，对端有数据或者正常关闭
        std::cout<< "Event EPOLLIN!" << std::endl;
        readhandler_();
    } else if(events_ & EPOLLOUT)
    {
        //写事件
        std::cout << "Event EPOLLOUT!" << std::endl;
        writehandler_();
    } else
    {
        //连接错误
        std::cout << "Event EPOLLERR!" << std::endl;
        errorhandler_();
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rax), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x5d25
movq 0x352b9(%rip), %rdi     # 0x3afb0
leaq 0x22306(%rip), %rsi     # 0x28004
callq 0x53a0
movq %rax, %rdi
movq 0x35273(%rip), %rsi     # 0x3af80
callq 0x53f0
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
callq 0x5f00
jmp 0x5ddd
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x5d67
movq 0x35274(%rip), %rdi     # 0x3afb0
leaq 0x222d3(%rip), %rsi     # 0x28016
callq 0x53a0
movq %rax, %rdi
movq 0x3522e(%rip), %rsi     # 0x3af80
callq 0x53f0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x5f00
jmp 0x5ddb
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5da9
movq 0x35232(%rip), %rdi     # 0x3afb0
leaq 0x222a0(%rip), %rsi     # 0x28025
callq 0x53a0
movq %rax, %rdi
movq 0x351ec(%rip), %rsi     # 0x3af80
callq 0x53f0
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0x5f00
jmp 0x5dd9
movq 0x35200(%rip), %rdi     # 0x3afb0
leaq 0x2227e(%rip), %rsi     # 0x28035
callq 0x53a0
movq %rax, %rdi
movq 0x351ba(%rip), %rsi     # 0x3af80
callq 0x53f0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x5f00
jmp 0x5ddb
jmp 0x5ddd
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: guoxuanhan[P]NetServer/echoserver.cpp
// Function: EchoServer::HandleMessage(std::shared_ptr<TcpConnection> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void EchoServer::HandleMessage(const spTcpConnection& sptcpconn, std::string &s)
{
    //std::string msg("reply msg:");
    //msg += s;
    //s.clear();
    //swap优化
    std::string msg;
    msg.swap(s);
    msg.insert(0, "reply msg:");
    sptcpconn->Send(msg);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x54f0
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x52d0
movq 0x8(%rsp), %rdi
leaq 0x219f2(%rip), %rdx     # 0x2807f
xorl %eax, %eax
movl %eax, %esi
callq 0x50e0
jmp 0x6698
movq 0x48(%rsp), %rdi
callq 0x6aa0
movq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1ca10
jmp 0x66b1
leaq 0x20(%rsp), %rdi
callq 0x5270
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x5270
movq 0x18(%rsp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
// File: guoxuanhan[P]NetServer/eventloop.cpp
// Function: CreateEventFd()
int CreateEventFd()
{
    int evtfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
    if(evtfd < 0)
    {
        std::cout<< "Failed in eventfd!" << std::endl;
        exit(1);
    }
    return evtfd;
}

// Assembly:
pushq %rax
xorl %edi, %edi
movl $0x80800, %esi          # imm = 0x80800
callq 0x5480
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x80f4
movq 0x32ee1(%rip), %rdi     # 0x3afb0
leaq 0x2027e(%rip), %rsi     # 0x28354
callq 0x53a0
movq %rax, %rdi
movq 0x32e9b(%rip), %rsi     # 0x3af80
callq 0x53f0
movl $0x1, %edi
callq 0x5460
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw (%rax,%rax)