LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: acherkaoui[P]HTOP/modules/Clock.cpp
// Function: Clock::getTime[abi:cxx11]()
std::string Clock::getTime()
{
	time_t rawTime;
	struct tm *localTime;
	std::stringstream now;

	time(&rawTime);
	localTime = localtime(&rawTime);
	now << formatTime(localTime->tm_hour) << ":";
	now << formatTime(1 + localTime->tm_min) << ":";
	now << formatTime(1 + localTime->tm_sec);
	return now.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x238(%rbp)
movq %rdi, %rax
movq %rax, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x42f0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x43d0
movq -0x228(%rbp), %rdi
callq 0x4310
movq %rax, -0x20(%rbp)
leaq -0x198(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x1c8(%rbp), %rdi
callq 0xdf20
jmp 0xdc93
movq -0x220(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x43c0
movq %rax, -0x240(%rbp)
jmp 0xdcaf
movq -0x240(%rbp), %rdi
leaq 0x6598(%rip), %rsi      # 0x14255
callq 0x4400
jmp 0xdcc4
leaq -0x1c8(%rbp), %rdi
callq 0x42a0
leaq -0x198(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
incl %esi
leaq -0x1f8(%rbp), %rdi
callq 0xdf20
jmp 0xdcf5
movq -0x248(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x43c0
movq %rax, -0x250(%rbp)
jmp 0xdd11
movq -0x250(%rbp), %rdi
leaq 0x6536(%rip), %rsi      # 0x14255
callq 0x4400
jmp 0xdd26
leaq -0x1f8(%rbp), %rdi
callq 0x42a0
leaq -0x198(%rbp), %rax
movq %rax, -0x258(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
incl %esi
leaq -0x218(%rbp), %rdi
callq 0xdf20
jmp 0xdd56
movq -0x258(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x43c0
jmp 0xdd6b
leaq -0x218(%rbp), %rdi
callq 0x42a0
movq -0x238(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x43f0
jmp 0xdd8c
leaq -0x1a8(%rbp), %rdi
callq 0x4330
movq -0x230(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xde1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x42a0
jmp 0xde1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x42a0
jmp 0xde1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x42a0
leaq -0x1a8(%rbp), %rdi
callq 0x4330
movq -0x1d0(%rbp), %rdi
callq 0x46f0
nopw %cs:(%rax,%rax)
// File: acherkaoui[P]HTOP/modules/Clock.cpp
// Function: Clock::getUtc[abi:cxx11]()
std::string Clock::getUtc()
{
	time_t now;
	struct tm *localTime;
	std::string utc;
	char buff[128];

	time(&now);
	localTime = localtime(&now);
	strftime(buff, 128, "%a %d %b %Y", localTime);
	utc = buff;
	return utc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x45b0
leaq -0x18(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x43d0
movq -0xd8(%rbp), %rdi
callq 0x4310
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x6398(%rip), %rdx      # 0x14230
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x80, %esi
callq 0x4370
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x4590
jmp 0xdec5
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xdefd
jmp 0xdef1
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x42a0
jmp 0xdf0d
movq -0xd0(%rbp), %rdi
callq 0x42a0
movq -0xe0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x46f0
nopl (%rax)
// File: acherkaoui[P]HTOP/modules/Clock.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> formatTime<int>(int)
std::string formatTime(T time)
{
	std::stringstream str;
	if (time < 10) {
		str << 0;
	}

	str << time;
	return str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x42f0
cmpl $0xa, -0xc(%rbp)
jge 0xdf87
leaq -0x188(%rbp), %rdi
xorl %esi, %esi
callq 0x46e0
jmp 0xdf65
jmp 0xdf87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4330
jmp 0xdfc9
leaq -0x188(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x46e0
jmp 0xdf98
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x43f0
jmp 0xdfad
leaq -0x198(%rbp), %rdi
callq 0x4330
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x46f0
nopw %cs:(%rax,%rax)
nop
// File: acherkaoui[P]HTOP/modules/OperatingSystem.cpp
// Function: OperatingSystem::OperatingSystem()
OperatingSystem::OperatingSystem() : AMonitorModule(true, "OS")
{
	struct utsname data;
	uname(&data);
	_kernel = data.release;
	_name = data.sysname;
	_domain = data.domainname;
	_machine = data.machine;
	_version = data.version;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x4700
movq -0x1d0(%rbp), %rdx
leaq 0x5c30(%rip), %rsi      # 0x14268
leaq -0x28(%rbp), %rdi
callq 0x45a0
jmp 0xe643
movq -0x1d8(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0xbc90
jmp 0xe65a
leaq -0x28(%rbp), %rdi
callq 0x42a0
leaq -0x29(%rbp), %rdi
callq 0x44a0
movq -0x1d8(%rbp), %rdi
leaq 0xc45e(%rip), %rax      # 0x1aad8
movq %rax, (%rdi)
addq $0x30, %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x45b0
movq -0x1d8(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x200(%rbp)
callq 0x45b0
movq -0x1d8(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x45b0
movq -0x1d8(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x45b0
movq -0x1d8(%rbp), %rdi
addq $0xb0, %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x45b0
leaq -0x1c2(%rbp), %rdi
callq 0x4080
movq -0x1e0(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x4590
jmp 0xe710
movq -0x1d8(%rbp), %rdi
addq $0x50, %rdi
leaq -0x1c2(%rbp), %rsi
callq 0x4590
jmp 0xe729
movq -0x1d8(%rbp), %rdi
leaq -0x7d(%rbp), %rsi
addq $0xb0, %rdi
callq 0x4590
jmp 0xe742
movq -0x1d8(%rbp), %rdi
leaq -0xbe(%rbp), %rsi
addq $0x90, %rdi
callq 0x4590
jmp 0xe75e
movq -0x1d8(%rbp), %rdi
leaq -0xff(%rbp), %rsi
addq $0x70, %rdi
callq 0x4590
jmp 0xe777
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe7a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x42a0
leaq -0x29(%rbp), %rdi
callq 0x44a0
jmp 0xe802
movq -0x1e8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x42a0
movq -0x1f0(%rbp), %rdi
callq 0x42a0
movq -0x1f8(%rbp), %rdi
callq 0x42a0
movq -0x200(%rbp), %rdi
callq 0x42a0
movq -0x1e0(%rbp), %rdi
callq 0x42a0
movq -0x1d8(%rbp), %rdi
callq 0x7280
movq -0x38(%rbp), %rdi
callq 0x46f0
nopl (%rax,%rax)
// File: acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::refreshTerminal()
void Curses::refreshTerminal()
{

	refresh();
	refreshTerminal(_ram);
	refreshTerminal(_user);
	refreshTerminal(_cpu);
	refreshTerminal(_time);
	refreshTerminal(_net);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x46c0
movq -0x10(%rbp), %rdi
movq 0x6b0(%rdi), %rsi
callq 0xfab0
movq -0x10(%rbp), %rdi
movq 0x6c8(%rdi), %rsi
callq 0xfab0
movq -0x10(%rbp), %rdi
movq 0x6b8(%rdi), %rsi
callq 0xfab0
movq -0x10(%rbp), %rdi
movq 0x6c0(%rdi), %rsi
callq 0xfab0
movq -0x10(%rbp), %rdi
movq 0x6d0(%rdi), %rsi
callq 0xfab0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::closeTerminal()
void Curses::closeTerminal()
{
	closeTerminal(_ram);
	closeTerminal(_user);
	closeTerminal(_cpu);
	closeTerminal(_time);
//	clearTerminal(_net);
	endwin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x6b0(%rdi), %rsi
callq 0x12710
movq -0x10(%rbp), %rdi
movq 0x6c8(%rdi), %rsi
callq 0x12710
movq -0x10(%rbp), %rdi
movq 0x6b8(%rdi), %rsi
callq 0x12710
movq -0x10(%rbp), %rdi
movq 0x6c0(%rdi), %rsi
callq 0x12710
callq 0x44e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::getchTerminal()
int Curses::getchTerminal()
{
	_ch = getch();
	if (_ch == KEY_ENTER)
	{
		printw("UP");
	}
	else if(_ch == KEY_DOWN)
	{
		wprintw(_ram, "DOWN");
		waddch(_ram, 'B');
	}
	wclear(stdscr);
	wclear(_ram);
	wclear(_cpu);
	wclear(_user);
	wclear(_time);
	return _ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x881d(%rip), %rax      # 0x1afc8
movq (%rax), %rdi
callq 0x41a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x157, 0x8(%rax)       # imm = 0x157
jne 0x127d5
leaq 0x216b(%rip), %rdi      # 0x14937
movb $0x0, %al
callq 0x4420
jmp 0x12812
movq -0x10(%rbp), %rax
cmpl $0x102, 0x8(%rax)       # imm = 0x102
jne 0x12810
movq -0x10(%rbp), %rax
movq 0x6b0(%rax), %rdi
leaq 0x2146(%rip), %rsi      # 0x1493a
movb $0x0, %al
callq 0x4070
movq -0x10(%rbp), %rax
movq 0x6b0(%rax), %rdi
movl $0x42, %esi
callq 0x4160
jmp 0x12812
movq 0x87af(%rip), %rax      # 0x1afc8
movq (%rax), %rdi
callq 0x4430
movq -0x10(%rbp), %rax
movq 0x6b0(%rax), %rdi
callq 0x4430
movq -0x10(%rbp), %rax
movq 0x6b8(%rax), %rdi
callq 0x4430
movq -0x10(%rbp), %rax
movq 0x6c8(%rax), %rdi
callq 0x4430
movq -0x10(%rbp), %rax
movq 0x6c0(%rax), %rdi
callq 0x4430
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: operator<<(std::ostream&, CConfig&)
ostream& operator <<( ostream& out, CConfig& c ) {
	out << "Ports:";
	for ( auto it = c.getPorts().begin(); it != c.getPorts().end(); it++ ) {
		out << ' ' << *it;
	}
	out << endl;

	out << "Working directory: " << c.getWorkDir() << endl;

	out << "Logger flags:";
	for ( int i = 0; i < E_LOG_FLAGS_MAX; i++ )
		if ( c.logFlags_m[i] )
			out << ' ' << logflagsNS::logFlagsToString( (ELogFlags) i );

	out << endl;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x239ba(%rip), %rsi     # 0x2c045
callq 0x64c0
movq -0x10(%rbp), %rdi
callq 0x85b0
movq %rax, %rdi
callq 0xac50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x85b0
movq %rax, %rdi
callq 0xacc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xac80
testb $0x1, %al
jne 0x86cd
jmp 0x8705
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x65b0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xacf0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6460
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xad10
movq %rax, -0x28(%rbp)
jmp 0x86a5
movq -0x8(%rbp), %rdi
movq 0x368a8(%rip), %rsi     # 0x3efb8
callq 0x6520
movq -0x8(%rbp), %rdi
leaq 0x2392c(%rip), %rsi     # 0x2c04c
callq 0x64c0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x85f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x6460
movq %rax, %rdi
movq 0x36870(%rip), %rsi     # 0x3efb8
callq 0x6520
movq -0x8(%rbp), %rdi
leaq 0x23908(%rip), %rsi     # 0x2c060
callq 0x64c0
movl $0x0, -0x2c(%rbp)
cmpl $0xc, -0x2c(%rbp)
jge 0x87ab
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x879e
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x65b0
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %edi
callq 0x207c0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x64c0
jmp 0x87a0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8764
movq -0x8(%rbp), %rdi
movq 0x36802(%rip), %rsi     # 0x3efb8
callq 0x6520
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::parseMapper(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<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>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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 CConfig::parseMapper( map<string, map<string, vector<string>>>::iterator& data ) {
	for ( auto it = data->second.begin(); it != data->second.end(); it++ )
		fileMapping_m.push_back( make_pair( it->first, it->second.front() ) );

	auto comp = []( const pair<string, string>& a, const pair<string, string>& b ) -> bool {
		return a.first.length() > b.first.length();
	};

	sort( fileMapping_m.begin(), fileMapping_m.end(), comp );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf70
movq %rax, %rdi
addq $0x20, %rdi
callq 0xb5a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf70
movq %rax, %rdi
addq $0x20, %rdi
callq 0xb600
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb5d0
testb $0x1, %al
jne 0x9326
jmp 0x93ca
movq -0xa0(%rbp), %rax
addq $0x78, %rax
movq %rax, -0xb0(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xb6a0
movq -0xc0(%rbp), %rdi
movq %rax, -0xb8(%rbp)
callq 0xb6a0
movq %rax, %rdi
addq $0x20, %rdi
callq 0xb030
movq -0xb8(%rbp), %rsi
movq %rax, %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xb660
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0xb630
jmp 0x9396
leaq -0x60(%rbp), %rdi
callq 0xb6c0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xb6f0
movq %rax, -0x78(%rbp)
jmp 0x92f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb6c0
jmp 0x9414
movq -0xa0(%rbp), %rdi
addq $0x78, %rdi
callq 0xb730
movq -0xa0(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x78, %rdi
callq 0xb760
movq %rax, -0x90(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x96e0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6920
nopl (%rax)
// File: metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void CParserINI::parseLine( string& line ) {
	unsigned int pos = 0;
	skipWS( line, pos );
	if ( pos == line.size() )
		return;

	switch ( line[pos] ) {
		case ';':
		case '#':
			return;
		case '[':
			parseNewBlock( line, pos );
			return;
		default:
			string id = getID( line, pos );
			vector<string> args = getArgs( line, pos );
			addParam( id, args );
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x13110
movl -0x14(%rbp), %eax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6360
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jne 0x12ee9
jmp 0x1303d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x6a00
movsbl (%rax), %eax
movl %eax, -0xac(%rbp)
subl $0x23, %eax
je 0x12f21
jmp 0x12f07
movl -0xac(%rbp), %eax
subl $0x3b, %eax
je 0x12f21
jmp 0x12f14
movl -0xac(%rbp), %eax
subl $0x5b, %eax
je 0x12f26
jmp 0x12f3f
jmp 0x1303d
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x13190
jmp 0x1303d
movq -0xa8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x14(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
callq 0x13460
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rcx
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x13610
jmp 0x12f7b
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6250
jmp 0x12f8a
leaq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xb450
jmp 0x12f9c
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x13050
jmp 0x12fb5
leaq -0x98(%rbp), %rdi
callq 0xb540
leaq -0x80(%rbp), %rdi
callq 0x6310
leaq -0x50(%rbp), %rdi
callq 0xb540
leaq -0x38(%rbp), %rdi
callq 0x6310
jmp 0x1303d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x13032
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x13029
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x13020
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xb540
leaq -0x80(%rbp), %rdi
callq 0x6310
leaq -0x50(%rbp), %rdi
callq 0xb540
leaq -0x38(%rbp), %rdi
callq 0x6310
jmp 0x13046
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6920
nop
// File: metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::getID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
string CParserINI::getID( string& line, unsigned int& pos ) {
	string id = getIdentifier( line, pos );
	skipWS( line, pos );
	if ( pos == line.size() )
		throw INIParserException( "End of line reached ('=' expected)" );
	if ( line[pos++] != '=' )
		throw INIParserException( "Unrecognized symbol ('=' expected): ", line[pos] );
	return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x137a0
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13110
jmp 0x134b2
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0x1353a
movl $0x48, %edi
callq 0x6280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x18df8(%rip), %rsi     # 0x2c2e4
callq 0x13ea0
jmp 0x134f3
movq -0x60(%rbp), %rdi
leaq 0x2b022(%rip), %rsi     # 0x3e520
leaq 0xa4b(%rip), %rdx       # 0x13f50
callq 0x68e0
jmp 0x13603
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x135f1
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x63b0
jmp 0x135f1
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movl %ecx, %esi
movl %esi, %ecx
incl %ecx
movl %ecx, (%rax)
callq 0x6a00
movq %rax, -0x68(%rbp)
jmp 0x13557
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x135d1
movl $0x48, %edi
callq 0x6280
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6a00
movq %rax, -0x70(%rbp)
jmp 0x13588
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rax
movsbl (%rax), %edx
leaq 0x18d6d(%rip), %rsi     # 0x2c307
callq 0x14170
jmp 0x135a1
movq -0x78(%rbp), %rdi
leaq 0x2af74(%rip), %rsi     # 0x3e520
leaq 0x99d(%rip), %rdx       # 0x13f50
callq 0x68e0
jmp 0x13603
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x63b0
jmp 0x135f1
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x135e4
movq -0x50(%rbp), %rdi
callq 0x6310
movq -0x48(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6310
movq -0x30(%rbp), %rdi
callq 0x6920
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::getArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
vector<string> CParserINI::getArgs( string& line, unsigned int& pos ) {
	vector<string> args;
	while ( 1 ) {
		args.push_back( getIdentifier( line, pos ) );
		if ( !getComma( line, pos ) )
			break;
	}

	return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xa970
jmp 0x13649
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x137a0
jmp 0x13660
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14230
jmp 0x1366f
leaq -0x48(%rbp), %rdi
callq 0x6310
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13c30
movb %al, -0x71(%rbp)
jmp 0x1368e
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x136be
jmp 0x13697
jmp 0x136c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x136e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6310
jmp 0x136e0
jmp 0x13647
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x136d3
movq -0x70(%rbp), %rdi
callq 0xb540
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xb540
movq -0x50(%rbp), %rdi
callq 0x6920
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::getComma(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
bool CParserINI::getComma( string& line, unsigned int& pos ) {
	skipWS( line, pos );
	if ( pos == line.size() || line[pos] == ';' || line[pos] == '#' )
		return false;
	if ( line[pos] != ',' )
		throw INIParserException( "Unrecognized symbol (',' expected): ", line[pos] );
	pos++;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13110
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0x13ca6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6a00
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x13ca6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6a00
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x13caf
movb $0x0, -0x1(%rbp)
jmp 0x13d43
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6a00
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x13d34
movl $0x48, %edi
callq 0x6280
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6a00
movq %rax, -0x40(%rbp)
jmp 0x13ced
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movsbl (%rax), %edx
leaq 0x18696(%rip), %rsi     # 0x2c395
callq 0x14170
jmp 0x13d06
movq -0x48(%rbp), %rdi
leaq 0x2a80f(%rip), %rsi     # 0x3e520
leaq 0x238(%rip), %rdx       # 0x13f50
callq 0x68e0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x63b0
jmp 0x13d4e
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6920
nopw (%rax,%rax)
// File: metopa[P]HTTP_Server/src/config/../logger/CLogger.h
// Function: void CLogger::ger<char [28], int, char [6], INIParserException>(ELogFlags, char const (&) [28], int const&, char const (&) [6], INIParserException const&)
void ger( ELogFlags level, const Args& ... args ) {
		if ( !initialized_m || config.checkLogFlag( level ) ) {
			mutex_m.lock();
			printTimestamp();
			*logStream_m << '\t' << logflagsNS::logFlagsToStringPrintable( level ) << ' ';
			print( args... );
			*logStream_m << endl;
			mutex_m.unlock();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x3c(%rax)
je 0x13e15
movl -0xc(%rbp), %esi
leaq 0x2b7d9(%rip), %rdi     # 0x3f5e0
callq 0x8490
testb $0x1, %al
jne 0x13e15
jmp 0x13e9a
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x2b990
movq -0x38(%rbp), %rdi
callq 0x20190
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl $0x9, %esi
callq 0x65b0
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %edi
callq 0x208a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x64c0
movq %rax, %rdi
movl $0x20, %esi
callq 0x65b0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x143b0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq 0x2b130(%rip), %rsi     # 0x3efb8
callq 0x6520
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x2b9e0
addq $0x40, %rsp
popq %rbp
retq
// File: metopa[P]HTTP_Server/src/content/CAbstractContent.cpp
// Function: CAbstractContent::creationTime()
void CAbstractContent::creationTime() {
	time_t ltime;
	tm result;

	ltime = time( NULL );
	localtime_r( &ltime, &result );
	asctime_r( &result, createTime_m );

	for ( int i = 1; i < 32; i++ )
		if ( !createTime_m[i] ) {
			createTime_m[i - 1] = 0;
			break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x6490
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x62a0
movq -0x58(%rbp), %rsi
addq $0x68, %rsi
leaq -0x48(%rbp), %rdi
callq 0x6090
movl $0x1, -0x4c(%rbp)
cmpl $0x20, -0x4c(%rbp)
jge 0x1591c
movq -0x58(%rbp), %rax
movslq -0x4c(%rbp), %rcx
cmpb $0x0, 0x68(%rax,%rcx)
jne 0x1590f
movq -0x58(%rbp), %rax
movl -0x4c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, 0x68(%rax,%rcx)
jmp 0x1591c
jmp 0x15911
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x158e6
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: metopa[P]HTTP_Server/src/content/CDirContent.cpp
// Function: CDirContent::makeLink(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CDirContent::makeLink( const string& path ) {
	if ( userPath_m.back() == '/' )
		return userPath_m + path;
	else if ( path == "." )
		return userPath_m;
	else
		return userPath_m + '/' + path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x20, %rdi
callq 0x6390
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x166af
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x20, %rsi
movq -0x18(%rbp), %rdx
callq 0x16eb0
jmp 0x16727
movq -0x18(%rbp), %rdi
leaq 0x15fd1(%rip), %rsi     # 0x2c68b
callq 0x16f30
testb $0x1, %al
jne 0x166c5
jmp 0x166d8
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x20, %rsi
callq 0x6250
jmp 0x16727
movq -0x50(%rbp), %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x2f, %edx
callq 0x16f60
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16c70
jmp 0x16705
leaq -0x38(%rbp), %rdi
callq 0x6310
jmp 0x16727
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6310
jmp 0x16731
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6920
nopw (%rax,%rax)
// File: metopa[P]HTTP_Server/src/content/CDirContent.cpp
// Function: CDirContent::modificationTime()
void CDirContent::modificationTime() {
	struct stat attr;
	stat( realPath_m.c_str(), &attr );
	ctime_r( &attr.st_mtime, modTime_m );

	for ( int i = 1; i < 32; i++ )
		if ( !modTime_m[i] ) {
			modTime_m[i - 1] = 0;
			break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
addq $0x40, %rdi
callq 0x6240
movq %rax, %rdi
leaq -0x98(%rbp), %rsi
callq 0x6480
movq -0xa8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
addq $0x58, %rdi
addq $0x88, %rsi
callq 0x65d0
movl $0x1, -0x9c(%rbp)
cmpl $0x20, -0x9c(%rbp)
jge 0x167eb
movq -0xa8(%rbp), %rax
movslq -0x9c(%rbp), %rcx
cmpb $0x0, 0x88(%rax,%rcx)
jne 0x167d8
movq -0xa8(%rbp), %rax
movl -0x9c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, 0x88(%rax,%rcx)
jmp 0x167eb
jmp 0x167da
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x1679a
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: metopa[P]HTTP_Server/src/content/CExternalContent.cpp
// Function: CExternalContent::load()
void CExternalContent::load() {
	exec();
	if ( wrapNeeded_m )
		rawData_m = CHTMLGenerator( rawData_m ).substituteNL().wrap( userPath_m );
	data_m.insert( data_m.begin(), rawData_m.begin(), rawData_m.end() );
	size_m = data_m.size();
	creationTime();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1c2d0
movq -0x90(%rbp), %rax
testb $0x1, 0xc8(%rax)
je 0x1c21a
movq -0x90(%rbp), %rsi
addq $0xa8, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
xorl %edx, %edx
callq 0x1df60
movq -0xa0(%rbp), %rdi
callq 0x1ead0
movq %rax, -0x98(%rbp)
jmp 0x1c1b8
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
addq $0x20, %rdx
leaq -0x28(%rbp), %rdi
callq 0x1ebb0
jmp 0x1c1d5
movq -0x90(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x6600
leaq -0x28(%rbp), %rdi
callq 0x6310
leaq -0x50(%rbp), %rdi
callq 0x16aa0
jmp 0x1c21a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x16aa0
jmp 0x1c2bf
movq -0x90(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
addq $0x8, %rdi
callq 0x16dc0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x16df0
movq -0x90(%rbp), %rdi
addq $0xa8, %rdi
callq 0x6440
movq -0x90(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0xa8, %rdi
callq 0x62f0
movq -0xa8(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x16d10
movq -0x90(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x8, %rdi
callq 0x16e30
movq -0x90(%rbp), %rdi
movq %rax, 0x60(%rdi)
callq 0x158a0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6920
nopl (%rax,%rax)
// File: metopa[P]HTTP_Server/src/content/CExternalContent.cpp
// Function: CExternalContent::readPipe(int)
void CExternalContent::readPipe( int fd ) {
	uint8_t buf[1024];
	ssize_t bytesRecvd;
	int errNo;

	while ( 1 ) {
		bytesRecvd = read( fd, buf, sizeof( buf ) );
		errNo = errno;
		if ( bytesRecvd == 0 )
			break;
		else if ( bytesRecvd < 0 ) {
			if ( errNo == EINTR )
				continue;
			else
				throw InternalErrorException( realPath_m );
		}

		rawData_m.insert( rawData_m.end(), buf, buf + bytesRecvd );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x450(%rbp)
movl -0xc(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x6770
movq %rax, -0x418(%rbp)
callq 0x6080
movl (%rax), %eax
movl %eax, -0x41c(%rbp)
cmpq $0x0, -0x418(%rbp)
jne 0x1c564
jmp 0x1c64f
cmpq $0x0, -0x418(%rbp)
jge 0x1c5dc
cmpl $0x4, -0x41c(%rbp)
jne 0x1c579
jmp 0x1c52d
movl $0x48, %edi
callq 0x6280
movq -0x450(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x458(%rbp)
addq $0x40, %rsi
callq 0x1c730
jmp 0x1c5a2
movq -0x458(%rbp), %rdi
leaq 0x22168(%rip), %rsi     # 0x3e718
leaq 0x1b9(%rip), %rdx       # 0x1c770
callq 0x68e0
movq -0x458(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x428(%rbp)
movl %eax, -0x42c(%rbp)
callq 0x63b0
jmp 0x1c658
jmp 0x1c5de
movq -0x450(%rbp), %rdi
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0x460(%rbp)
addq $0xa8, %rdi
callq 0x62f0
movq %rax, -0x440(%rbp)
leaq -0x438(%rbp), %rdi
leaq -0x440(%rbp), %rsi
callq 0x14130
movq -0x460(%rbp), %rdi
leaq -0x410(%rbp), %rdx
leaq -0x410(%rbp), %rcx
addq -0x418(%rbp), %rcx
movq -0x438(%rbp), %rsi
callq 0x1c830
movq %rax, -0x448(%rbp)
jmp 0x1c52d
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
movq -0x428(%rbp), %rdi
callq 0x6920
nopw %cs:(%rax,%rax)
nop
// File: metopa[P]HTTP_Server/src/content/CHTMLGenerator.cpp
// Function: CHTMLGenerator::enlarge(int)
CHTMLGenerator& CHTMLGenerator::enlarge( int sizeDelta ) {
	char buf[10];
	sprintf( buf, "%d", 6 + sizeDelta * 2 );
	applyAttr( "font", "size=" + string( buf ) );
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %eax
leal 0x6(%rax,%rax), %edx
leaq 0xd753(%rip), %rsi      # 0x2c0d0
xorl %eax, %eax
leaq -0x16(%rbp), %rdi
callq 0x6100
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6930
movq -0xa0(%rbp), %rdx
leaq 0xdc0c(%rip), %rsi      # 0x2c5b2
leaq -0x38(%rbp), %rdi
callq 0xa9d0
jmp 0x1e9b1
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6930
movq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0x16(%rbp), %rsi
callq 0xa9d0
jmp 0x1e9dd
leaq 0xdbd3(%rip), %rsi      # 0x2c5b7
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x1f030
jmp 0x1e9f6
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x1e1a0
jmp 0x1ea0c
leaq -0x70(%rbp), %rdi
callq 0x6310
leaq -0x90(%rbp), %rdi
callq 0x6310
leaq -0x91(%rbp), %rdi
callq 0x6550
leaq -0x38(%rbp), %rdi
callq 0x6310
leaq -0x39(%rbp), %rdi
callq 0x6550
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1eaaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1ea9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1ea8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6310
leaq -0x90(%rbp), %rdi
callq 0x6310
leaq -0x91(%rbp), %rdi
callq 0x6550
leaq -0x38(%rbp), %rdi
callq 0x6310
leaq -0x39(%rbp), %rdi
callq 0x6550
movq -0x48(%rbp), %rdi
callq 0x6920
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/content/CHTMLGenerator.cpp
// Function: CHTMLGenerator::substituteNL()
CHTMLGenerator& CHTMLGenerator::substituteNL() {
	unsigned long int n = 0;
	string htmlNL = "<br>";
	while ( ( n = data_m.find( '\n', n ) ) != data_m.npos ) {
		data_m.insert( n, htmlNL );
		n += htmlNL.size() + 1;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6930
movq -0x50(%rbp), %rdx
leaq 0xdab9(%rip), %rsi      # 0x2c5bd
leaq -0x30(%rbp), %rdi
callq 0xa9d0
jmp 0x1eb0f
leaq -0x31(%rbp), %rdi
callq 0x6550
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xa, %esi
callq 0x66b0
movq %rax, -0x10(%rbp)
cmpq $-0x1, %rax
je 0x1eb8c
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x6830
jmp 0x1eb47
leaq -0x30(%rbp), %rdi
callq 0x6360
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1eb18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x6550
jmp 0x1eb9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6310
jmp 0x1eb9f
leaq -0x30(%rbp), %rdi
callq 0x6310
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6920
nopl (%rax,%rax)
// File: metopa[P]HTTP_Server/src/content/CHTMLGenerator.cpp
// Function: CHTMLGenerator::wrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CHTMLGenerator::wrap( const string& title ) {
	return "<html>\n"
				   "  <head>\n"
				   "    <title>" + title + "</title>\n"
				   "  </head>\n"
				   "  <body>\n      " +
		   data_m + "\n"
				   "  </body>\n"
				   "</html>";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdx
leaq 0xd9d4(%rip), %rsi      # 0x2c5c2
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1eea0
movq -0x90(%rbp), %rsi
leaq 0xd9d2(%rip), %rdx      # 0x2c5de
leaq -0x58(%rbp), %rdi
callq 0x16cc0
jmp 0x1ec17
movq -0x98(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x16c70
jmp 0x1ec2d
movq -0xa8(%rbp), %rdi
leaq 0xd9c6(%rip), %rdx      # 0x2c601
leaq -0x38(%rbp), %rsi
callq 0x16cc0
jmp 0x1ec46
leaq -0x38(%rbp), %rdi
callq 0x6310
leaq -0x58(%rbp), %rdi
callq 0x6310
leaq -0x78(%rbp), %rdi
callq 0x6310
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1ecb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1ecab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6310
leaq -0x58(%rbp), %rdi
callq 0x6310
leaq -0x78(%rbp), %rdi
callq 0x6310
movq -0x80(%rbp), %rdi
callq 0x6920
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/content/CPathResolver.cpp
// Function: CPathResolver::substitutePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string CPathResolver::substitutePath( string& path ) {
	for ( auto it = config.getFileMappings().begin(); it != config.getFileMappings().end(); it++ )
		if ( partialCompare( path, it->first ) ) {
			if ( it->second == "-" )
				throw PermissionDeniedException( path );
			else
				return it->second + path.substr( it->first.length() );
		}
	return config.getWorkDir() + path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x202df(%rip), %rdi     # 0x3f5e0
callq 0x8650
movq %rax, %rdi
callq 0x1fb30
movq %rax, -0x20(%rbp)
leaq 0x202c7(%rip), %rdi     # 0x3f5e0
callq 0x8650
movq %rax, %rdi
callq 0x1fba0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1fb60
testb $0x1, %al
jne 0x1f340
jmp 0x1f491
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1fbd0
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0x1f4d0
testb $0x1, %al
jne 0x1f36a
jmp 0x1f47b
leaq -0x20(%rbp), %rdi
callq 0x1fbd0
movq %rax, %rdi
addq $0x20, %rdi
leaq 0xd2a3(%rip), %rsi      # 0x2c624
callq 0x16f30
testb $0x1, %al
jne 0x1f38c
jmp 0x1f3e5
movl $0x48, %edi
callq 0x6280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
callq 0x168f0
jmp 0x1f3ae
movq -0x88(%rbp), %rdi
leaq 0x1f23c(%rip), %rsi     # 0x3e5f8
leaq -0x8a93(%rip), %rdx     # 0x16930
callq 0x68e0
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x63b0
jmp 0x1f4ba
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1fbd0
movq -0xa8(%rbp), %rdi
addq $0x20, %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x1fbd0
movq %rax, %rdi
callq 0x67d0
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq $-0x1, %rcx
callq 0x6500
movq -0x78(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x1fbf0
jmp 0x1f459
leaq -0x58(%rbp), %rdi
callq 0x6310
jmp 0x1f4ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6310
jmp 0x1f4ba
jmp 0x1f47d
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x1fc40
movq %rax, -0x60(%rbp)
jmp 0x1f312
leaq 0x20148(%rip), %rdi     # 0x3f5e0
callq 0x85f0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x16eb0
movq -0x70(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6920
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/content/CPathResolver.cpp
// Function: CPathResolver::partialCompare(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool CPathResolver::partialCompare( const string& a, const string& b ) {
	if ( a.length() < b.length() )
		return false;
	for ( unsigned long int i = 0; i < b.length(); i++ )
		if ( a[i] != b[i] )
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x67d0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x67d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f50c
movb $0x0, -0x1(%rbp)
jmp 0x1f578
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x67d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f574
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6580
movsbl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6580
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x1f564
movb $0x0, -0x1(%rbp)
jmp 0x1f578
jmp 0x1f566
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1f514
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/content/CPathResolver.cpp
// Function: CPathResolver::getExt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CPathResolver::getExt( const string& path ) {
	unsigned long int slash = path.find_last_of( '/' );
	unsigned long int dot = path.find_last_of( '.' );
	if ( dot > slash )
		return path.substr( dot + 1 );
	else
		return string();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x69c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x69c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x1f609
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
movq $-0x1, %rcx
callq 0x6500
jmp 0x1f612
movq -0x38(%rbp), %rdi
callq 0x6730
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: metopa[P]HTTP_Server/src/content/CStringContent.cpp
// Function: CStringContent::load()
void CStringContent::load() {
	string rawHtml = CHTMLGenerator( msg_m ).enlarge( 2 ).wrap( msg_m );
	size_m = rawHtml.size();
	data_m.insert( data_m.begin(), rawHtml.begin(), rawHtml.end() );
	creationTime();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
addq $0xa8, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
xorl %edx, %edx
callq 0x1df60
movq -0x98(%rbp), %rdi
movl $0x2, %esi
callq 0x1e950
movq %rax, -0x90(%rbp)
jmp 0x1fcfd
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdx
addq $0xa8, %rdx
leaq -0x28(%rbp), %rdi
callq 0x1ebb0
jmp 0x1fd1d
leaq -0x50(%rbp), %rdi
callq 0x16aa0
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6360
movq -0xa0(%rbp), %rdi
movq %rax, 0x60(%rdi)
addq $0x8, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x16dc0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x16df0
movq -0xb8(%rbp), %rdi
callq 0x6440
movq -0xb8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x62f0
movq -0xb0(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x16d10
movq %rax, -0xa8(%rbp)
jmp 0x1fda3
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x158a0
jmp 0x1fdbf
leaq -0x28(%rbp), %rdi
callq 0x6310
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x16aa0
jmp 0x1fdfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6310
movq -0x58(%rbp), %rdi
callq 0x6920
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::CLogger()
CLogger::CLogger() {
	logStream_m = &cerr;
	logStreamIsCOUT = true;
	pid_m = getpid();
	initialized_m = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x10, %rdi
callq 0x2b950
movq -0x10(%rbp), %rax
movq 0x1f128(%rip), %rcx     # 0x3eff0
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
callq 0x67a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movb $0x0, 0x3c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::~CLogger()
CLogger::~CLogger() {
	logStream_m->flush();
	if ( !logStreamIsCOUT ) {
		delete logStream_m;
		logStream_m = nullptr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x6330
jmp 0x1ff0e
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x1ff3e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1ff33
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x2b970
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb060
nopl (%rax)