LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zerolfx[P]P-Machine/ssp.cpp
// Function: Ssp::execute(StackMachine*)
void Ssp::execute(StackMachine *stack)
{	
	int newSPvalue = stack->fMP + fP - 1;

	// get the stack consistent
	if(newSPvalue < stack->fSP)
	{
		for(int i = stack->fSP; i > newSPvalue; --i)
		{	
			delete stack->fStore[i];
			stack->fStore[i] = 0;
			stack->fStore.pop_back();
		}
	}
	else
	{
		for(int i = stack->fSP; i < newSPvalue; ++i)
		{
			stack->fStore.push_back(new StackElement());
		}
	}
	
	stack->fSP = newSPvalue;
	
	// adding cost of this instruction
	stack->fTime.count("ssp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl 0xc0(%rsi), %ecx
movl 0x8(%rdi), %edx
leal (%rdx,%rcx), %eax
addl %edx, %ecx
decl %ecx
movslq 0xb4(%rsi), %r13
cmpl %r13d, %eax
movl %ecx, -0x2c(%rbp)
jle 0x16d65
cmpl %ecx, %r13d
jge 0x16da8
leaq 0x18(%rbx), %r14
notl %r13d
addl %eax, %r13d
leaq -0x50(%rbp), %r15
movl $0x8, %edi
callq 0x6200
movq %rax, %r12
movq %rax, %rdi
callq 0x1a2f0
movq %r12, -0x50(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa334
decl %r13d
jne 0x16d3a
jmp 0x16da8
movslq %eax, %r15
incq %r13
movq 0x18(%rbx), %rax
movq -0x8(%rax,%r13,8), %r14
testq %r14, %r14
je 0x16d81
movq %r14, %rdi
callq 0x1a300
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movq 0x18(%rbx), %rax
movq $0x0, -0x8(%rax,%r13,8)
addq $-0x8, 0x20(%rbx)
decq %r13
cmpq %r15, %r13
jg 0x16d6b
movl -0x2c(%rbp), %eax
movl %eax, 0xb4(%rbx)
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xed3c(%rip), %rsi      # 0x25afc
leaq 0xed38(%rip), %rdx      # 0x25aff
leaq -0x50(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x1cbc8
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x16df5
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x16e2e
movq -0x40(%rbp), %rsi
incq %rsi
jmp 0x16e29
movq %rax, %rbx
jmp 0x16e2e
movq %rax, %rbx
movl $0x8, %esi
movq %r12, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
cmpb $0x1, 0xc(%rdi)
jne 0x193ca
leaq 0xce5d(%rip), %rsi      # 0x26218
movl $0x7, %edx
movq %rbx, %rdi
callq 0x6270
jmp 0x19419
movq %rdi, %r14
leaq 0xce4c(%rip), %rsi      # 0x26220
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6270
movl 0x8(%r14), %esi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x73d2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x6270
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19419
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x6210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19441
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x1b016
leaq -0x9(%rbp), %rsi
movb $0x74, (%rsi)
jmp 0x1b01d
leaq -0xa(%rbp), %rsi
movb $0x66, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6270
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1b798
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x1b291
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b67a
movl (%rax), %eax
decl %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq 0xb536(%rip), %rsi      # 0x267db
leaq -0x40(%rbp), %rdi
movq %r14, %rdx
callq 0x1b5e8
leaq 0xb52a(%rip), %rsi      # 0x267e2
leaq -0x40(%rbp), %rdi
callq 0x6450
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1b2e3
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x1b2ee
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
movq 0x8(%rax), %rdx
leaq -0x60(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x1b14c
xorl %r15d, %r15d
leaq 0x1776a(%rip), %rsi     # 0x32a88
leaq -0x1bb(%rip), %rdx      # 0x1b16a
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b345
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b35e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r15b, %r15b
jne 0x1b386
jmp 0x1b38e
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b386
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1b386
movq %rax, %r14
movq %rbx, %rdi
callq 0x6170
movq %r14, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1b798
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x1b40c
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x8a76
movl %r15d, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bb56
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b3ff
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq 0xb3d3(%rip), %rsi      # 0x267f3
leaq -0x68(%rbp), %rdi
movq %r14, %rdx
callq 0x1b5e8
leaq 0xb3c7(%rip), %rsi      # 0x267fa
leaq -0x68(%rbp), %rdi
callq 0x6450
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1b45e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x1b469
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x1b1b8
xorl %r15d, %r15d
leaq 0x188e7(%rip), %rsi     # 0x33d80
leaq -0x2ca(%rip), %rdx      # 0x1b1d6
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b4c0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b4d9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r15b, %r15b
jne 0x1b501
jmp 0x1b523
movq %rax, %r14
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b501
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1b501
movq %rax, %r14
movq %rbx, %rdi
callq 0x6170
jmp 0x1b523
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b523
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1b798
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x1cc28
movq 0x17403(%rip), %r15     # 0x33ff0
leaq 0x9c39(%rip), %rsi      # 0x2682d
movl $0x31, %edx
movq %r15, %rdi
callq 0x6270
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b67a
movl (%rax), %eax
addl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x0, 0xb0(%rdi)
cmpb $0x0, 0xc4(%rdi)
jne 0x1ce8c
xorl %eax, %eax
cmpl 0xc8(%rbx), %eax
jge 0x1cf47
cmpb $0x1, 0xcc(%rbx)
jne 0x1ce34
movq %rbx, %rdi
callq 0x1cfce
movl 0xb0(%rbx), %eax
cltq
movq (%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
cmpb $0x1, 0xcc(%rbx)
jne 0x1ce6f
movq %rbx, %rdi
callq 0x1d038
movq %rbx, %rdi
callq 0x1d1a0
movq %rbx, %rdi
callq 0x1d2ea
movq %rbx, %rdi
callq 0x1d472
movl 0xb0(%rbx), %eax
incl %eax
movl %eax, 0xb0(%rbx)
incl 0xd8(%rbx)
cmpb $0x0, 0xc4(%rbx)
je 0x1ce11
movq 0x1712d(%rip), %r14     # 0x33fc0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rax, %r14
leaq 0x99cb(%rip), %rsi      # 0x2688f
movl $0x14, %edx
movq %rax, %rdi
callq 0x6270
addq $0x78, %rbx
movq %rbx, %rdi
callq 0x1cc44
movq %r14, %rdi
movl %eax, %esi
callq 0x63f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6140
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x98fc(%rip), %rsi      # 0x2685f
leaq 0x9924(%rip), %rdx      # 0x2688e
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b14c
xorl %r12d, %r12d
leaq 0x15afc(%rip), %rsi     # 0x32a88
leaq -0x1e29(%rip), %rdx     # 0x1b16a
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1cfb3
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r12b, %r12b
jne 0x1cfbd
jmp 0x1cfc5
movq %rax, %r14
movq %rbx, %rdi
callq 0x6170
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xd4(%rdi), %ecx
testl %ecx, %ecx
je 0x1d069
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
movq %rax, %rdx
shrq $0x3, %rdx
subl %ecx, %edx
movslq %edx, %r14
jmp 0x1d074
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
xorl %r14d, %r14d
sarq $0x3, %rax
cmpq %r14, %rax
jbe 0x1d163
movq 0x16f38(%rip), %r15     # 0x33fc0
leaq 0x9854(%rip), %r12      # 0x268e3
movl $0x2, %edx
movq %r15, %rdi
leaq 0x983e(%rip), %rsi      # 0x268dc
callq 0x6270
movq %r15, %rdi
movl %r14d, %esi
callq 0x63f0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x981f(%rip), %rsi      # 0x268df
callq 0x6270
movl $0x1, %edx
movq %r13, %rdi
leaq 0x9809(%rip), %rsi      # 0x268dd
callq 0x6270
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r13, %rdi
leaq -0x29(%rbp), %rsi
callq 0x6270
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x6270
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %r13, %rdi
callq 0x1a8ef
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
incq %r14
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x1d08f
movq 0x16e56(%rip), %rbx     # 0x33fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpb $0x1, 0xcd(%rdi)
jne 0x1d2e8
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xb8(%rdi)
jns 0x1d2ac
xorl %r12d, %r12d
movq 0x16deb(%rip), %r14     # 0x33fc0
xorl %r13d, %r13d
decl %r13d
movl $0x2, %edx
movq %r14, %rdi
leaq 0x96f2(%rip), %rsi      # 0x268dc
callq 0x6270
movq %r14, %rdi
movl %r13d, %esi
callq 0x63f0
movq %rax, %r15
movl $0x3, %edx
movq %rax, %rdi
leaq 0x96d3(%rip), %rsi      # 0x268df
callq 0x6270
movl $0x1, %edx
movq %r15, %rdi
leaq 0x96bd(%rip), %rsi      # 0x268dd
callq 0x6270
movq 0x30(%rbx), %rax
movq (%rax,%r12), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0x6270
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0x9687(%rip), %rsi      # 0x268e3
callq 0x6270
movq 0x30(%rbx), %rax
movq (%rax,%r12), %rsi
movq %r15, %rdi
callq 0x1a8ef
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
addq $0x8, %r12
cmpl 0xb8(%rbx), %r13d
jg 0x1d1d8
movq 0x16d0d(%rip), %rbx     # 0x33fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0xd8(%rdi), %eax
cmpl 0xd0(%rdi), %eax
jne 0x1d4f9
movq %rdi, %rbx
movq 0x16b2b(%rip), %r14     # 0x33fc0
leaq 0x9408(%rip), %rsi      # 0x268a4
movl $0x32, %edx
movq %r14, %rdi
callq 0x6270
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq 0x16b01(%rip), %rdi     # 0x33fd8
leaq -0x11(%rbp), %r14
movq %r14, %rsi
callq 0x62e0
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x63, %eax
jne 0x1d502
movl $0x0, 0xd8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %edi, %edi
callq 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebx
testl %esi, %esi
je 0x1d58e
movl %esi, %r14d
movq %rdi, %r15
cmpl %ebx, 0xb4(%r15)
jle 0x1d59e
movq 0x18(%r15), %rax
movslq %ebx, %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movl %eax, %ebx
decl %r14d
jne 0x1d56c
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1b8(%rbp), %rdi
callq 0x6300
leaq -0x1a8(%rbp), %r15
leaq 0x9358(%rip), %rsi      # 0x26910
movl $0x5, %edx
movq %r15, %rdi
callq 0x6270
movq %r15, %rdi
movl %r14d, %esi
callq 0x63f0
movq %rax, %r14
leaq 0x9320(%rip), %rsi      # 0x268fa
movl $0x1, %edx
movq %rax, %rdi
callq 0x6270
movq %r14, %rdi
movl %ebx, %esi
callq 0x63f0
leaq 0x931e(%rip), %rsi      # 0x26916
movl $0x36, %edx
movq %rax, %rdi
callq 0x6270
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x6340
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x11668
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b14c
xorl %r15d, %r15d
leaq 0x15441(%rip), %rsi     # 0x32a88
leaq -0x24e4(%rip), %rdx     # 0x1b16a
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d672
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
testb %r15b, %r15b
jne 0x1d67c
jmp 0x1d689
movq %rax, %r14
movq %rbx, %rdi
callq 0x6170
jmp 0x1d689
movq %rax, %r14
leaq -0x1b8(%rbp), %rdi
callq 0x6440
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq 0x167d2(%rip), %rbx     # 0x33fc0
leaq 0x9158(%rip), %rsi      # 0x2694d
movl $0x49, %edx
movq %rbx, %rdi
callq 0x6270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
leaq 0x913d(%rip), %rsi      # 0x26997
movl $0xe, %edx
movq %rbx, %rdi
callq 0x6270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
leaq 0x9111(%rip), %rsi      # 0x269a6
movl $0x34, %edx
movq %rbx, %rdi
callq 0x6270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
leaq 0x910b(%rip), %rsi      # 0x269db
movl $0xf, %edx
movq %rbx, %rdi
callq 0x6270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6140
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x540, %rsp            # imm = 0x540
movq %rsi, %rbx
leaq -0x360(%rbp), %rdi
callq 0x122c
leaq -0x270(%rbp), %r14
movq %r14, %rdi
callq 0x10a0
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x1080
leaq -0x560(%rbp), %r15
leaq -0x360(%rbp), %r12
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x10b0
movq -0x268(%rbp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x12ac
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x250(%rbp,%rax)
je 0x2292
leaq -0x360(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fc6
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x220c
movq 0x2ceb(%rip), %r14      # 0x4fd8
leaq 0xd2d(%rip), %rsi       # 0x3021
movl $0x7, %edx
movq %r14, %rdi
callq 0x1090
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2325
movq %rbx, %rdi
callq 0x1040
movq 0x2cc0(%rip), %rdi      # 0x4fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1090
jmp 0x233d
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x10d0
movq 0x2c94(%rip), %rdi      # 0x4fd8
leaq 0xcde(%rip), %rsi       # 0x3029
movl $0x5, %edx
callq 0x1090
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x1040
movq 0x2c70(%rip), %rdi      # 0x4fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1090
movq 0x2c5e(%rip), %rdi      # 0x4fd8
leaq 0xcae(%rip), %rsi       # 0x302f
movl $0x2, %edx
callq 0x1090
leaq -0x270(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x540, %rsp            # imm = 0x540
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23ab
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x29d6
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d54
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2464
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
cmpl $0x0, 0x30(%rbx)
jne 0x24c0
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x20e0
movslq 0x28(%rbx), %rcx
cmpq %rcx, %rax
jb 0x24c0
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x2150
movslq 0x2c(%rbx), %rcx
cmpq %rcx, %rax
jb 0x24c0
movl $0x1, 0x30(%rbx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x2a13
movq 0x2b21(%rip), %rdi      # 0x4fd0
leaq 0xb6a(%rip), %rsi       # 0x3020
movl $0x1, %edx
callq 0x2190
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24e8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpl $0x0, 0x30(%rdi)
jne 0x2550
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x20e0
movslq 0x28(%rbx), %rcx
cmpq %rcx, %rax
jb 0x2550
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x2150
movslq 0x2c(%rbx), %rcx
cmpq %rcx, %rax
jb 0x2550
movl $0x1, 0x30(%rbx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x2a13
movq 0x2a91(%rip), %rdi      # 0x4fd0
leaq 0xada(%rip), %rsi       # 0x3020
movl $0x1, %edx
callq 0x2190
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x2575
movq (%rax), %rsi
incq %rsi
popq %rbx
jmp 0x2170
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x2a3d
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x259c(%rip), %rdi      # 0x4fd0
callq 0x2190
addq $0x20, %r14
cmpq %rbx, %r14
je 0x2a78
movq 0x2587(%rip), %r15      # 0x4fd0
leaq 0x61b(%rip), %r12       # 0x306b
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2190
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2190
addq $0x20, %r14
cmpq %rbx, %r14
jne 0x2a50
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x4280
leaq 0xaed3(%rip), %rcx      # 0x1007f
movl $0xa, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4390
movq (%rbx), %rdi
movq %rsp, %rsi
callq 0xc820
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x51d7
callq 0x4310
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x51f2
callq 0x4310
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4410
testl %eax, %eax
js 0x5573
popq %rcx
retq
movq 0x12a3e(%rip), %rdi     # 0x17fb8
leaq 0xadef(%rip), %rsi      # 0x10370
callq 0x4330
movq %rax, %rdi
callq 0x41a0
movl $0x1, %edi
callq 0x43f0
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/eventloop.cpp
// Function: EventLoop::EventLoop()
EventLoop::EventLoop() :
    functorlist_(), channellist_(), activechannellist_(), poller_(),
    quit_(true), tid_(std::this_thread::get_id()), mutex_(),
    wakeupfd_(CreateEventFd()), wakeupchannel_()
{
    wakeupchannel_.SetFd(wakeupfd_);
    wakeupchannel_.SetEvents(EPOLLIN | EPOLLET);
    wakeupchannel_.SetReadHandle(std::bind(&EventLoop::HandleRead, this));
    wakeupchannel_.SetErrorHandle(std::bind(&EventLoop::HandleError, this));
    AddChannelToPoller(&wakeupchannel_);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x40(%rdi)
movq %r14, %rdi
callq 0xae1c
movb $0x1, 0xc0(%rbx)
callq 0x42f0
movq %rax, 0xc8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movq $0x0, 0xf0(%rbx)
callq 0x5560
movl %eax, 0xf8(%rbx)
leaq 0x100(%rbx), %r15
movq %r15, %rdi
callq 0x4b1c
movl 0xf8(%rbx), %esi
movq %r15, %rdi
callq 0x4bba
movq %r15, %rdi
movl $0x80000001, %esi       # imm = 0x80000001
callq 0x4bc2
movq $0x0, 0x8(%rsp)
movl $0x18, %edi
callq 0x4350
leaq 0x14c(%rip), %rcx       # 0x5798
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x42a(%rip), %r12       # 0x5a92
movq %r12, 0x18(%rsi)
leaq 0x43b(%rip), %r13       # 0x5aae
movq %r13, 0x10(%rsi)
movq %r15, %rdi
callq 0x4d64
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5696
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq $0x0, 0x8(%rsp)
movl $0x18, %edi
callq 0x4350
leaq 0x106(%rip), %rcx       # 0x57b6
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r12, 0x18(%rsi)
movq %r13, 0x10(%rsi)
movq %r15, %rdi
callq 0x4d78
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x56ec
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
movq %r15, %rsi
callq 0xb176
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5745
jmp 0x5745
movq %rax, %r12
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x575c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x575c
jmp 0x5745
jmp 0x5759
movq %rax, %r12
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x575c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x575c
movq %rax, %rdi
callq 0x4df2
jmp 0x5759
movq %rax, %r12
jmp 0x576c
movq %rax, %r12
jmp 0x5764
movq %rax, %r12
movq %r15, %rdi
callq 0x4b46
movq %r14, %rdi
callq 0xaf3e
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x577a
callq 0x4310
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5788
callq 0x4310
movq %rbx, %rdi
callq 0x5a00
movq %r12, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/eventloop.cpp
// Function: EventLoop::loop()
void EventLoop::loop()
{
    quit_ = false;
    while(!quit_)
    {
        poller_.poll(activechannellist_);
        for(Channel* pchannel : activechannellist_)
        {
            //处理事件
            pchannel->HandleEvent();
        }
        activechannellist_.clear();
        ExecuteTask();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0xc0(%rdi)
leaq 0x48(%rdi), %r14
leaq 0x30(%rdi), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xaf6c
movq 0x30(%rbx), %r12
movq 0x38(%rbx), %r13
cmpq %r13, %r12
je 0x5867
movq (%r12), %rdi
callq 0x4bca
addq $0x8, %r12
cmpq %r13, %r12
jne 0x5847
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x5867
movq %rax, 0x38(%rbx)
movq %rbx, %rdi
callq 0x5882
cmpb $0x0, 0xc0(%rbx)
je 0x582f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/eventloop.cpp
// Function: EventLoop::ExecuteTask()
void EventLoop::ExecuteTask()
{
    std::vector<Functor> functorlist;
    {
        std::lock_guard<std::mutex> lock(mutex_);
        functorlist.swap(functorlist_);
    }
    for(Functor & functor : functorlist)
    {
        functor();
    }
    functorlist.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0xd0(%rdi), %r15
movq %r15, %rdi
callq 0x4480
testl %eax, %eax
jne 0x5929
movq (%r14), %rbx
movq %rbx, (%rsp)
movq 0x8(%r14), %r12
movq %r12, 0x8(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %r15, %rdi
callq 0x42a0
cmpq %r12, %rbx
je 0x5902
cmpq $0x0, 0x10(%rbx)
je 0x5924
movq %rbx, %rdi
callq *0x18(%rbx)
addq $0x20, %rbx
cmpq %r12, %rbx
jne 0x58e8
movq (%rsp), %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d1e
movq %r14, %rdi
callq 0x5a00
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4140
movl %eax, %edi
callq 0x4220
jmp 0x5934
jmp 0x5934
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a00
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/eventloop.cpp
// Function: EventLoop::AddTask(std::function<void ()>)
void EventLoop::AddTask(Functor functor)
{
    {
        std::lock_guard<std::mutex> lock(mutex_);
        functorlist_.push_back(functor);
    }
    //跨线程唤醒，worker线程唤醒IO线程
    WakeUp();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xd0(%rdi), %r14
movq %r14, %rdi
callq 0x4480
testl %eax, %eax
jne 0x59e5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a28
movq %r14, %rdi
callq 0x42a0
leaq 0x8(%rsp), %rsi
movq $0x1, (%rsi)
movl 0xf8(%rbx), %edi
movl $0x8, %edx
callq 0x4120
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x4220
movq %rax, %rbx
movq %r14, %rdi
callq 0x42a0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/eventloopthread.cpp
// Function: EventLoopThread::~EventLoopThread()
EventLoopThread::~EventLoopThread()
{
    //线程结束时清理
    std::cout<< "Clean up the EventLoopThread id:" << std::this_thread::get_id() << std::endl;
    //停止IO线程运行
    loop_->Quit();
    //清理IO线程防止内存泄漏，因为pthread_create会calloc
    th_.join();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1220a(%rip), %r14     # 0x17fb8
leaq 0xa66b(%rip), %rsi      # 0x10420
movl $0x20, %edx
movq %r14, %rdi
callq 0x43a0
callq 0x42f0
testq %rax, %rax
je 0x5de0
movq 0x121e5(%rip), %rdi     # 0x17fb8
movq %rax, %rsi
callq 0x4230
movq %rax, %r14
jmp 0x5df4
leaq 0xa6cb(%rip), %rsi      # 0x104b2
movl $0x24, %edx
movq %r14, %rdi
callq 0x43a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4320
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4240
movq 0x30(%rbx), %rdi
callq 0x595c
movq %rbx, %rdi
callq 0x4560
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x5e3e
callq 0x4310
cmpq $0x0, (%rbx)
jne 0x5e4c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x40b0
movq %rax, %rdi
callq 0x4df2
nop
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/eventloopthread.cpp
// Function: EventLoopThread::ThreadFunc()
void EventLoopThread::ThreadFunc()
{
    EventLoop loop;
    loop_ = &loop;

    threadid_ = std::this_thread::get_id();
    std::stringstream sin;
    sin << threadid_;
    threadname_ += sin.str();
    std::cout<< "in the thread: " << threadname_ << std::endl;

    try
    {
        loop_->loop();
    } catch(std::bad_alloc& bad)
    {
        std::cerr << "Bad_alloc caught in EventLoopThread::ThreadFunc loop: " << bad.what() << std::endl;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x338, %rsp            # imm = 0x338
movq %rdi, %rbx
leaq 0x1b0(%rsp), %r14
movq %r14, %rdi
callq 0x5598
movq %r14, 0x30(%rbx)
callq 0x42f0
movq %rax, 0x8(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x4260
leaq 0x38(%rsp), %rdi
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x5ef1
callq 0x4230
jmp 0x5f02
leaq 0xa5ba(%rip), %rsi      # 0x104b2
movl $0x24, %edx
callq 0x43a0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44f0
leaq 0x10(%rbx), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x40f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f37
callq 0x4310
movq 0x1207a(%rip), %rdi     # 0x17fb8
leaq 0xa4fc(%rip), %rsi      # 0x10441
movl $0xf, %edx
callq 0x43a0
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x1205a(%rip), %rdi     # 0x17fb8
callq 0x43a0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4320
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4240
movq 0x30(%rbx), %rdi
callq 0x5814
movq 0x11ffb(%rip), %rsi     # 0x17f98
leaq 0x28(%rsp), %rdi
callq 0x4290
leaq 0xa8(%rsp), %rdi
callq 0x4110
leaq 0x1b0(%rsp), %rdi
callq 0x57c2
addq $0x338, %rsp            # imm = 0x338
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x605b
movq %rbx, %rdi
callq 0x4150
movq %rax, %rbx
movq 0x11ffe(%rip), %rdi     # 0x17fe8
leaq 0xa460(%rip), %rsi      # 0x10451
movl $0x36, %edx
callq 0x43a0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x11fdd(%rip), %rdi     # 0x17fe8
movq %rax, %rsi
callq 0x4330
movq %rax, %rdi
callq 0x41a0
callq 0x4530
jmp 0x5f96
jmp 0x6058
movq %rax, %rbx
callq 0x4530
jmp 0x605b
movq %rax, %rdi
callq 0x4df2
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x605b
callq 0x4310
jmp 0x605b
jmp 0x6058
movq %rax, %rbx
jmp 0x6079
movq %rax, %rbx
movq 0x11f36(%rip), %rsi     # 0x17f98
leaq 0x28(%rsp), %rdi
callq 0x4290
leaq 0xa8(%rsp), %rdi
callq 0x4110
leaq 0x1b0(%rsp), %rdi
callq 0x57c2
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/eventloopthreadpool.cpp
// Function: EventLoopThreadPool::~EventLoopThreadPool()
EventLoopThreadPool::~EventLoopThreadPool()
{
    std::cout << "Clean up the EventLoopThreadPool" << std::endl;
    for(int i = 0; i < threadnum_; ++i)
    {
        delete threadlist_[i];
    }
    threadlist_.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x11d2f(%rip), %r14     # 0x17fb8
leaq 0xa297(%rip), %rsi      # 0x10527
movl $0x20, %edx
movq %r14, %rdi
callq 0x43a0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x4320
movsbl %al, %esi
movq 0x11cfd(%rip), %rdi     # 0x17fb8
callq 0x4030
movq %rax, %rdi
callq 0x4240
cmpl $0x0, 0x8(%rbx)
jle 0x62fa
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x62e6
movq %r14, %rdi
callq 0x5da0
movq %r14, %rdi
callq 0x4310
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x62d1
movq 0x10(%rbx), %rdi
cmpq %rdi, 0x18(%rbx)
je 0x6308
movq %rdi, 0x18(%rbx)
testq %rdi, %rdi
je 0x6317
popq %rbx
popq %r14
popq %r15
jmp 0x4310
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x4df2
nop
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/eventloopthreadpool.cpp
// Function: EventLoopThreadPool::GetNextLoop()
EventLoop* EventLoopThreadPool::GetNextLoop()
{
    if(threadnum_ > 0)
    {
        EventLoop *loop = threadlist_[index_]->GetLoop();
        index_ = (index_ + 1) % threadnum_;
        return loop;
        //LC策略,还没写
        //EventLoop *loop = threadlist_[index_]->GetLoop();
        //index_ = (index_ + 1) % threadnum_;
        //return loop;
    }
    else
    {
        return mainloop_;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x6387
movslq 0x28(%rbx), %rax
movq 0x10(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
callq 0x5e5a
movq %rax, %rcx
movl 0x28(%rbx), %eax
incl %eax
cltd
idivl 0x8(%rbx)
movl %edx, 0x28(%rbx)
movq %rcx, %rax
popq %rbx
retq
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/httpserver.cpp
// Function: HttpServer::HandleNewConnection(std::shared_ptr<TcpConnection> const&)
void HttpServer::HandleNewConnection(const spTcpConnection& sptcpconn)
{
    //std::string msg(s);
    std::shared_ptr<HttpSession> sphttpsession = std::make_shared<HttpSession>(); //创建应用层会话
    spTimer sptimer = std::make_shared<Timer>(5000, Timer::TimerType::TIMER_ONCE, std::bind(&TcpConnection::Shutdown, sptcpconn));
    sptimer->Start();
    //可以优化成无锁，放入conn里面就行
    {
        std::lock_guard <std::mutex> lock(mutex_);
        httpsessionnlist_[sptcpconn] = sphttpsession;
        timerlist_[sptcpconn] = sptimer;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
movq %r13, -0x8(%r15)
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x7f4c
movl $0x1388, 0xc(%rsp)      # imm = 0x1388
movl $0x0, 0x8(%rsp)
leaq 0x62cb(%rip), %rax      # 0xcb70
movq %rax, (%r12)
movq %r13, 0x8(%r12)
movq (%rbx), %rax
movq %rax, 0x10(%r12)
movq 0x8(%rbx), %rax
movq %rax, 0x18(%r12)
testq %rax, %rax
je 0x68d9
movq 0x116e5(%rip), %rcx     # 0x17fb0
cmpb $0x0, (%rcx)
je 0x68d5
incl 0x8(%rax)
jmp 0x68d9
lock
incl 0x8(%rax)
leaq 0x18(%rsp), %r12
movq $0x0, -0x8(%r12)
leaq 0x10(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
leaq 0x30(%rsp), %r9
movq %r12, %rdi
callq 0x800c
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x6917
callq 0x795e
movq 0x10(%rsp), %rdi
callq 0xf1fe
leaq 0x60(%r14), %r13
movq %r13, %rdi
callq 0x4480
testl %eax, %eax
jne 0x69ad
movq %r14, %rdi
movq %rbx, %rsi
callq 0x76b0
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x7a48
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7716
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, %rdi
movq %r12, %rsi
callq 0x7a48
movq %r13, %rdi
callq 0x42a0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x6990
callq 0x795e
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x699f
callq 0x795e
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x4220
jmp 0x69b6
movq %rax, %rbx
jmp 0x69d0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x69d5
movq %rax, %rbx
movq %r13, %rdi
callq 0x42a0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x69df
callq 0x795e
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x69ee
callq 0x795e
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/guoxuanhan[P]NetServer/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    signal(SIGUSR1, sighandler1);
    signal(SIGUSR2, sighandler2);
    signal(SIGINT, sighandler2);
    signal(SIGPIPE, SIG_IGN);  //SIG_IGN,系统函数，忽略信号的处理程序,客户端发送RST包后，服务器还调用write会触发

    int port = 80;
    int iothreadnum = 4;
    int workerthreadnum = 4;
    if(argc == 4)
    {
        port = atoi(argv[1]);
        iothreadnum = atoi(argv[2]);
        workerthreadnum = atoi(argv[3]);
    }

    EventLoop loop;
    lp = &loop;
    HttpServer httpserver(&loop, port, iothreadnum, workerthreadnum);
    httpserver.Start();

    try
    {
        loop.loop();
    }
    catch (std::bad_alloc& ba)
    {
        std::cerr << "bad_alloc caught in ThreadPool::ThreadFunc task: " << ba.what() << '\n';
    }
    //loop.loop();

    // EventLoop loop;
    // lp = &loop;
    // EchoServer echoserver(&loop, port, iothreadnum);
    // echoserver.Start();
    // loop.loop();
    // return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x17a(%rip), %rsi       # 0xae07
movl $0xa, %edi
callq 0x43e0
leaq 0x171(%rip), %r14       # 0xae0f
movl $0xc, %edi
movq %r14, %rsi
callq 0x43e0
movl $0x2, %edi
movq %r14, %rsi
callq 0x43e0
movl $0x1, %esi
movl $0xd, %edi
callq 0x43e0
cmpl $0x4, %ebp
jne 0xacf0
movq 0x8(%rbx), %rdi
callq 0x44d0
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x44d0
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x44d0
movl %eax, %ebx
jmp 0xad00
movl $0x50, %ebp
movl $0x4, %r14d
movl $0x4, %ebx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5598
movq %r15, 0xd634(%rip)      # 0x18348
leaq 0x190(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movl %ebx, %r8d
callq 0x64c4
leaq 0x190(%rsp), %rdi
callq 0x74c2
leaq 0x8(%rsp), %rdi
callq 0x5814
leaq 0x190(%rsp), %rdi
callq 0x7416
leaq 0x8(%rsp), %rdi
callq 0x57c2
xorl %eax, %eax
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xade3
movq %rbx, %rdi
callq 0x4150
movq %rax, %rbx
movq 0xd264(%rip), %rdi      # 0x17fe8
leaq 0x615e(%rip), %rsi      # 0x10ee9
movl $0x31, %edx
callq 0x43a0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0xd243(%rip), %rdi      # 0x17fe8
movq %rax, %rsi
callq 0x4330
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x43a0
callq 0x4530
jmp 0xad43
jmp 0xade0
movq %rax, %rbx
callq 0x4530
jmp 0xade3
movq %rax, %rdi
callq 0x4df2
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x7416
jmp 0xadf5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x57c2
movq %rbx, %rdi
callq 0x45a0