LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdx, %r15
movq %rdi, %rbx
callq 0x9618
movq %r15, %rsi
movq %r12, %rdx
callq 0x9350
movl (%r12), %eax
cmpq %rax, 0x8(%r15)
je 0x94f4
leal 0x1(%rax), %ecx
movl %ecx, (%r12)
movq (%r15), %rcx
cmpb $0x3d, (%rcx,%rax)
jne 0x9510
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
leaq 0xadde(%rip), %rsi      # 0x142e4
movq %rax, %rdi
callq 0x991e
jmp 0x9535
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
movl (%r12), %eax
movq (%r15), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xadda(%rip), %rsi      # 0x14307
movq %r14, %rdi
callq 0x9a42
leaq 0x1704c(%rip), %rsi     # 0x20588
leaq -0x215f(%rip), %rdx     # 0x73e4
movq %r14, %rdi
callq 0x5740
jmp 0x954d
movq %rax, %r15
movq %r14, %rdi
callq 0x5300
jmp 0x955d
movq %rax, %r15
movq %rbx, %rdi
callq 0x5210
movq %r15, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x9618
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9fba
movq %r12, %rdi
callq 0x5210
movq %r15, %rsi
movq %r14, %rdx
callq 0x97ac
testb %al, %al
jne 0x9592
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x95e2
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5210
jmp 0x95e5
movq %rax, %r14
movq %rbx, %rdi
callq 0x745c
movq %r14, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::getIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
string CParserINI::getIdentifier( string& line, unsigned int& pos ) {
	string currentArg( "" );
	int delim;

	skipWS( line, pos );
	if ( pos == line.size() )
		throw INIParserException( "End of line reached (identifier expected)" );

	if ( line[pos] == '\'' || line[pos] == '"' ) {
		delim = line[pos++];
		while ( pos < line.size() ) {
			if ( line[pos] == delim ) {
				delim = -1;
				break;
			}
			currentArg.insert( currentArg.end(), line[pos] );
			pos++;
		}

		if ( delim != -1 )
			throw INIParserException( "End of line reached (quotation mark expected)" );
		pos++;
		return currentArg;
	}

	while ( pos < line.size() ) {
		if ( isValidArgChar( line[pos] ) )
			currentArg.insert( currentArg.end(), line[pos++] );
		else
			break;
	}

	if ( currentArg.empty() )
		throw INIParserException( "Empty identifier" );

	return currentArg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0xb8c1(%rip), %rsi      # 0x14ef0
leaq 0x7(%rsp), %rdx
callq 0x712a
movq %r15, %rsi
movq %r14, %rdx
callq 0x9350
movl (%r14), %ecx
movq 0x8(%r15), %rax
cmpq %rcx, %rax
je 0x9737
movq (%r15), %rsi
movzbl (%rsi,%rcx), %edx
cmpl $0x22, %edx
je 0x9669
cmpl $0x27, %edx
jne 0x96f2
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movb (%rsi,%rcx), %bpl
movl %edx, %ecx
cmpq %rcx, %rax
jbe 0x971e
movq (%r15), %rax
movb (%rax,%rcx), %al
cmpb %bpl, %al
je 0x9724
movq (%rbx), %rsi
addq 0x8(%rbx), %rsi
movsbl %al, %edx
movq %rbx, %rdi
callq 0x57c0
movl (%r14), %edx
incl %edx
movl %edx, (%r14)
movq 0x8(%r15), %rax
jmp 0x9673
movq (%r15), %rcx
movb (%rcx,%rax), %dl
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
jb 0x96d9
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
setae %sil
cmpb $0x5f, %dl
setne %dl
testb %sil, %dl
jne 0x96fb
movq (%rbx), %rsi
addq 0x8(%rbx), %rsi
leal 0x1(%rax), %edx
movl %edx, (%r14)
movsbl (%rcx,%rax), %edx
movq %rbx, %rdi
callq 0x57c0
movl (%r14), %eax
cmpq %rax, 0x8(%r15)
ja 0x96ad
cmpq $0x0, 0x8(%rbx)
jne 0x9729
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
leaq 0xac70(%rip), %rsi      # 0x14384
movq %rax, %rdi
callq 0x991e
jmp 0x976d
cmpb $-0x1, %bpl
jne 0x9753
incl %ecx
movl %ecx, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
leaq 0xabe3(%rip), %rsi      # 0x1432c
movq %rax, %rdi
callq 0x991e
jmp 0x976d
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
leaq 0xabf1(%rip), %rsi      # 0x14356
movq %rax, %rdi
callq 0x991e
leaq 0x16e14(%rip), %rsi     # 0x20588
leaq -0x2397(%rip), %rdx     # 0x73e4
movq %r14, %rdi
callq 0x5740
jmp 0x9787
jmp 0x9787
movq %rax, %r15
movq %r14, %rdi
callq 0x5300
jmp 0x979b
jmp 0x9798
jmp 0x9798
movq %rax, %r15
movq %rbx, %rdi
callq 0x5210
movq %r15, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x9350
movl (%rbx), %ecx
cmpq %rcx, 0x8(%r14)
jne 0x97c8
xorl %eax, %eax
jmp 0x981f
movq (%r14), %rax
movzbl (%rax,%rcx), %edx
xorl %eax, %eax
cmpl $0x23, %edx
je 0x981f
cmpl $0x2c, %edx
je 0x9819
cmpl $0x3b, %edx
je 0x981f
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r15
movl (%rbx), %eax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xab9a(%rip), %rsi      # 0x14395
movq %r15, %rdi
callq 0x9a42
leaq 0x16d7e(%rip), %rsi     # 0x20588
leaq -0x242d(%rip), %rdx     # 0x73e4
movq %r15, %rdi
callq 0x5740
incl %ecx
movl %ecx, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x5300
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/threads/../logger/CLogger.h
// Function: void CLogger::ger<char [32], char const*, CLogger::NoSpace, char [2], CLogger::NoSpace, int>(ELogFlags, char const (&) [32], char const* const&, CLogger::NoSpace const&, char const (&) [2], CLogger::NoSpace const&, int 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 $0x28, %rsp
movq %r9, %rbp
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpb $0x1, 0x3c(%rdi)
jne 0x1217f
leaq 0xf381(%rip), %rdi      # 0x214f0
movl %r15d, %esi
callq 0x6434
testb %al, %al
je 0x12213
movq %rbp, 0x10(%rsp)
movq %r13, 0x8(%rsp)
movq %rbx, %rbp
leaq 0x10(%r14), %rbx
movq %rbx, %rdi
callq 0x131de
movq %r14, %rdi
callq 0xdc5c
movq (%r14), %rdi
pushq $0x9
popq %rsi
callq 0x5480
movq %r12, %r13
movq %rax, %r12
movl %r15d, %edi
callq 0xdfce
movq %r12, %rdi
movq %rax, %rsi
callq 0x5400
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5480
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x20(%rsp), %r9
callq 0x123c2
movq (%r14), %rdi
callq 0x5220
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x131f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x53c0
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x5250
leaq 0x68(%rbx), %rsi
movq %r14, %rdi
callq 0x5070
cmpq $0x1f, %r15
je 0xa282
cmpb $0x0, 0x69(%rbx,%r15)
je 0xa27c
incq %r15
jmp 0xa269
movb $0x0, 0x68(%rbx,%r15)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x20(%rsi), %r15
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
jne 0xa754
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xaa91
jmp 0xa79f
leaq 0x9f30(%rip), %rsi      # 0x1468b
movq %r14, %rdi
callq 0xaac9
testb %al, %al
je 0xa774
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55d0
jmp 0xa79f
leaq 0x8(%rsp), %r12
pushq $0x2f
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xaad6
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xaa11
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x53b0
leaq 0x58(%rsp), %rdi
leaq 0x88(%rbx), %rsi
callq 0x54a0
xorl %eax, %eax
cmpq $0x1f, %rax
je 0xa80b
cmpb $0x0, 0x89(%rbx,%rax)
je 0xa803
incq %rax
jmp 0xa7ee
movb $0x0, 0x88(%rbx,%rax)
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc1c8
cmpb $0x1, 0xc8(%rbx)
jne 0xc176
leaq 0xa8(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xcb4c
movq %r15, %rdi
callq 0xd230
leaq 0x20(%rbx), %rdx
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xd2b8
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x54d0
movq %r15, %rdi
callq 0x5210
leaq 0x8(%rsp), %rdi
callq 0x5210
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0xa8(%rbx), %rdx
movq 0xb0(%rbx), %rcx
addq %rdx, %rcx
callq 0xaa50
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0xa234
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55b0
callq 0x5150
testl %eax, %eax
je 0xc25f
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xc291
movl 0x8(%rsp), %edi
callq 0x5810
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xc352
movl 0x4(%rsp), %edi
callq 0x5810
leaq 0xc(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5330
movl (%r14), %eax
testl %eax, %eax
jne 0xc230
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x7f, %eax
jne 0xc2f1
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa8c8
leaq 0x14406(%rip), %rsi     # 0x20660
jmp 0xc2e8
movl 0x4(%rsp), %edi
callq 0x5810
movl 0x8(%rsp), %edi
pushq $0x1
popq %rsi
callq 0x53d0
movq 0x40(%rbx), %rdi
cmpb $0x1, 0xc9(%rbx)
jne 0xc321
callq 0x5350
movl %eax, %edi
callq 0x54b0
callq 0x5060
movl (%rax), %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x1534a(%rip), %rdi     # 0x215f0
leaq 0x8240(%rip), %rdx      # 0x144ed
pushq $0x1
popq %rsi
callq 0xc406
movl 0x4(%rsp), %edi
callq 0x5810
movl 0x8(%rsp), %edi
callq 0x5810
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc4ae
leaq 0x14498(%rip), %rsi     # 0x20780
leaq -0x5173(%rip), %rdx     # 0x717c
jmp 0xc319
pushq $0x28
popq %rdi
callq 0x5230
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc4c4
leaq 0x14486(%rip), %rsi     # 0x20798
leaq 0x1bf(%rip), %rdx       # 0xc4d8
movq %r14, %rdi
callq 0x5740
movq %rdi, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x54e0
pushq $0x7f
popq %rdi
callq 0x54b0
jmp 0xc339
jmp 0xc339
movq %rax, %rbx
movq %r14, %rdi
callq 0x5300
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movq %rsp, %r15
movl $0x400, %edx            # imm = 0x400
movl %ebp, %edi
movq %r15, %rsi
callq 0x5600
movq %rax, %r12
callq 0x5060
testq %r12, %r12
je 0xc3e2
js 0xc3ad
movq 0xa8(%rbx), %rsi
addq 0xb0(%rbx), %rsi
leaq (%rsp,%r12), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0xc4ec
jmp 0xc370
cmpl $0x4, (%rax)
je 0xc370
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc4ae
leaq 0x143ad(%rip), %rsi     # 0x20780
leaq -0x525e(%rip), %rdx     # 0x717c
movq %r14, %rdi
callq 0x5740
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x5300
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/content/CFileContent.cpp
// Function: CFileContent::load()
void CFileContent::load() {
	ifstream is( realPath_m, ifstream::binary );
	if ( !is )
		throw FileNotFoundException( userPath_m.c_str(), "" );

	is.seekg( 0, is.end );
	size_m = (size_t) is.tellg();
	is.seekg( 0, is.beg );

	char * buf = new char[size_m];
	is.read( buf, size_m );

	size_m = (size_t) is.tellg();

	data_m.insert( data_m.begin(), buf, buf + size_m );
	delete[] buf;

	if ( !is.good() )
		throw FileErrorException( userPath_m.c_str() );

	is.close();

	modificationTime();
	creationTime();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %rbx
leaq 0x40(%rdi), %rsi
leaq 0x50(%rsp), %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x56e0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x70(%rsp,%rax)
jne 0xc846
leaq 0x50(%rsp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x55a0
leaq 0x50(%rsp), %rdi
callq 0x5760
movq %rax, 0x60(%rbx)
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55a0
movq 0x60(%rbx), %r15
movq %r15, %rdi
callq 0x5030
movq %rax, %r14
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x5520
leaq 0x50(%rsp), %rdi
callq 0x5760
movq %rax, 0x60(%rbx)
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rcx
addq %rax, %rcx
movq %r14, %rdx
callq 0xc996
movq %r14, %rdi
callq 0x5530
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x70(%rsp,%rax)
jne 0xc8a9
leaq 0x50(%rsp), %rdi
callq 0x50f0
movq %rbx, %rdi
callq 0xc946
movq %rbx, %rdi
callq 0xa234
leaq 0x50(%rsp), %rdi
callq 0x5140
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
movq 0x20(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x712a
leaq 0x8685(%rip), %rsi      # 0x14ef0
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x712a
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x7166
xorl %ebp, %ebp
leaq 0x13bc8(%rip), %rsi     # 0x20460
leaq -0x5723(%rip), %rdx     # 0x717c
movq %r14, %rdi
callq 0x5740
jmp 0xc8ef
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
movq 0x20(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x712a
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xa948
xorl %ebp, %ebp
leaq 0x13d98(%rip), %rsi     # 0x20678
leaq -0x576b(%rip), %rdx     # 0x717c
movq %r14, %rdi
callq 0x5740
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5210
jmp 0xc909
movq %rax, %rbx
movb $0x1, %bpl
jmp 0xc909
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0xc91f
jmp 0xc934
jmp 0xc91c
movq %rax, %rbx
movq %r14, %rdi
callq 0x5300
jmp 0xc934
jmp 0xc931
jmp 0xc931
jmp 0xc931
jmp 0xc931
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x5140
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/content/CHTMLGenerator.cpp
// Function: CHTMLGenerator::makeTable(std::vector<CHTMLGenerator, std::allocator<CHTMLGenerator>>&)
CHTMLGenerator& CHTMLGenerator::makeTable( vector<CHTMLGenerator>& entries ) {
	CHTMLGenerator current;
	for ( auto it : entries ) {
		current = it;
		current.applyAttr( "td" ).applyAttr( "tr" ).append( '\n' );
		append( current );
	}
	applyAttr( "table" );

	return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
leaq 0x7f1e(%rip), %rsi      # 0x14ef0
leaq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x712a
leaq 0x60(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x55d0
leaq 0x60(%rsp), %r14
andl $0x0, 0x20(%r14)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x5210
movq (%r13), %r12
movq 0x8(%r13), %rbx
leaq 0x40(%rsp), %rbp
leaq 0x88(%rsp), %r13
cmpq %rbx, %r12
je 0xd0b2
movq %r15, %rdi
movq %r12, %rsi
callq 0xd480
movq %r14, %rdi
movq %r15, %rsi
callq 0xd49e
movq %rbp, %rdi
leaq 0x7561(%rip), %rsi      # 0x145a6
leaq 0xf(%rsp), %rdx
callq 0x712a
movq %r14, %rdi
movq %rbp, %rsi
callq 0xcb66
movq %r13, %rdi
leaq 0x7545(%rip), %rsi      # 0x145a9
leaq 0xe(%rsp), %rdx
callq 0x712a
movq %r14, %rdi
movq %r13, %rsi
callq 0xcb66
movq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x5360
movq %r13, %rdi
callq 0x5210
movq %rbp, %rdi
callq 0x5210
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x5800
movq %r15, %rdi
callq 0x5210
addq $0x28, %r12
jmp 0xd01c
leaq 0x74f3(%rip), %rsi      # 0x145ac
leaq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x712a
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xcb66
leaq 0x18(%rsp), %rdi
callq 0x5210
leaq 0x60(%rsp), %rdi
callq 0x5210
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd124
jmp 0xd116
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0xd152
movq %rax, %rbx
jmp 0xd157
movq %rax, %rbx
jmp 0xd14d
jmp 0xd124
jmp 0xd11f
movq %rax, %rbx
jmp 0xd139
movq %rax, %rbx
jmp 0xd143
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x5210
leaq 0x40(%rsp), %rdi
callq 0x5210
leaq 0x18(%rsp), %rdi
callq 0x5210
leaq 0x60(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leal 0x6(%rsi,%rsi), %edx
leaq 0x6f5b(%rip), %rsi      # 0x140d0
leaq 0x6e(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x50d0
leaq 0x7427(%rip), %rsi      # 0x145b2
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x712a
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %r14, %rsi
callq 0x712a
leaq 0x7404(%rip), %rsi      # 0x145b7
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd4bf
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xcccc
leaq 0x28(%rsp), %rdi
callq 0x5210
leaq 0x8(%rsp), %rdi
callq 0x5210
leaq 0x48(%rsp), %rdi
callq 0x5210
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5210
jmp 0xd20f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
jmp 0xd21e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x7379(%rip), %rsi      # 0x145bd
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x712a
xorl %edx, %edx
pushq $0xa
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5570
cmpq $-0x1, %rax
je 0xd28a
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x56c0
movq 0x10(%rsp), %rax
leaq (%r15,%rax), %rdx
incq %rdx
jmp 0xd25b
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x72f4(%rip), %rsi      # 0x145c2
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0xd409
leaq 0x72fc(%rip), %rdx      # 0x145de
movq %rsp, %rdi
movq %r15, %rsi
callq 0xaa30
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0xaa11
leaq 0x72fd(%rip), %rdx      # 0x14601
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xaa30
leaq 0x20(%rsp), %rdi
callq 0x5210
movq %rsp, %rdi
callq 0x5210
leaq 0x40(%rsp), %rdi
callq 0x5210
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5210
jmp 0xd34c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5210
jmp 0xd359
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
xorl %edx, %edx
leaq 0x7119(%rip), %rsi      # 0x14614
pushq $0x2
popq %rdi
pushq $0x3
popq %r8
xorl %r10d, %r10d
xorl %r9d, %r9d
cmpq %rcx, %rdx
jae 0xd575
testl %r9d, %r9d
js 0xd575
movb (%rax,%rdx), %r11b
movl %r10d, %r10d
movslq (%rsi,%r10,4), %r10
addq %rsi, %r10
jmpq *%r10
cmpb $0x2e, %r11b
jne 0xd539
movl %edi, %r10d
jmp 0xd570
cmpb $0x2e, %r11b
jne 0xd539
movl %r8d, %r10d
jmp 0xd570
xorl %r10d, %r10d
cmpb $0x2f, %r11b
setne %r10b
jmp 0xd570
xorl %ebp, %ebp
xorl %r10d, %r10d
cmpb $0x2e, %r11b
sete %bpl
setne %r10b
subl %ebp, %r9d
jmp 0xd570
xorl %ebp, %ebp
xorl %r10d, %r10d
cmpb $0x2f, %r11b
sete %bpl
setne %r10b
addl %ebp, %r9d
incq %rdx
jmp 0xd508
testl %r9d, %r9d
js 0xd57f
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa8c8
leaq 0x130c4(%rip), %rsi     # 0x20660
leaq -0x6427(%rip), %rdx     # 0x717c
movq %r14, %rdi
callq 0x5740
movq %rax, %rbx
movq %r14, %rdi
callq 0x5300
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13f1a(%rip), %r12     # 0x214f0
movq %r12, %rdi
callq 0x64b0
movq (%rax), %r15
movq %r12, %rdi
callq 0x64b0
cmpq 0x8(%rax), %r15
je 0xd604
movq %r14, %rsi
movq %r15, %rdx
callq 0xd6c4
testb %al, %al
jne 0xd620
addq $0x40, %r15
jmp 0xd5e1
leaq 0x13ee5(%rip), %rdi     # 0x214f0
callq 0x649e
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xaa91
jmp 0xd666
leaq 0x20(%r15), %r12
leaq 0x6ff9(%rip), %rsi      # 0x14624
movq %r12, %rdi
callq 0xaac9
testb %al, %al
jne 0xd675
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x5430
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xd9c3
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xa8c8
leaq 0x12fce(%rip), %rsi     # 0x20660
leaq -0x651d(%rip), %rdx     # 0x717c
movq %r15, %rdi
callq 0x5740
movq %rax, %rbx
movq %r15, %rdi
callq 0x5300
jmp 0xd6bb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
pushq $0x2f
popq %rsi
pushq $-0x1
popq %r15
movq %rdx, %rdi
movq %r15, %rdx
callq 0x5820
movq %rax, %r12
pushq $0x2e
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x5820
cmpq %r12, %rax
jbe 0xd740
incq %rax
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5430
jmp 0xd750
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xcb4c
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0xd160
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xd2b8
leaq 0x28(%rsp), %rdi
callq 0x5210
movq 0x10(%rsp), %rcx
movq %rcx, 0x60(%rbx)
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
addq %rdx, %rcx
callq 0xaa50
movq %rbx, %rdi
callq 0xa234
leaq 0x8(%rsp), %rdi
callq 0x5210
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xda6e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xda80
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x131d0
movq 0x1350c(%rip), %rax     # 0x20ff0
movq %rax, (%rbx)
movb $0x1, 0x8(%rbx)
callq 0x5630
movl %eax, 0x38(%rbx)
movb $0x0, 0x3c(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x52b0
cmpb $0x0, 0x8(%rbx)
jne 0xdb1e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xdb1a
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, (%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x131d8
movq %rax, %rdi
callq 0x7285
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6554(%rip), %rsi      # 0x1409f
movq %r14, %rdi
callq 0xaac9
testb %al, %al
je 0xdb64
movb $0x1, 0x8(%rbx)
movq 0x1346e(%rip), %r15     # 0x20fd0
jmp 0xdb93
movb $0x0, 0x8(%rbx)
movl $0x200, %edi            # imm = 0x200
callq 0x5410
movq %rax, %r15
movq (%r14), %rsi
pushq $0x10
popq %rdx
movq %rax, %rdi
callq 0x5460
movq %r15, %rdi
addq $0x70, %rdi
callq 0x5100
testb %al, %al
je 0xdba5
movq %r15, (%rbx)
movb $0x1, 0x3c(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x712a
leaq 0x1387e(%rip), %rax     # 0x21450
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x712a
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x7166
xorl %ebp, %ebp
leaq 0x1285e(%rip), %rsi     # 0x20460
leaq -0x6a8d(%rip), %rdx     # 0x717c
movq %rbx, %rdi
callq 0x5740
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5210
jmp 0xdc26
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0xdc3a
jmp 0xdc54
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
jmp 0xdc54
movq %rax, %r14
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
callq 0x5420
movq %r14, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
pushq $0x28
popq %rsi
callq 0x5480
movl 0x38(%rbx), %esi
movq %rax, %rdi
callq 0x5750
pushq $0x29
popq %rsi
movq %rax, %rdi
callq 0x5480
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5480
xorl %edi, %edi
callq 0x53c0
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x30(%rsp), %r14
movq %r14, %rsi
callq 0x5250
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5070
pushq $0x1
popq %rax
cmpq $0x20, %rax
je 0xdcd2
cmpb $0x0, (%rsp,%rax)
je 0xdccd
incq %rax
jmp 0xdcbc
movb $0x0, -0x1(%rsp,%rax)
movq (%rbx), %rdi
movq %rsp, %rsi
callq 0x5400
addq $0x68, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
cmpb $0x1, 0x3c(%rdi)
jne 0xdd27
leaq 0x137d4(%rip), %rdi     # 0x214f0
movl %ebp, %esi
callq 0x6434
testb %al, %al
je 0xdd97
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x131de
movq %r15, %rdi
callq 0xdc5c
movq (%r15), %rdi
pushq $0x9
popq %r15
movl %r15d, %esi
callq 0x5480
movq %rax, %r12
movl %ebp, %edi
callq 0xdfb0
movq %r12, %rdi
movq %rax, %rsi
callq 0x5400
movq %rax, %rdi
movl %r15d, %esi
callq 0x5480
movq %rax, %r15
movl %ebx, %edi
callq 0x51c0
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
movq %rax, %rdi
callq 0x5220
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x131f2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xde04
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x6930(%rip), %rsi      # 0x146eb
callq 0x5400
xorl %ebp, %ebp
leaq 0x13727(%rip), %r14     # 0x214f0
pushq $0x20
popq %r15
cmpl $0xc, %ebp
je 0xde05
movq %r14, %rdi
movl %ebp, %esi
callq 0x6434
testb %al, %al
je 0xde00
movq (%rbx), %r12
movl %ebp, %edi
callq 0xdfb0
movq %r12, %rdi
movq %rax, %rsi
callq 0x5400
movq %rax, %rdi
movl %r15d, %esi
callq 0x5480
incl %ebp
jmp 0xddcd
retq
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5220
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::printStatistic(int, std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&, 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&)
void CLogger::printStatistic( int port, const high_resolution_clock::time_point& time, const string& input,
							  const string& output ) {
	if ( !initialized_m || config.checkLogFlag( STATISTICS ) ) {
		mutex_m.lock();
		printTimestamp();
		auto us = chrono::duration_cast<chrono::microseconds>( high_resolution_clock::now() - time ).count();
		auto ms = us / 1000;
		us %= 1000;
		*logStream_m << '\t' << logflagsNS::logFlagsToStringPrintable( STATISTICS ) << ' ' <<
		"port:" << port << '\t' <<
		"processing_time(ms):" << ms << '.' << us << '\t' <<
		//"request_header:" << substractHeader( inputMsg_m ) << '\t' <<
		"request_size:" << input.size() << "\t" <<

		"response_size:" << output.size() << endl;
		mutex_m.unlock();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
cmpb $0x1, 0x3c(%rdi)
jne 0xde4f
leaq 0x136b1(%rip), %rdi     # 0x214f0
pushq $0xa
popq %rsi
callq 0x6434
testb %al, %al
je 0xdf9f
movq %r14, 0x10(%rsp)
leaq 0x10(%r12), %rdi
movq %rdi, 0x8(%rsp)
callq 0x131de
movq %r12, %rdi
callq 0xdc5c
callq 0x5080
movq %rax, %rcx
subq (%rbx), %rcx
movl $0x3e8, %edi            # imm = 0x3E8
movq %rcx, %rax
cqto
idivq %rdi
movq %rax, %rsi
movl $0xf4240, %r8d          # imm = 0xF4240
movq %rcx, %rax
cqto
idivq %r8
movq %rax, %rbx
movq %rsi, %rax
cqto
idivq %rdi
movq %rdx, %r13
movq (%r12), %rdi
pushq $0x9
popq %r12
movl %r12d, %esi
callq 0x5480
movq %r15, %r14
movq %rax, %r15
pushq $0xa
popq %rdi
callq 0xdfce
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5480
leaq 0x681c(%rip), %rsi      # 0x146f9
movq %rax, %rdi
callq 0x5400
movq %rax, %rdi
movl %ebp, %esi
callq 0x5750
movq %rax, %rdi
movl %r12d, %esi
callq 0x5480
leaq 0x67fe(%rip), %rsi      # 0x146ff
movq %rax, %rdi
callq 0x5400
movq %rax, %rdi
movq %rbx, %rsi
callq 0x53e0
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
movq %r13, %rsi
callq 0x53e0
movq %rax, %rdi
movl %r12d, %esi
callq 0x5480
leaq 0x67d8(%rip), %rsi      # 0x14714
movq %rax, %rdi
callq 0x5400
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x6f98(%rip), %rsi      # 0x14eef
movq %rax, %rdi
callq 0x5400
leaq 0x67bc(%rip), %rsi      # 0x14722
movq %rax, %rdi
callq 0x5400
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x52a0
movq %rax, %rdi
callq 0x5220
movq 0x8(%rsp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x131f2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0xc, %ebx
je 0xe014
movl %ebx, %edi
callq 0xdfb0
movq %r14, %rdi
movq %rax, %rsi
callq 0x5180
testl %eax, %eax
je 0xe014
incl %ebx
jmp 0xdff5
cmpl $0xb, %ebx
pushq $0xb
popq %rax
cmovbl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x131de
decq 0x390(%rbx)
movq %r14, %rdi
callq 0x131f2
cmpq $0x0, 0x390(%rbx)
je 0xe61d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xef2e
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x54c0
movq %r12, %rdi
xorl %esi, %esi
callq 0x5580
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0xf0ac
movq 0x8(%rbx), %rdi
addq $-0x8, %rdi
movq (%r15), %rcx
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x57a0
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0xe74c
addq $-0x8, 0x8(%rbx)
leaq 0x12ebd(%rip), %rdi     # 0x215f0
leaq 0x6172(%rip), %rdx      # 0x148ac
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0xeff8
leaq 0x10(%rsp), %rdi
callq 0x5710
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xe764
movq %rax, %r14
movq %rbx, %rdi
callq 0xead0
movq %r14, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x54c0
movq %r12, %rdi
xorl %esi, %esi
callq 0x5580
movq (%r13), %rbp
leaq 0x8(%rsp), %r13
cmpq (%r15), %rbp
je 0xe81b
andq $0x0, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xf0ac
movq 0x8(%rbx), %rdi
addq $-0x8, %rdi
movq (%rbp), %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x57a0
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0xe815
addq $-0x8, 0x8(%rbx)
leaq 0x12df2(%rip), %rdi     # 0x215f0
pushq $0x1
popq %rsi
leaq 0x60a4(%rip), %rdx      # 0x148ac
movq %r13, %rcx
leaq 0x4(%rsp), %r8
callq 0xeff8
addq $0x10, %rbp
jmp 0xe7bd
leaq 0x10(%rsp), %rdi
callq 0x5710
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe836
movq %rax, %r14
movq %rbx, %rdi
callq 0xead0
movq %r14, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
callq 0xf4d0
leaq 0x8(%rbx), %r14
movq (%rbx), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0xf5d2
movl (%r14), %edi
movl %ebp, %esi
callq 0x5470
cmpl $-0x1, %eax
je 0xf2f0
movl (%r14), %eax
leaq 0x10(%rsp), %r8
movl %eax, (%r8)
leaq 0x12343(%rip), %rdi     # 0x215f0
leaq 0x575c(%rip), %rcx      # 0x14a10
pushq $0x5
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0xf852
movq 0x8(%rsp), %rdi
addq $0xc, %rbx
leaq 0x4dff(%rip), %rsi      # 0x140d0
movq %rbx, %rdx
xorl %eax, %eax
callq 0x53f0
cmpl $0x1, %eax
je 0xf2e3
orl $-0x1, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x5230
movq %rax, %r15
leaq 0x5705(%rip), %rsi      # 0x14a07
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x712a
callq 0x5060
movl (%rax), %edi
callq 0x51c0
leaq 0x30(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rax, %rsi
callq 0x712a
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
pushq $-0x2
popq %r8
movq %r15, %rdi
movq %r12, %rcx
callq 0xf818
xorl %ebp, %ebp
leaq 0x11564(%rip), %rsi     # 0x208b8
leaq 0x4d3(%rip), %rdx       # 0xf82e
movq %r15, %rdi
callq 0x5740
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0x5210
jmp 0xf378
movq %rax, %r12
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0xf38c
jmp 0xf399
movq %rax, %r12
movq %r15, %rdi
callq 0x5300
jmp 0xf399
movq %rax, %r12
movq %r14, %rdi
callq 0xf7fc
jmp 0xf3a6
movq %rax, %r12
movq %rbx, %rdi
callq 0xf5c4
movq %r12, %rdi
callq 0x5770