LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5710
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 0x10b9e
incq %r15
cmpq $0x20, %r15
jne 0x10b8c
jmp 0x10ba4
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_O1/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 0x10c36
leaq 0x118a2(%rip), %rdi     # 0x224c8
movl %r15d, %esi
callq 0x6848
testb %al, %al
je 0x10d2c
leaq 0x10(%r14), %rbx
movq %rbx, %rdi
callq 0x17b62
movq %r14, %rdi
callq 0x10b00
movq (%r14), %rdi
leaq 0x6(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
callq 0x5450
movq %rax, %r14
movl %r15d, %edi
callq 0x11084
testq %rax, %rax
je 0x10c8a
movq %rax, %r15
movq %rax, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x10ca4
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x56f0
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 0x10ce3
movq %rax, %r15
movq %rax, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x10cfd
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x56f0
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 0x17b76
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10e17
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x79ad(%rip), %rsi      # 0x18707
movl $0xd, %edx
callq 0x5450
xorl %ebp, %ebp
leaq 0x1175b(%rip), %r14     # 0x224c8
leaq 0x7(%rsp), %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x6848
testb %al, %al
je 0x10dd8
movq (%rbx), %r12
movl %ebp, %edi
callq 0x11084
testq %rax, %rax
je 0x10daa
movq %rax, %r13
movq %rax, %rdi
callq 0x51f0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x10dc3
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x56f0
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5450
incl %ebp
cmpl $0xc, %ebp
jne 0x10d72
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_O1/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 0x10710(%rip), %r14     # 0x217e0
leaq 0x76bb(%rip), %r15      # 0x18792
movq %r15, %rsi
cmpl $0xa, %ebp
ja 0x110e2
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5150
testl %eax, %eax
je 0x110fe
incl %ebp
addq $0x8, %r14
cmpl $0xc, %ebp
jne 0x110d7
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_O1/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 0x17b62
decq 0x390(%rbx)
movq %r14, %rdi
callq 0x17b76
cmpq $0x0, 0x390(%rbx)
je 0x11895
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x398(%rbx)
leaq 0x350(%rbx), %rdi
callq 0x17b92
addq $0x370, %rbx            # imm = 0x370
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17b92
// File: /workspace/github_cpp_makefile_star2_O1/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), %rsi
cmpq 0x10(%rbx), %rsi
je 0x11a18
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x11a25
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x12474
movq 0x8(%rbx), %rdi
addq $-0x8, %rdi
movq (%r15), %rcx
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
callq 0x5760
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x11a6c
addq $-0x8, 0x8(%rbx)
leaq 0x10b77(%rip), %rdi     # 0x225c8
leaq 0x6e44(%rip), %rdx      # 0x1889c
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movl $0x1, %esi
callq 0x1235a
leaq 0x18(%rsp), %rdi
callq 0x56c0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x11a86
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x11a9d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x53f0
movq %r14, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11b78
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq $0x0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x11b20
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x11b2b
movq %rbx, %rdi
movq %r12, %rdx
callq 0x12474
movq 0x8(%rbx), %rdi
addq $-0x8, %rdi
movq (%rbp), %rcx
movq %r13, %rsi
movq %r14, %rdx
callq 0x5760
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x11b6f
addq $-0x8, 0x8(%rbx)
leaq 0x10a72(%rip), %rdi     # 0x225c8
movl $0x1, %esi
leaq 0x6d3a(%rip), %rdx      # 0x1889c
movq %r12, %rcx
leaq 0x4(%rsp), %r8
callq 0x1235a
addq $0x10, %rbp
cmpq (%r15), %rbp
jne 0x11afc
leaq 0x10(%rsp), %rdi
callq 0x56c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11b93
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x11baa
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x53f0
movq %r14, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
movq %rsi, 0x10(%rsp)
callq 0x128b0
leaq 0x8(%rbx), %r14
movq (%rbx), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x129f4
movl (%r14), %edi
movl %ebp, %esi
callq 0x5430
cmpl $-0x1, %eax
je 0x1264c
movl (%r14), %eax
leaq 0x18(%rsp), %r8
movl %eax, (%r8)
leaq 0xffc6(%rip), %rdi      # 0x225c8
leaq 0x63f7(%rip), %rcx      # 0x18a00
leaq 0x10(%rsp), %rdx
movl $0x5, %esi
callq 0x12cfc
movq 0x10(%rsp), %rdi
addq $0xc, %rbx
leaq 0x5ac4(%rip), %rsi      # 0x180ec
movq %rbx, %rdx
xorl %eax, %eax
callq 0x53d0
cmpl $0x1, %eax
je 0x1263d
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 0x638e(%rip), %rsi      # 0x189f7
leaq 0x638f(%rip), %rdx      # 0x189ff
leaq 0x18(%rsp), %rdi
callq 0x8f0e
callq 0x5060
movl (%rax), %edi
callq 0x51b0
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x7bea
movb $0x1, %bpl
movq 0x10(%rsp), %rcx
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %r15, %rdi
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x131da
leaq 0xf309(%rip), %rax      # 0x219c8
movq %rax, (%r15)
xorl %ebp, %ebp
leaq 0xf185(%rip), %rsi      # 0x21850
leaq 0x5e8(%rip), %rdx       # 0x12cba
movq %r15, %rdi
callq 0x5700
movq %rax, %r12
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12700
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x12700
movq %rax, %r12
movb $0x1, %bpl
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x1271f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x1271f
movq %rax, %r12
movb $0x1, %bpl
testb %bpl, %bpl
je 0x12731
movq %r15, %rdi
callq 0x52e0
jmp 0x12731
movq %rax, %r12
movq %r14, %rdi
callq 0x12c9e
jmp 0x1273e
movq %rax, %r12
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1274b
callq 0x5520
movq %r12, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/network/CPortObtainer.cpp
// Function: CPortObtainer::acceptConnection()
TSocketRemoteConnection CPortObtainer::acceptConnection() {
	TSocketRemoteConnection rConn;
	rConn.sockfd_m = accept( socket_m, (sockaddr *) &( rConn.remoteaddr_m ), &( rConn.addrlen_m ) );
	if ( rConn.sockfd_m == -1 ) {
		throw PortInitializationException( "accept()", strerror( errno ), port_m, socket_m );
	}

	Log.ger<>( DEBUG_NETWORK, port_m, "has new connection. Session socket", rConn.sockfd_m );
	return rConn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, (%rdi)
leaq 0x88(%rdi), %rdx
movl $0x80, 0x88(%rdi)
movl 0x8(%rsi), %edi
leaq 0x8(%rbx), %rsi
callq 0x5170
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x127ca
addq $0xc, %r14
leaq 0xfe23(%rip), %rdi      # 0x225c8
leaq 0x6271(%rip), %rcx      # 0x18a1d
movl $0x5, %esi
movq %r14, %rdx
movq %rbx, %r8
callq 0x12e12
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0x5200
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x622d(%rip), %rsi      # 0x18a14
leaq 0x622e(%rip), %rdx      # 0x18a1c
leaq 0x8(%rsp), %rdi
callq 0x8f0e
callq 0x5060
movl (%rax), %edi
callq 0x51b0
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x7bea
movl 0x8(%r14), %r8d
movl 0xc(%r14), %ecx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x13480
leaq 0xf18e(%rip), %rax      # 0x219c8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf00a(%rip), %rsi      # 0x21850
leaq 0x46d(%rip), %rdx       # 0x12cba
movq %rbx, %rdi
callq 0x5700
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1287b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x1287b
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1289a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x1289a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x128a7
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/network/CPortObtainer.cpp
// Function: CPortObtainer::CAddrInfoWrapper::CAddrInfoWrapper(char const*)
CPortObtainer::CAddrInfoWrapper::CAddrInfoWrapper( const char * port ) {
	addrinfo hints;

	memset( &hints, 0, sizeof( hints ) );

	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;

	int status;
	if ( ( status = getaddrinfo( NULL, port, &hints, &servinfo_m ) ) != 0 ) {
		servinfo_m = nullptr;
		throw PortInitializationException( "getaddrinfo()", gai_strerror( status ), port );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movl $0x1, %eax
movl %eax, 0x8(%rdx)
movl %eax, (%rdx)
xorl %edi, %edi
movq %rbx, %rcx
callq 0x54e0
testl %eax, %eax
jne 0x128fc
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
movq $0x0, (%rbx)
movl $0x50, %edi
callq 0x5200
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x611e(%rip), %rsi      # 0x18a40
leaq 0x6124(%rip), %rdx      # 0x18a4d
leaq 0x10(%rsp), %rdi
callq 0x8f0e
movl %ebp, %edi
callq 0x5590
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x7bea
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x131da
leaq 0xf057(%rip), %rax      # 0x219c8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xeed3(%rip), %rsi      # 0x21850
leaq 0x336(%rip), %rdx       # 0x12cba
movq %rbx, %rdi
callq 0x5700
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x129b2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x129b2
movq %rax, %r14
movb $0x1, %bpl
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x129d1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x129d1
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x129de
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/network/../exceptions/network/socket/../NetworkException.h
// Function: NetworkException::print(std::ostream&) const
virtual ostream& print( ostream& out ) const noexcept override {
		if ( sock_m == -2 )
			return out << selfName() << ' ' << func_m << " on port " << port_m << '(' << sock_m << "): " << err_m;
		else
			return out << selfName() << ' ' << func_m << " on port " << port_m << ": " << err_m;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x2, 0x4c(%rdi)
movq (%rdi), %rax
movq 0x18(%rax), %rax
jne 0x1331b
movq %rbx, %rdi
callq *%rax
movq %rax, %r15
testq %rax, %rax
je 0x13347
movq %r15, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x1335f
movq %rbx, %rdi
callq *%rax
movq %rax, %r15
testq %rax, %rax
je 0x133df
movq %r15, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x133f7
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x56f0
leaq 0xd(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x5450
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x5450
movq %rax, %r14
leaq 0x5741(%rip), %rsi      # 0x18acf
movl $0x9, %edx
movq %rax, %rdi
callq 0x5450
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x5710
leaq 0xe(%rsp), %rsi
movb $0x28, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5450
movl 0x4c(%rbx), %esi
movq %rax, %rdi
callq 0x5710
movq %rax, %r14
leaq 0x5002(%rip), %rsi      # 0x183d2
movl $0x3, %edx
movq %rax, %rdi
callq 0x5450
jmp 0x13455
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x56f0
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x5450
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x5450
movq %rax, %r14
leaq 0x56a9(%rip), %rsi      # 0x18acf
movl $0x9, %edx
movq %rax, %rdi
callq 0x5450
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x5710
movq %rax, %r14
leaq 0x4f8b(%rip), %rsi      # 0x183d3
movl $0x2, %edx
movq %rax, %rdi
callq 0x5450
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %r14, %rdi
callq 0x5450
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x7db2
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/network/CSocketIO.cpp
// Function: CSocketIO::sendData(char const*, unsigned long) const
void CSocketIO::sendData( const char * data, size_t size ) const {
	size_t sent = 0;
	ssize_t bytesSent;
	int errNo;

	while ( sent < size ) {
		bytesSent = send( sockfd_m, data + sent, size - sent, 0 );

		errNo = errno;
		if ( bytesSent < 0 ) {
			if ( errNo == EINTR )
				continue;
			else {
				close( sockfd_m );
				throw SocketSenderException( "send()", strerror( errNo ), port_m, sockfd_m );
			}
		}

		sent += bytesSent;
	}
	Log.ger<>( DEBUG_NETWORK, "New document has been sent on the port", port_m );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
testq %rdx, %rdx
je 0x137cf
movq %rdx, %rbx
xorl %r15d, %r15d
movq %rdx, %r12
movq 0x10(%rsp), %rax
leaq (%rax,%r15), %r13
movl (%r14), %edi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x5210
testq %rax, %rax
jns 0x137c4
callq 0x5060
movl (%rax), %ebp
cmpl $0x4, %ebp
je 0x137a1
jmp 0x137fc
addq %rax, %r15
movq %rbx, %r12
subq %r15, %r12
ja 0x13798
addq $0x4, %r14
leaq 0xedee(%rip), %rdi      # 0x225c8
leaq 0x5319(%rip), %rdx      # 0x18afa
movl $0x5, %esi
movq %r14, %rcx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13ae6
movl (%r14), %edi
callq 0x57c0
movl $0x50, %edi
callq 0x5200
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x52d2(%rip), %rsi      # 0x18af3
leaq 0x52d1(%rip), %rdx      # 0x18af9
leaq 0x18(%rsp), %rdi
callq 0x8f0e
movl %ebp, %edi
callq 0x51b0
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x7bea
movl (%r14), %r8d
movl 0x4(%r14), %ecx
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x13480
leaq 0xe202(%rip), %rax      # 0x21a70
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe19e(%rip), %rsi      # 0x21a18
leaq -0xbc7(%rip), %rdx      # 0x12cba
movq %rbx, %rdi
callq 0x5700
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x138af
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x138af
movq %rax, %r14
movb $0x1, %bpl
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x138ce
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x138ce
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x138db
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/requests/CRequestParser.cpp
// Function: CRequestParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CRequestParser::parse( const string& body ) {
	unsigned int pos = 0;
	type_m = methodTypeNS::methodFromString( getNextToken( body, pos ) );
	if ( type_m == RT_UNSUPPORTED )
		throw RequestParserException( lastToken_m.c_str(), "Request type" );
	resource_m = getNextToken( body, pos );
	if ( resource_m.empty() )
		throw RequestParserException( lastToken_m.c_str(), "Resource" );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x20, %r8d
callq 0x14f50
movq %r15, %rdi
callq 0x151bb
movl %eax, (%rbx)
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x14d9e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
cmpl $0x3, (%rbx)
je 0x14df6
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x20, %r8d
callq 0x14f50
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x54a0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x14de2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
cmpq $0x0, 0x10(%rbx)
je 0x14e66
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x7bea
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3df9(%rip), %rsi      # 0x18c1f
leaq 0x3dfe(%rip), %rdx      # 0x18c2b
leaq 0x30(%rsp), %rdi
callq 0x8f0e
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x1500a
xorl %ebp, %ebp
leaq 0xcc93(%rip), %rsi      # 0x21ae8
leaq 0x22e(%rip), %rdx       # 0x1508a
movq %r14, %rdi
callq 0x5700
jmp 0x14ed4
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x7bea
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3d96(%rip), %rsi      # 0x18c2c
leaq 0x3d97(%rip), %rdx      # 0x18c34
leaq 0x30(%rsp), %rdi
callq 0x8f0e
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x1500a
xorl %ebp, %ebp
leaq 0xcc23(%rip), %rsi      # 0x21ae8
leaq 0x1be(%rip), %rdx       # 0x1508a
movq %r14, %rdi
callq 0x5700
jmp 0x14ed8
jmp 0x14ef4
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x14efa
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x14efa
movq %rax, %rbx
movb $0x1, %bpl
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x14f1b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x14f1b
jmp 0x14f15
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x14f48
movq %r14, %rdi
callq 0x52e0
jmp 0x14f48
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14f48
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/requests/CRequestParser.cpp
// Function: CRequestParser::getNextToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int&, char)
string CRequestParser::getNextToken( const string& str, unsigned int& pos, char delim ) {
	lastToken_m.clear();

	while ( pos < str.size() && str[pos] == delim )
		pos++;

	while ( pos < str.size() ) {
		if ( str[pos] == delim )
			return lastToken_m;

		lastToken_m += str[pos++];
	}

	return lastToken_m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x30(%rsi)
movq 0x28(%rsi), %rax
movb $0x0, (%rax)
movq 0x8(%rdx), %rax
movl (%rcx), %ecx
cmpq %rcx, %rax
jbe 0x14f9d
movq (%r12), %rdx
leal 0x1(%rcx), %esi
cmpb %bpl, (%rdx,%rcx)
jne 0x14f9d
movl %esi, (%r15)
movl %esi, %ecx
incl %esi
cmpq %rcx, %rax
ja 0x14f8b
movl (%r15), %eax
cmpq %rax, 0x8(%r12)
jbe 0x14fd4
leaq 0x28(%r14), %r13
movl %eax, %ecx
movq (%r12), %rdx
cmpb %bpl, (%rdx,%rax)
je 0x14fd4
incl %ecx
movl %ecx, (%r15)
movsbl (%rdx,%rax), %esi
movq %r13, %rdi
callq 0x5340
movl (%r15), %eax
movl %eax, %ecx
cmpq %rax, 0x8(%r12)
ja 0x14fad
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x8e7e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/requests/EMethodType.cpp
// Function: methodTypeNS::methodFromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
EMethodType methodTypeNS::methodFromString( const std::string& str ) {
	for ( int i = 0; i < RT_MAXENUM; i++ ) {
		if ( str == methodToString( (EMethodType) i ) )
			return (EMethodType) i;
	}
	return RT_UNSUPPORTED;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0xc971(%rip), %r15      # 0x21b40
leaq 0x3a98(%rip), %r12      # 0x18c6e
movq %r12, %rsi
cmpl $0x4, %ebx
ja 0x151e1
movq (%r15), %rsi
movq %r14, %rdi
callq 0x5150
testl %eax, %eax
je 0x151fd
incl %ebx
addq $0x8, %r15
cmpl $0x5, %ebx
jne 0x151d6
movl $0x3, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/requests/response_generators/CAbstractGenerator.cpp
// Function: CAbstractGenerator::getCodeMsg(int)
const char * CAbstractGenerator::getCodeMsg( int code ) {
	switch ( code ) {
		case 200:
			return "OK";
		case 400:
			return "Bad Request";
		case 403:
			return "Forbidden";
		case 404:
			return "Not Found";
		case 405:
			return "Method Not Allowed";
		case 409:
			return "Conflict";
		case 501:
			return "Not Implemented";
		case 503:
			return "Service Unavailable";
		default:
			return "Other Code";
	}
}

// Assembly:
cmpl $0x1f4, %esi            # imm = 0x1F4
jg 0x15237
leal -0x190(%rsi), %eax
cmpl $0x9, %eax
ja 0x1524f
leaq 0x3a56(%rip), %rcx      # 0x18c7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3a96(%rip), %rax      # 0x18ccc
retq
cmpl $0x1f5, %esi            # imm = 0x1F5
je 0x15287
cmpl $0x1f7, %esi            # imm = 0x1F7
jne 0x1525f
leaq 0x3aca(%rip), %rax      # 0x18d18
retq
cmpl $0xc8, %esi
jne 0x1525f
leaq 0x3a6b(%rip), %rax      # 0x18cc9
retq
leaq 0x3ac6(%rip), %rax      # 0x18d2c
retq
leaq 0x3a7e(%rip), %rax      # 0x18cec
retq
leaq 0x3a6c(%rip), %rax      # 0x18ce2
retq
leaq 0x3a5a(%rip), %rax      # 0x18cd8
retq
leaq 0x3a79(%rip), %rax      # 0x18cff
retq
leaq 0x3a7a(%rip), %rax      # 0x18d08
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/signals/signals.cpp
// Function: signalNS::initSignalMask(__sigset_t&)
void signalNS::initSignalMask( sigset_t& sig ) {
	sigemptyset( &sig );
	sigaddset( &sig, SIGHUP );
	sigaddset( &sig, SIGINT );
	sigaddset( &sig, SIGTERM );
	sigaddset( &sig, SIGPIPE );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x54c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5630
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5630
movq %rbx, %rdi
movl $0xf, %esi
callq 0x5630
movq %rbx, %rdi
movl $0xd, %esi
popq %rbx
jmp 0x5630
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/signals/signals.cpp
// Function: signalNS::sigWait()
int signalNS::sigWait() {
	int signal = -1;
	sigset_t signalMask;
	initSignalMask( signalMask );
	sigaddset( &signalMask, SIGUSR1 );

	sigwait( &signalMask, &signal );
	return signal;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
leaq 0x4(%rsp), %rbx
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x163d4
movq %r14, %rdi
movl $0xa, %esi
callq 0x5630
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5180
movl (%rbx), %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/signals/signals.cpp
// Function: signalNS::setEmptyHandler(int)
void ::signalNS::setEmptyHandler( int sigNum ) {
	struct sigaction sa;
	memset( (void *) &sa, 0, sizeof( sa ) );

	sa.sa_handler = emptyHandler;

	sigaction( sigNum, &sa, nullptr );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %edi, %ebx
movq %rsp, %r14
movl $0x98, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x5260
leaq -0x26(%rip), %rax       # 0x16481
movq %rax, (%r14)
movl %ebx, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x54d0
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/threads/CPortThread.cpp
// Function: CPortThread::run()
void CPortThread::run() {
	Log.ger<>( THREADS, "Listener thread", id_m, "successfully started" );
	int processedCount = 0;

	while ( 1 ) {
		try {
			if ( !queue_m->push( new CRequest( socket_m.acceptConnection(), socket_m.port() ) ) )
				break;
			processedCount++;
		}
		catch ( NetworkException& e ) {
			break;
		}
	}

	queue_m->notifyProducerStopped();

	Log.ger<>( INFO, "Port_number:requests_processed\t", port_m, CLogger::NoSpace(), ":", CLogger::NoSpace(),
			   processedCount );
	Log.ger<>( THREADS, "Listener thread", id_m, "shuts down" );

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rcx
leaq 0xc0ad(%rip), %rdi      # 0x225c8
leaq 0x28c2(%rip), %rdx      # 0x18de4
leaq 0x291d(%rip), %r8       # 0x18e46
movl $0x9, %esi
movq %rcx, 0x10(%rsp)
callq 0x16656
leaq 0x10(%r14), %r12
xorl %eax, %eax
movl %eax, 0x4(%rsp)
movq 0x28(%r14), %rbx
movl $0xa0, %edi
callq 0x53e0
movq %rax, %rbp
movb $0x1, %r13b
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x12760
movl 0x18(%rsp), %r15d
movq %r12, %rdi
callq 0x12cb6
movq %rbp, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x13cec
movq %rbp, 0x8(%rsp)
xorl %r13d, %r13d
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x167ce
testb %al, %al
je 0x165d5
movl 0x4(%rsp), %eax
incl %eax
jmp 0x1653e
movq %rdx, %r12
movq %rax, %rbx
jmp 0x165be
movq %rdx, %r12
movq %rax, %rbx
testb %r13b, %r13b
je 0x165be
movl $0xa0, %esi
movq %rbp, %rdi
callq 0x53f0
cmpl $0x1, %r12d
jne 0x1664e
movq %rbx, %rdi
callq 0x51e0
callq 0x56b0
movq 0x28(%r14), %rdi
callq 0x1185e
addq $0x20, %r14
leaq 0x4(%rsp), %rax
leaq 0xbfda(%rip), %rbx      # 0x225c8
leaq 0x27ff(%rip), %rdx      # 0x18df4
leaq 0x2132(%rip), %r9       # 0x1872e
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rcx
pushq %rax
leaq 0x10(%rsp), %rax
pushq %rax
callq 0x16868
addq $0x10, %rsp
leaq 0x27c1(%rip), %rdx      # 0x18de4
leaq 0x27ea(%rip), %r8       # 0x18e14
movq %rbx, %rdi
movl $0x9, %esi
movq 0x10(%rsp), %rcx
callq 0x1699a
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/threads/CThreadSafeQueue.h
// Function: CThreadSafeQueue<CRequest*, (CRequest*)0, 100u>::push(CRequest* const&)
bool CThreadSafeQueue<T, defVal, TArraySize>::push( T const& e ) {
	semFull_m.wait();
	mutex_m.lock();
	if ( isDisabled_m ) {
		semFull_m.post();
		mutex_m.unlock();
		return false;
	}
	else {
		array_m[writeIndex_m] = e;
		writeIndex_m = ( writeIndex_m + 1 ) % TArraySize;
		mutex_m.unlock();
		semEmpty_m.post();
		return true;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x370(%rdi), %r13
movq %r13, %rdi
callq 0x17b8c
leaq 0x328(%r14), %r15
movq %r15, %rdi
callq 0x17b62
movb 0x398(%r14), %bl
cmpb $0x1, %bl
jne 0x16819
movq %r13, %rdi
callq 0x17b92
movq %r15, %rdi
callq 0x17b76
jmp 0x16859
movq (%r12), %rax
movl 0x320(%r14), %ecx
movq %rax, (%r14,%rcx,8)
leal 0x1(%rcx), %eax
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
shrq $0x25, %rcx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x320(%r14)
movq %r15, %rdi
callq 0x17b76
addq $0x350, %r14            # imm = 0x350
movq %r14, %rdi
callq 0x17b92
xorb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/threads/CSignalThread.cpp
// Function: CSignalThread::run()
void CSignalThread::run() {
	Log.ger<>( THREADS, "Signal thread successfully started" );
	int sig = signalNS::sigWait();
	Log.ger<>( CRITICAL, "Signal", sig, "caught. Request queue is disabled." );
	queue_m->disable();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb976(%rip), %r14      # 0x225c8
leaq 0x21df(%rip), %rdx      # 0x18e38
movq %r14, %rdi
movl $0x9, %esi
callq 0x16cbc
callq 0x1643a
leaq 0x4(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x21e2(%rip), %rdx      # 0x18e5b
leaq 0x21e2(%rip), %r8       # 0x18e62
movq %r14, %rdi
movl $0x1, %esi
callq 0x16dc8
movq 0x8(%rbx), %rbx
movb $0x1, 0x398(%rbx)
leaq 0x350(%rbx), %rdi
callq 0x17b92
addq $0x370, %rbx            # imm = 0x370
movq %rbx, %rdi
callq 0x17b92
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/threads/CThreadPool.cpp
// Function: CThreadPool::timedJoinThread(unsigned long, unsigned long)
bool CThreadPool::timedJoinThread( pthread_t thread, uint64_t msec ) {
	struct timespec ts;
	ts.tv_sec = (int) ( msec / 1000 );
	ts.tv_nsec = ( msec % 1000 ) * 1000000;
	return pthread_timedjoin_np( thread, NULL, &ts ) == 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rdi
movq %rdx, %rax
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
mulq %rdx
shrq $0x4, %rdx
movslq %edx, %rsi
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
imulq $0x3e8, %rdx, %rdx      # imm = 0x3E8
subq %rdx, %rcx
imulq $0xf4240, %rcx, %rcx    # imm = 0xF4240
movq %rcx, 0x8(%rax)
xorl %esi, %esi
movq %rax, %rdx
callq 0x52c0
testl %eax, %eax
sete %al
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/threads/CWorkerThread.cpp
// Function: CWorkerThread::run()
void CWorkerThread::run() {
	int processedCount = 0;
	Log.ger<>( THREADS, "Worker thread", id_m, "successfully started" );
	while ( 1 ) {
		try {
			unique_ptr<CRequest> current( queue_m->pop() );
			if ( !current )
				break;

			Log.ger<>( THREADS, "Worker thread", id_m, "has new job" );
			current->receive();
			current->parse();
			current->generate();
			current->sendBack();

			processedCount++;
		}
		catch ( EmptyDataException& e ) {
			Log.ger( DEBUG_NETWORK, e );
		}
		catch ( NetworkException& e ) {
			Log.ger( NETWORK, e );
		}
		catch ( bad_alloc& e ) { }
	}

	Log.ger<>( INFO, "Thread_id:requests_processed\t", id_m, CLogger::NoSpace(), ":", CLogger::NoSpace(),
			   processedCount );
	Log.ger<>( THREADS, "Worker thread", id_m, "shuts down" );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x0, 0x24(%rsp)
leaq 0x8(%rdi), %rbx
leaq 0xb4e2(%rip), %rdi      # 0x225c8
leaq 0x1da8(%rip), %r12      # 0x18e95
leaq 0x1d52(%rip), %r8       # 0x18e46
movl $0x9, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x172a0
leaq 0x1d98(%rip), %r13      # 0x18ea3
leaq 0x18(%rsp), %rbp
movq 0x18(%r14), %rdi
callq 0x17418
movq %rax, %r15
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x17206
leaq 0xb497(%rip), %rdi      # 0x225c8
movl $0x9, %esi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x174b0
movq 0x18(%rsp), %rdi
callq 0x142f6
movq 0x18(%rsp), %rdi
callq 0x13df8
movq 0x18(%rsp), %rdi
callq 0x14240
movq 0x18(%rsp), %rdi
callq 0x14290
incl 0x24(%rsp)
movq %rbp, %rdi
callq 0x17628
testq %r15, %r15
jne 0x17110
jmp 0x17210
movq %rdx, %r15
movq %rax, 0x8(%rsp)
jmp 0x1719c
movq %rdx, %r15
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x17628
cmpl $0x3, %r15d
jne 0x171c2
movq 0x8(%rsp), %rdi
callq 0x51e0
leaq 0xb415(%rip), %rdi      # 0x225c8
movl $0x5, %esi
movq %rax, %rdx
callq 0x1775c
jmp 0x171fc
cmpl $0x2, %r15d
jne 0x171e8
movq 0x8(%rsp), %rdi
callq 0x51e0
leaq 0xb3ef(%rip), %rdi      # 0x225c8
movl $0x4, %esi
movq %rax, %rdx
callq 0x1765c
jmp 0x171fc
cmpl $0x1, %r15d
jne 0x1728e
movq 0x8(%rsp), %rdi
callq 0x51e0
callq 0x56b0
jmp 0x17110
leaq 0x18(%rsp), %rdi
callq 0x17628
leaq 0x24(%rsp), %rax
leaq 0x16(%rsp), %r10
leaq 0xb3a7(%rip), %r14      # 0x225c8
leaq 0x1c87(%rip), %rdx      # 0x18eaf
leaq 0x14ff(%rip), %r9       # 0x1872e
leaq 0x17(%rsp), %r8
movq %r14, %rdi
movl $0x2, %esi
movq %rbx, %rcx
pushq %rax
pushq %r10
callq 0x1785c
addq $0x10, %rsp
leaq 0x1c43(%rip), %rdx      # 0x18e95
leaq 0x1bbb(%rip), %r8       # 0x18e14
movq %r14, %rdi
movl $0x9, %esi
movq %rbx, %rcx
callq 0x179d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
callq 0x56b0
jmp 0x1728e
movq %rax, 0x8(%rsp)
callq 0x56b0
movq 0x8(%rsp), %rdi
callq 0x5730
movq %rax, %rdi
callq 0x7db2
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/threads/CThreadSafeQueue.h
// Function: CThreadSafeQueue<CRequest*, (CRequest*)0, 100u>::pop()
T CThreadSafeQueue<T, defVal, TArraySize>::pop() {
	semEmpty_m.wait();
	mutex_m.lock();
	if ( !isDisabled_m || readIndex_m != writeIndex_m ) {
		T e = array_m[readIndex_m];
		readIndex_m = ( readIndex_m + 1 ) % TArraySize;
		mutex_m.unlock();
		semFull_m.post();
		return e;
	}
	else {
		mutex_m.unlock();
		semEmpty_m.post();
		return defVal;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x350(%rdi), %r14
movq %r14, %rdi
callq 0x17b8c
leaq 0x328(%rbx), %r15
movq %r15, %rdi
callq 0x17b62
cmpb $0x1, 0x398(%rbx)
jne 0x17465
movl 0x324(%rbx), %eax
cmpl 0x320(%rbx), %eax
jne 0x17465
movq %r15, %rdi
callq 0x17b76
xorl %r12d, %r12d
jmp 0x17499
movl 0x324(%rbx), %eax
movq (%rbx,%rax,8), %r12
incl %eax
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
shrq $0x25, %rcx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x324(%rbx)
movq %r15, %rdi
callq 0x17b76
addq $0x370, %rbx            # imm = 0x370
movq %rbx, %r14
movq %r14, %rdi
callq 0x17b92
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/dtran.cc
// Function: strprintf[abi:cxx11](char const*, ...)
std::string strprintf(const char * fmt, ...) {
    std::string ret;
    char * str;
    va_list ap;
    va_start (ap, fmt);
    if (vasprintf(&str, fmt, ap) < 0) {
        fprintf(stderr, "Out of memory\n");
        exit(1);
    }
    va_end(ap);
    ret = str;
    free(str);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x25b0
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x10(%rsp), %rdx
movq %rdi, 0x10(%rdx)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
callq 0x2110
testl %eax, %eax
js 0x2633
movq 0x8(%rsp), %r14
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x2090
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x21f0
movq 0x8(%rsp), %rdi
callq 0x2170
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2270
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x264f
movq (%r12), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/dtran.cc
// Function: Dtran::Dtran(char const*, unsigned int, bool, bool, bool)
Dtran(const char * fname, uint b, bool n, bool e, bool o) :
        basereg(b), baseaddr(~0u), nolabels(n), noequs(e), nooctal(o) {

    unsigned int addr = 0;
    struct stat st;

    FILE * textfd = fopen (fname, "r");
    if (! textfd) {
        fprintf (stderr, "dtran: %s not found\n", fname);
        exit(1);
    }
    stat (fname, &st);
    uint codelen = st.st_size / 6;

    if (codelen >= 32768) {
        fprintf(stderr, "File too large\n");
        exit(1);
    }
    while (!feof(textfd) && addr < 0100000) {
        memory[addr++] = freadw (textfd);
    }

    fill_lengths();
    if (codelen < comment_off) {
        fprintf(stderr, "File was too short: %d, expected %d\n", codelen, comment_off);
        exit (EXIT_FAILURE);
    }
    symtab.resize(head_len + sym_len);
    labels.resize(cmd_len + const_len + bss_len + data_len);
    fclose (textfd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, 0x34(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movb %cl, 0x40(%rdi)
movb %r8b, 0x41(%rdi)
movb %r9b, 0x42(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40048(%rdi)
movups %xmm0, 0x40058(%rdi)
movups %xmm0, 0x40068(%rdi)
leaq 0x2983(%rip), %rsi      # 0x52c8
movq %r15, %rdi
callq 0x2160
testq %rax, %rax
je 0x2a37
movq %rax, %r14
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
movabsq $0x2aaaaaaaaaaaaaab, %rax # imm = 0x2AAAAAAAAAAAAAAB
imulq 0x30(%r12)
movq %rdx, %r15
shrq $0x3f, %r15
addl %edx, %r15d
cmpl $0x7fff, %r15d          # imm = 0x7FFF
ja 0x2a3f
movq %r14, %rdi
callq 0x2200
testl %eax, %eax
jne 0x29df
xorl %r12d, %r12d
movl $0x6, %ebp
xorl %eax, %eax
movq %rax, %r13
shlq $0x8, %r13
movq %r14, %rdi
callq 0x2050
cltq
orq %r13, %rax
decl %ebp
jne 0x29a5
movq %rax, 0x48(%rbx,%r12,8)
movq %r14, %rdi
callq 0x2200
testl %eax, %eax
jne 0x29df
leaq 0x1(%r12), %rax
cmpq $0x7fff, %r12           # imm = 0x7FFF
movq %rax, %r12
jb 0x299e
leaq 0x40048(%rbx), %r12
leaq 0x40060(%rbx), %r13
movq %rbx, %rdi
callq 0x3406
movl 0x30(%rbx), %esi
cmpl %r15d, %esi
ja 0x2a44
movl 0x4(%rbx), %esi
addl (%rbx), %esi
movq %r12, %rdi
callq 0x35c0
movl 0x20(%rbx), %esi
addl 0x18(%rbx), %esi
addl 0x1c(%rbx), %esi
addl 0xc(%rbx), %esi
movq %r13, %rdi
callq 0x35c0
movq %r14, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
movq %r15, %rdi
callq 0x2349
callq 0x2324
movl %r15d, %edi
callq 0x22ff
movq %rax, %rbx
movq %r13, %rdi
callq 0x35f0
movq %r12, %rdi
callq 0x35f0
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/dtran.cc
// Function: Dtran::prtext(bool)
void
prtext (bool litconst)
{
    uint32 addr = 0;
    uint32 limit = cmd_len;
    for (uint32 cur = addr; cur < limit; ++cur) {
        uint64 & opcode = memory[cur+3];
        mklabels(cur, opcode >> 24, litconst);
        mklabels(cur, opcode & 0xffffff, litconst);
    }
    if (nolabels) {
        puts(" /:,BSS,");
    }
    for (; addr < limit; ++addr) {
        uint64 opcode;
        if (!labels[addr].empty()) {
            if (nolabels) {
                printf(" :");
            } else {
                printf(" %s:", labels[addr].c_str());
            }
        } else
            putchar(' ');
        opcode = memory[addr+3];
        prinsn (addr, opcode >> 24);
        // Do not print the non-insn part of a word
        // if it looks like a placeholder
        opcode &= 0xffffff;
        if (opcode == 02200000) {
            opcode = memory[addr+3] >> 24;
            opcode &= 03700000;
            if (opcode != 03100000 &&
                labels[addr+1].empty()) {
                labels[addr+1] = " ";
            }
        } else {
            putchar(' ');
            prinsn (addr, opcode);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r15d
testq %r15, %r15
je 0x2aff
xorl %r14d, %r14d
movzbl %sil, %ebp
movl $0xffffff, %r12d        # imm = 0xFFFFFF
leal 0x3(%r14), %r13d
movl 0x4b(%rbx,%r13,8), %edx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x3e40
movl 0x48(%rbx,%r13,8), %edx
andl %r12d, %edx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x3e40
incq %r14
cmpq %r14, %r15
jne 0x2acc
cmpb $0x0, 0x40(%rbx)
je 0x2b11
leaq 0x2c58(%rip), %rdi      # 0x5764
callq 0x21e0
testq %r15, %r15
je 0x2c03
movl $0x20, %r14d
xorl %r13d, %r13d
movq 0x40060(%rbx), %rax
cmpq $0x0, -0x18(%rax,%r14)
je 0x2b48
cmpb $0x1, 0x40(%rbx)
jne 0x2b54
leaq 0x29e9(%rip), %rdi      # 0x5528
xorl %eax, %eax
callq 0x2030
jmp 0x2b67
movl $0x20, %edi
callq 0x21b0
jmp 0x2b67
movq -0x20(%rax,%r14), %rsi
leaq 0x29cb(%rip), %rdi      # 0x552b
xorl %eax, %eax
callq 0x2030
leal 0x3(%r13), %r12d
movq 0x48(%rbx,%r12,8), %rbp
movq %rbp, %rdx
shrq $0x18, %rdx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x409c
andl $0xffffff, %ebp         # imm = 0xFFFFFF
cmpq $0x90000, %rbp          # imm = 0x90000
jne 0x2bdc
movq 0x48(%rbx,%r12,8), %rax
movabsq $0xf8000000000, %rcx    # imm = 0xF8000000000
andq %rcx, %rax
movabsq $0xc8000000000, %rcx    # imm = 0xC8000000000
cmpq %rcx, %rax
je 0x2bf3
movq 0x40060(%rbx), %rdi
movq 0x8(%rdi,%r14), %rdx
testq %rdx, %rdx
jne 0x2bf3
addq %r14, %rdi
movl $0x1, %r8d
xorl %esi, %esi
leaq 0x2b4a(%rip), %rcx      # 0x571f
callq 0x21f0
jmp 0x2bf3
movl $0x20, %edi
callq 0x21b0
movq %rbx, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x409c
incq %r13
addq $0x20, %r14
cmpq %r13, %r15
jne 0x2b23
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq