LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::parseNewBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
void CParserINI::parseNewBlock( string& line, unsigned int& pos ) {
	string newBlock( "" );
	pos++;
	for ( ; pos < line.size() && isValidArgChar( line[pos] ); pos++ )
		newBlock.insert( newBlock.end(), line[pos] );
	if ( pos == line.size() )
		throw INIParserException( "End of line reached (']' expected)" );
	if ( line[pos] != ']' )
		throw INIParserException( "Unrecognized symbol (']' expected): ", line[pos] );

	currentBlock = newBlock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xec10(%rip), %rdx      # 0x18ecc
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x8e2c
movl (%r14), %eax
incl %eax
movl %eax, (%r14)
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jbe 0xa322
movq (%rbx), %rdx
movb (%rdx,%rax), %dl
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
jb 0xa308
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
setae %sil
cmpb $0x5f, %dl
setne %dil
testb %sil, %dil
jne 0xa322
movq 0x8(%rsp), %rsi
movsbl %dl, %r8d
movl $0x1, %ecx
movq %r12, %rdi
xorl %edx, %edx
callq 0x5780
jmp 0xa2ca
cmpq %rax, %rcx
je 0xa363
movq (%rbx), %rcx
cmpb $0x5d, (%rcx,%rax)
jne 0xa381
addq $0x30, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x5250
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa355
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r15
leaq 0xdf41(%rip), %rsi      # 0x182b8
movq %rax, %rdi
callq 0xa9f4
jmp 0xa3a7
movl $0x48, %edi
callq 0x5200
movq %rax, %r15
movl (%r14), %eax
movq (%rbx), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xdf3c(%rip), %rsi      # 0x182db
movq %r15, %rdi
callq 0xab94
leaq 0x17152(%rip), %rsi     # 0x21500
leaq -0x2499(%rip), %rdx     # 0x7f1c
movq %r15, %rdi
callq 0x56f0
jmp 0xa3bf
movq %rax, %rbx
movq %r15, %rdi
callq 0x52e0
jmp 0xa3d1
jmp 0xa3ce
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa3e7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
callq 0xa5b4
movq 0x8(%r14), %rcx
movl (%r15), %eax
cmpq %rax, %rcx
jbe 0xa432
movq (%r14), %rdx
movzbl (%rdx,%rax), %esi
cmpl $0x9, %esi
je 0xa423
cmpl $0x20, %esi
jne 0xa437
incl %eax
movl %eax, (%r15)
movq %rax, %rsi
cmpq %rax, %rcx
ja 0xa415
jmp 0xa439
movq %rax, %rsi
jmp 0xa439
movl %eax, %esi
cmpq %rsi, %rcx
je 0xa45b
incl %eax
movl %eax, (%r15)
movq (%r14), %rax
cmpb $0x3d, (%rax,%rsi)
jne 0xa479
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r12
leaq 0xde91(%rip), %rsi      # 0x18300
movq %rax, %rdi
callq 0xa9f4
jmp 0xa49f
movl $0x48, %edi
callq 0x5200
movq %rax, %r12
movl (%r15), %eax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xde8c(%rip), %rsi      # 0x18323
movq %r12, %rdi
callq 0xab94
leaq 0x1705a(%rip), %rsi     # 0x21500
leaq -0x2591(%rip), %rdx     # 0x7f1c
movq %r12, %rdi
callq 0x56f0
jmp 0xa4b7
movq %rax, %r14
movq %r12, %rdi
callq 0x52e0
jmp 0xa4c7
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xa4de
movq (%rbx), %rsi
incq %rsi
callq 0x53f0
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xa5b4
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb00a
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa541
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %r15, %rsi
movq %r14, %rdx
callq 0xa784
testb %al, %al
jne 0xa512
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xa57e
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa581
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xa581
movq %rax, %r14
movq %rbx, %rdi
callq 0x7fe8
movq %r14, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
movl (%rdx), %ecx
cmpq %rcx, %rax
jbe 0xa7b9
movq (%r14), %rdx
movzbl (%rdx,%rcx), %esi
cmpl $0x9, %esi
je 0xa7ab
cmpl $0x20, %esi
jne 0xa7be
incl %ecx
movl %ecx, (%rbx)
movq %rcx, %rsi
cmpq %rcx, %rax
ja 0xa79d
jmp 0xa7c0
movq %rcx, %rsi
jmp 0xa7c0
movl %ecx, %esi
cmpq %rsi, %rax
jne 0xa7c9
xorl %eax, %eax
jmp 0xa822
movq (%r14), %rax
movzbl (%rax,%rsi), %edx
xorl %eax, %eax
cmpl $0x23, %edx
je 0xa822
cmpl $0x2c, %edx
je 0xa81c
cmpl $0x3b, %edx
je 0xa822
movl $0x48, %edi
callq 0x5200
movq %rax, %r15
movl (%rbx), %eax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xdbb3(%rip), %rsi      # 0x183b1
movq %r15, %rdi
callq 0xab94
leaq 0x16cf3(%rip), %rsi     # 0x21500
leaq -0x28f8(%rip), %rdx     # 0x7f1c
movq %r15, %rdi
callq 0x56f0
incl %ecx
movl %ecx, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %rbp
movl %esi, %r13d
movq %rdi, %r15
cmpb $0x1, 0x3c(%rdi)
jne 0xa899
leaq 0x17c37(%rip), %rdi     # 0x224c0
movl %r13d, %esi
callq 0x67b4
testb %al, %al
je 0xa9e5
movq %rbx, 0x8(%rsp)
leaq 0x10(%r15), %rdi
movq %rdi, 0x10(%rsp)
callq 0x17b4e
movq %r15, %rdi
callq 0x10a90
movq (%r15), %rdi
leaq 0x3(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
callq 0x5450
movq %rax, %rbx
movl %r13d, %edi
callq 0x1102f
testq %rax, %rax
je 0xa8f4
movq %rax, %r13
movq %rax, %rdi
callq 0x51f0
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0xa90d
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x56e0
movb $0x20, %r13b
leaq 0x4(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5450
movq (%r15), %rbx
movq %rbp, %rdi
callq 0x51f0
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x5450
movq (%r15), %rdi
leaq 0x5(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
callq 0x5450
movq (%r15), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
callq 0x5700
movq (%r15), %rdi
leaq 0x6(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
callq 0x5450
movq (%r15), %rbx
movq %r12, %rdi
callq 0x51f0
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x5450
movq (%r15), %rdi
leaq 0x7(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
callq 0x5450
movq (%r15), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r15), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
movq 0x10(%rsp), %rdi
callq 0x17b62
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x5390
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x5220
leaq 0x68(%rbx), %rsi
movq %r14, %rdi
callq 0x5070
cmpb $0x0, 0x69(%rbx,%r15)
je 0xb400
incq %r15
cmpq $0x1f, %r15
jne 0xb3ed
jmp 0xb406
movb $0x0, 0x68(%rbx,%r15)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
jne 0xbb90
addq $0x20, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc150
jmp 0xbc61
leaq 0xcb10(%rip), %rsi      # 0x186a7
movq %r14, %rdi
callq 0x5150
testl %eax, %eax
je 0xbc11
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8d96
movq 0x8(%r15), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x2f, %r8d
callq 0x5780
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5160
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xbc2d
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xbc33
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x8d96
jmp 0xbc61
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xbc61
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xbc72
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xbc8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movq %rsp, %rsi
callq 0x5380
leaq 0x58(%rsp), %rdi
leaq 0x88(%rbx), %rsi
callq 0x5470
xorl %eax, %eax
cmpb $0x0, 0x89(%rbx,%rax)
je 0xbcd3
incq %rax
cmpq $0x1f, %rax
jne 0xbcbe
jmp 0xbcdb
movb $0x0, 0x88(%rbx,%rax)
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0xe0d8
cmpb $0x1, 0xc8(%rbx)
jne 0xe075
leaq 0xa8(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xed10
movq %r15, %rdi
callq 0xfd96
leaq 0x20(%rbx), %rdx
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xfe56
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x54a0
movq (%r15), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xe05a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe075
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0xa8(%rbx), %rdx
movq 0xb0(%rbx), %rcx
addq %rdx, %rcx
callq 0xdd18
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0xb3b8
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe0cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/content/CExternalContent.cpp
// Function: CExternalContent::exec()
void CExternalContent::exec() {
	int dataPipe[2];
	pipe( dataPipe );

	int chPID;
	if ( ( chPID = fork() ) == -1 ) {
		int errNo = errno;
		Log.ger<>( CRITICAL, "fork() failed, errno", errNo );
		close( dataPipe[0] );
		close( dataPipe[1] );
		throw InternalErrorException( realPath_m ); //TODO add args
	}

	if ( chPID == 0 ) {
		close( dataPipe[0] );
		dup2( dataPipe[1], STDOUT_FILENO );

		if ( isScript_m )
			exit( system( realPath_m.c_str() ) );
		else {
			execl( realPath_m.c_str(), realPath_m.c_str(), (char *) nullptr );
			exit( 127 );
		}
	}
	else {
		close( dataPipe[1] );
		readPipe( dataPipe[0] );
		close( dataPipe[0] );
		int rc;
		waitpid( chPID, &rc, 0 );
		if ( rc == 127 )
			throw PermissionDeniedException( realPath_m );
		if ( rc != 0 )
			throw ServiceUnavailableException( realPath_m );
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rdi
callq 0x5580
callq 0x5120
testl %eax, %eax
je 0xe171
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xe1a5
movl 0x8(%rsp), %edi
callq 0x57b0
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xe26e
movl 0x4(%rsp), %edi
callq 0x57b0
leaq 0xc(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5310
movl (%r14), %eax
testl %eax, %eax
jne 0xe140
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x7f, %eax
jne 0xe209
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbe54
leaq 0x1346c(%rip), %rsi     # 0x215d8
jmp 0xe200
movl 0x4(%rsp), %edi
callq 0x57b0
movl 0x8(%rsp), %edi
movl $0x1, %esi
callq 0x53a0
movq 0x40(%rbx), %rdi
cmpb $0x1, 0xc9(%rbx)
jne 0xe23b
callq 0x5330
movl %eax, %edi
callq 0x5480
callq 0x5060
movl (%rax), %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x14406(%rip), %rdi     # 0x225c0
leaq 0xa348(%rip), %rdx      # 0x18509
movl $0x1, %esi
callq 0xe348
movl 0x4(%rsp), %edi
callq 0x57b0
movl 0x8(%rsp), %edi
callq 0x57b0
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe47a
leaq 0x134f8(%rip), %rsi     # 0x216f8
leaq -0x66e5(%rip), %rdx     # 0x7b22
jmp 0xe233
movl $0x28, %edi
callq 0x5200
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe4c6
leaq 0x134e4(%rip), %rsi     # 0x21710
leaq 0x2bf(%rip), %rdx       # 0xe4f2
movq %r14, %rdi
callq 0x56f0
movq %rdi, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x54b0
movl $0x7f, %edi
callq 0x5480
jmp 0xe255
jmp 0xe255
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x400, %edx            # imm = 0x400
movl %ebp, %edi
callq 0x55b0
movq %rax, %r13
callq 0x5060
testq %r13, %r13
je 0xe2f1
movq %rax, %r14
leaq 0xa8(%rbx), %r15
movq %rsp, %r12
testq %r13, %r13
js 0xe2d4
movq 0xa8(%rbx), %rdx
addq 0xb0(%rbx), %rdx
leaq (%rsp,%r13), %r8
movq %r15, %rdi
movq %rdx, %rsi
movq %r12, %rcx
callq 0xe68e
jmp 0xe2da
cmpl $0x4, (%r14)
jne 0xe303
movl $0x400, %edx            # imm = 0x400
movl %ebp, %edi
movq %r12, %rsi
callq 0x55b0
movq %rax, %r13
testq %rax, %rax
jne 0xe2ad
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe47a
leaq 0x133d2(%rip), %rsi     # 0x216f8
leaq -0x680b(%rip), %rdx     # 0x7b22
movq %r14, %rdi
callq 0x56f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leal 0x6(%rsi,%rsi), %edx
leaq 0x84cd(%rip), %rsi      # 0x180ec
leaq 0x6e(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x50d0
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8990(%rip), %rsi      # 0x185ce
leaq 0x898d(%rip), %rdx      # 0x185d2
leaq 0x48(%rsp), %rdi
callq 0x8e2c
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x51f0
leaq (%rsp,%rax), %rdx
addq $0x6e, %rdx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x8e2c
leaq 0x8956(%rip), %rcx      # 0x185d3
leaq 0x28(%rsp), %rdi
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5440
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xfcb8
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xfcbf
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xf15e
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfcff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xfd16
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xfd2d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfd5b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xfd5b
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xfd77
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xfd77
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xfd8e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8827(%rip), %rsi      # 0x185d9
leaq 0x8824(%rip), %rdx      # 0x185dd
movq %rsp, %rdi
callq 0x8e2c
movq %rbx, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x5530
cmpq $-0x1, %rax
je 0xfe11
movq %rax, %r14
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5440
movq 0x8(%rsp), %rax
leaq (%r14,%rax), %rdx
incq %rdx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x5530
movq %rax, %r14
cmpq $-0x1, %rax
jne 0xfdd9
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xfe27
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xfe4d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8772(%rip), %rsi      # 0x185de
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x100c0
leaq 0x877a(%rip), %rsi      # 0x185fa
movq %r15, %rdi
callq 0x57a0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xfeae
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0xfeb5
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x5160
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xff02
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0xff09
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x86f1(%rip), %rsi      # 0x1861d
callq 0x57a0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xff53
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xff59
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0xff87
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xff9d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xffb8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0xffe4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xffe4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xffff
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xffff
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1001a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/content/CPathResolver.cpp
// Function: CPathResolver::unwindPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CPathResolver::unwindPath( const string& path ) {
	int depth = 0;
	int state = 0;
	for ( unsigned long int i = 0; i < path.length() && depth >= 0; i++ ) {
		switch ( state ) {
			case 0:
				if ( path[i] == '.' )
					state = 2;
				else if ( path[i] == '/' )
					state = 0;
				else state = 1;
				break;
			case 1:
				if ( path[i] == '/' ) {
					state = 0;
					depth++;
				}
				break;
			case 2:
				if ( path[i] == '.' )
					state = 3;
				else if ( path[i] == '/' )
					state = 0;
				else state = 1;
				break;
			case 3:
				if ( path[i] == '.' ) {
					state = 0;
					depth--;
				}
				else state = 1;
				break;
			default:
				break;
		}
	}
	if ( depth < 0 )
		throw PermissionDeniedException( path );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x101ee
movq %rsi, %rbx
movq (%rsi), %rdx
xorl %ecx, %ecx
movl $0x1, %esi
movb -0x1(%rdx,%rsi), %r9b
movl %ecx, %r8d
leaq 0x84bb(%rip), %rdi      # 0x18630
movslq (%rdi,%r8,4), %r8
addq %rdi, %r8
jmpq *%r8
incq %rsi
movb -0x1(%rdx,%rsi), %r9b
movl %r8d, %r8d
movslq (%rdi,%r8,4), %r8
addq %rdi, %r8
jmpq *%r8
movl $0x2, %r8d
jmp 0x101d0
xorl %r10d, %r10d
xorl %r8d, %r8d
cmpb $0x2e, %r9b
sete %r10b
setne %r8b
subl %r10d, %ecx
jmp 0x101e1
xorl %r10d, %r10d
xorl %r8d, %r8d
cmpb $0x2f, %r9b
sete %r10b
setne %r8b
addl %r10d, %ecx
jmp 0x101e1
movl $0x3, %r8d
cmpb $0x2e, %r9b
je 0x101e1
xorl %r8d, %r8d
cmpb $0x2f, %r9b
setne %r8b
cmpq %rax, %rsi
jae 0x101ea
testl %ecx, %ecx
jns 0x1017f
testl %ecx, %ecx
js 0x101f6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbe54
leaq 0x113c3(%rip), %rsi     # 0x215d8
leaq -0x86fa(%rip), %rdx     # 0x7b22
movq %r14, %rdi
callq 0x56f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x12270(%rip), %r15     # 0x224c0
movq %r15, %rdi
callq 0x6830
movq (%rax), %r12
movq %r15, %rdi
callq 0x6830
cmpq 0x8(%rax), %r12
je 0x10323
leaq 0x1224c(%rip), %r15     # 0x224c0
movq 0x8(%r12), %rax
cmpq %rax, 0x8(%r14)
jae 0x10296
addq $0x40, %r12
movq %r15, %rdi
callq 0x6830
cmpq 0x8(%rax), %r12
jne 0x10274
jmp 0x10323
testq %rax, %rax
je 0x102b6
movq (%r14), %rcx
movq (%r12), %rdx
xorl %esi, %esi
movb (%rcx,%rsi), %dil
cmpb (%rdx,%rsi), %dil
jne 0x1027f
incq %rsi
cmpq %rsi, %rax
jne 0x102a4
leaq 0x20(%r12), %rdi
leaq 0x837e(%rip), %rsi      # 0x18640
callq 0x5150
testl %eax, %eax
je 0x10386
movq 0x8(%r12), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x5400
movq 0x20(%r12), %rcx
movq 0x28(%r12), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5440
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1033f
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x10345
leaq 0x12196(%rip), %rdi     # 0x224c0
callq 0x681e
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xc150
jmp 0x10377
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10377
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xbe54
leaq 0x11233(%rip), %rsi     # 0x215d8
leaq -0x888a(%rip), %rdx     # 0x7b22
movq %r15, %rdi
callq 0x56f0
movq %rax, %rbx
movq %r15, %rdi
callq 0x52e0
jmp 0x103df
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x103df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x57c0
movq %rax, %r15
movq %r14, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x57c0
cmpq %r15, %rax
jbe 0x10477
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x5400
jmp 0x1048a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xed10
movq %r15, %rdi
movl $0x2, %esi
callq 0xfc06
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xfe56
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x107a9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x10(%rsp), %rcx
movq %rcx, 0x60(%rbx)
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
addq %rdx, %rcx
callq 0xdd18
movq %rbx, %rdi
callq 0xb3b8
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x107ea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x107f6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1082c
movq 0x18(%rsp), %rsi
jmp 0x10824
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1082c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x17b40
movq 0x11728(%rip), %rax     # 0x21ff0
movq %rax, (%rbx)
movb $0x1, 0x8(%rbx)
callq 0x55e0
movl %eax, 0x38(%rbx)
movb $0x0, 0x3c(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5290
cmpb $0x0, 0x8(%rbx)
jne 0x10905
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x108fe
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x17b48
movq %rax, %rdi
callq 0x7cac
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CLogger::init( const string& logFile ) {
	if ( logFile == "stdout" ) {
		logStreamIsCOUT = true;
		logStream_m = &cout;
	}
	else {
		logStreamIsCOUT = false;
		ofstream * lfile = new ofstream( logFile.c_str() );
		if ( !lfile->is_open() ) {
			delete lfile;
			throw FileNotFoundException( logFile.c_str(), MSG_CRIT_ERR );
		}
		logStream_m = lfile;
	}
	initialized_m = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x778a(%rip), %rsi      # 0x180bb
movq %r14, %rdi
callq 0x5150
testl %eax, %eax
je 0x109ee
movb $0x0, 0x8(%rbx)
movl $0x200, %edi            # imm = 0x200
callq 0x53e0
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movl $0x10, %edx
callq 0x5420
movq %r15, %rdi
addq $0x70, %rdi
callq 0x50f0
testb %al, %al
jne 0x109f9
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movl $0x48, %edi
callq 0x5200
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7ae4
leaq 0x11a7b(%rip), %rax     # 0x22420
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x7ae4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x8492
leaq 0x10a75(%rip), %rax     # 0x21448
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x109f9(%rip), %rsi     # 0x213d8
leaq -0x8ec4(%rip), %rdx     # 0x7b22
movq %rbx, %rdi
callq 0x56f0
movb $0x1, 0x8(%rbx)
movq 0x115d7(%rip), %r15     # 0x21fd0
movq %r15, (%rbx)
movb $0x1, 0x3c(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10a29
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10a44
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
testb %bpl, %bpl
jne 0x10a6e
jmp 0x10a88
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10a6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x10a6e
movq %rax, %r14
movq %rbx, %rdi
callq 0x52e0
jmp 0x10a88
movq %rax, %r14
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
callq 0x53f0
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::printTimestamp()
void CLogger::printTimestamp() {
	time_t ltime;
	tm result;
	char stime[32];

	*logStream_m << '(' << pid_m << ')' << ' ';

	ltime = time( NULL );
	localtime_r( &ltime, &result );
	asctime_r( &result, stime );
	for ( int i = 1; i < 32; i++ )
		if ( !stime[i] ) {
			stime[i - 1] = 0;
			break;
		}
	*logStream_m << stime;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x28(%rsp), %r14
movb $0x28, (%r14)
movl $0x1, %r15d
movl $0x1, %edx
movq %r14, %rsi
callq 0x5450
movl 0x38(%rbx), %esi
movq %rax, %rdi
callq 0x5700
movb $0x29, (%r14)
leaq 0x28(%rsp), %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5450
movb $0x20, (%r14)
leaq 0x28(%rsp), %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x5450
xorl %edi, %edi
callq 0x5390
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x5220
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5070
cmpb $0x0, (%rsp,%r15)
je 0x10b2e
incq %r15
cmpq $0x20, %r15
jne 0x10b1c
jmp 0x10b34
movb $0x0, -0x1(%rsp,%r15)
movq (%rbx), %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x51f0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5450
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::error(ELogFlags, int)
void CLogger::error( ELogFlags level, int errNo ) {
	if ( !initialized_m || config.checkLogFlag( level ) ) {
		mutex_m.lock();
		printTimestamp();
		*logStream_m << '\t' << logflagsNS::logFlagsToString( level ) << '\t' << strerror( errNo ) << endl;
		mutex_m.unlock();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
cmpb $0x1, 0x3c(%rdi)
jne 0x10bc6
leaq 0x1190a(%rip), %rdi     # 0x224c0
movl %r15d, %esi
callq 0x67b4
testb %al, %al
je 0x10cbc
leaq 0x10(%r14), %rbx
movq %rbx, %rdi
callq 0x17b4e
movq %r14, %rdi
callq 0x10a90
movq (%r14), %rdi
leaq 0x6(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
callq 0x5450
movq %rax, %r14
movl %r15d, %edi
callq 0x11014
testq %rax, %rax
je 0x10c1a
movq %rax, %r15
movq %rax, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x10c34
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x56e0
leaq 0x7(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x5450
movq %rax, %r14
movl %ebp, %edi
callq 0x51b0
testq %rax, %rax
je 0x10c73
movq %rax, %r15
movq %rax, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x10c8d
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x56e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
movq %rbx, %rdi
callq 0x17b62
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::options()
void CLogger::options() {
	if ( initialized_m ) {
		*logStream_m << "Log options: ";
		for ( int i = 0; i < E_LOG_FLAGS_MAX; i++ )
			if ( config.checkLogFlag( ELogFlags( i ) ) )
				*logStream_m << logflagsNS::logFlagsToString( ELogFlags( i ) ) << ' ';
		*logStream_m << endl;
	}
}

// Assembly:
cmpb $0x1, 0x3c(%rdi)
jne 0x10da7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x7a1d(%rip), %rsi      # 0x18707
movl $0xd, %edx
callq 0x5450
xorl %ebp, %ebp
leaq 0x117c3(%rip), %r14     # 0x224c0
leaq 0x7(%rsp), %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x67b4
testb %al, %al
je 0x10d68
movq (%rbx), %r12
movl %ebp, %edi
callq 0x11014
testq %rax, %rax
je 0x10d3a
movq %rax, %r13
movq %rax, %rdi
callq 0x51f0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x10d53
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x56e0
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5450
incl %ebp
cmpl $0xc, %ebp
jne 0x10d02
movq (%rbx), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/logger/ELogFlags.cpp
// Function: logflagsNS::logFlagsFromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
ELogFlags logflagsNS::logFlagsFromString( std::string& str ) {
	for ( int i = 0; i < E_LOG_FLAGS_MAX; i++ )
		if ( str.compare( logFlagsToString( (ELogFlags) i ) ) == 0 )
			return (ELogFlags) i;
	return UNDEFINED;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x107b8(%rip), %r14     # 0x21818
leaq 0x772b(%rip), %r15      # 0x18792
movq %r15, %rsi
cmpl $0xa, %ebp
ja 0x11072
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5150
testl %eax, %eax
je 0x1108e
incl %ebp
addq $0x8, %r14
cmpl $0xc, %ebp
jne 0x11067
movl $0xc, %ebp
cmpl $0xb, %ebp
movl $0xb, %eax
cmovbl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/threads/CThreadSafeQueue.h
// Function: CThreadSafeQueue<CRequest*, (CRequest*)0, 100u>::notifyProducerStopped()
void CThreadSafeQueue<T, defVal, TArraySize>::notifyProducerStopped() {
	mutex_m.lock();
	activeProducers_m--;
	mutex_m.unlock();
	if ( activeProducers_m == 0 )
		disable();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x328(%rdi), %r14
movq %r14, %rdi
callq 0x17b4e
decq 0x390(%rbx)
movq %r14, %rdi
callq 0x17b62
cmpq $0x0, 0x390(%rbx)
je 0x11825
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x398(%rbx)
leaq 0x350(%rbx), %rdi
callq 0x17b7e
addq $0x370, %rbx            # imm = 0x370
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17b7e
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/threads/CThreadPool.h
// Function: CThreadPool::CThreadPool<std::shared_ptr<CRunnable>>(std::shared_ptr<CRunnable> const&, void* (*)(void*))
CThreadPool( const T& e, void * (* func)( void * ) = CRunnable::threadRunner ) {
		pthread_attr_t attr;
		pthread_attr_init( &attr );
		pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
		int retCode;

		threads_m.push_back( pthread_t() );
		if ( ( retCode = pthread_create( &threads_m.back(), &attr, func, (void *) &( *e ) ) ) != 0 ) {
			threads_m.pop_back();
			Log.ger<>( CRITICAL, "pthread_create: failed to create thread. Error #", CLogger::NoSpace(), retCode );
		}

		pthread_attr_destroy( &attr );
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
movq %r13, 0x10(%rdi)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x5490
movq %r12, %rdi
xorl %esi, %esi
callq 0x5540
movq %r13, 0x10(%rsp)
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x119a8
movq $0x0, (%rax)
addq $0x8, %rax
movq %rax, 0x8(%rbx)
jmp 0x119bc
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x123fa
movq 0x8(%rbx), %rax
addq $-0x8, %rax
movq (%r15), %rcx
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x5750
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x11a02
addq $-0x8, 0x8(%rbx)
leaq 0x10bd9(%rip), %rdi     # 0x225c0
leaq 0x6eae(%rip), %rdx      # 0x1889c
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movl $0x1, %esi
callq 0x122e0
leaq 0x18(%rsp), %rdi
callq 0x56b0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x11a1c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x11a33
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x53f0
movq %r14, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/threads/CThreadPool.h
// Function: CThreadPool::CThreadPool<__gnu_cxx::__normal_iterator<std::shared_ptr<CRunnable>*, std::vector<std::shared_ptr<CRunnable>, std::allocator<std::shared_ptr<CRunnable>>>>>(__gnu_cxx::__normal_iterator<std::shared_ptr<CRunnable>*, std::vector<std::shared_ptr<CRunnable>, std::allocator<std::shared_ptr<CRunnable>>>> const&, __gnu_cxx::__normal_iterator<std::shared_ptr<CRunnable>*, std::vector<std::shared_ptr<CRunnable>, std::allocator<std::shared_ptr<CRunnable>>>> const&, void* (*)(void*))
CThreadPool( const InputIterator& beginIter, const InputIterator& endIter,
				 void * (* func)( void * ) = CRunnable::threadRunner ) {
		pthread_attr_t attr;
		pthread_attr_init( &attr );
		pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
		int retCode;

		for ( auto it = beginIter; it != endIter; it++ ) {
			threads_m.push_back( pthread_t() );
			if ( ( retCode = pthread_create( &threads_m.back(), &attr, func, (void *) &( **it ) ) ) != 0 ) {
				threads_m.pop_back();
				Log.ger<>( CRITICAL, "pthread_create: failed to create thread. Error #", CLogger::NoSpace(), retCode );
			}
		}

		pthread_attr_destroy( &attr );
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x5490
movq %r13, %rdi
xorl %esi, %esi
callq 0x5540
movq (%r12), %rbp
cmpq %rbp, (%r15)
je 0x11b11
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq $0x0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x11ab6
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x11ac5
movq %rbx, %rdi
movq %r12, %rdx
callq 0x123fa
movq 0x8(%rbx), %rsi
addq $-0x8, %rsi
movq (%rbp), %rcx
movq %rsi, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x5750
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x11b08
addq $-0x8, 0x8(%rbx)
leaq 0x10ad1(%rip), %rdi     # 0x225c0
movl $0x1, %esi
leaq 0x6da1(%rip), %rdx      # 0x1889c
movq %r12, %rcx
leaq 0x4(%rsp), %r8
callq 0x122e0
addq $0x10, %rbp
cmpq (%r15), %rbp
jne 0x11a92
leaq 0x10(%rsp), %rdi
callq 0x56b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11b2c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x11b43
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x53f0
movq %r14, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/network/CPortObtainer.cpp
// Function: CPortObtainer::CPortObtainer(char const*, int)
CPortObtainer::CPortObtainer( const char * port, int connsPerPort ) :
		addrinfo_m( port ), socket_m( addrinfo_m, port ) {
	if ( listen( socket_m, connsPerPort ) == -1 )
		throw PortInitializationException( "listen()", strerror( errno ), port );

	Log.ger<>( DEBUG_NETWORK, port, "is binded to socket", (int) socket_m );
	if ( sscanf( port, "%d", &port_m ) != 1 )
		port_m = -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
callq 0x12858
leaq 0x8(%rbx), %r14
movq (%rbx), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x129ae
movl (%r14), %edi
movl %ebp, %esi
callq 0x5430
cmpl $-0x1, %eax
je 0x125d5
movl (%r14), %eax
leaq 0x18(%rsp), %r8
movl %eax, (%r8)
leaq 0x10035(%rip), %rdi     # 0x225c0
leaq 0x646e(%rip), %rcx      # 0x18a00
leaq 0x10(%rsp), %rdx
movl $0x5, %esi
callq 0x12cc6
movq 0x10(%rsp), %rdi
addq $0xc, %rbx
leaq 0x5b3b(%rip), %rsi      # 0x180ec
movq %rbx, %rdx
xorl %eax, %eax
callq 0x53d0
cmpl $0x1, %eax
je 0x125c6
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0x5200
movq %rax, %r15
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x6405(%rip), %rsi      # 0x189f7
leaq 0x6406(%rip), %rdx      # 0x189ff
leaq 0x18(%rsp), %rdi
callq 0x8e2c
callq 0x5060
movl (%rax), %edi
callq 0x51b0
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x7ae4
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rcx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x131a4
leaq 0xf382(%rip), %rax      # 0x219c8
movq %rax, (%r15)
xorl %ebp, %ebp
leaq 0xf236(%rip), %rsi      # 0x21888
leaq 0x62b(%rip), %rdx       # 0x12c84
movq %r15, %rdi
callq 0x56f0
movq %rax, %r12
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1267f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x12696
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53f0
testb %bpl, %bpl
jne 0x126bc
jmp 0x126c9
movq %rax, %r12
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x126bc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x126bc
movq %rax, %r12
movq %r15, %rdi
callq 0x52e0
jmp 0x126c9
movq %rax, %r12
movq %r14, %rdi
callq 0x12c68
jmp 0x126d6
movq %rax, %r12
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x126e3
callq 0x5520
movq %r12, %rdi
callq 0x5720
nop