LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andl $0x0, (%rdi)
leaq 0x88(%rdi), %rdx
movl $0x80, 0x88(%rdi)
movl 0x8(%rsi), %edi
leaq 0x8(%rbx), %rsi
callq 0x5190
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0xf423
addq $0xc, %r14
leaq 0x121ee(%rip), %rdi     # 0x215f0
leaq 0x5624(%rip), %rcx      # 0x14a2d
pushq $0x5
popq %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0xf91c
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x5230
movq %rax, %rbx
leaq 0x55ef(%rip), %rsi      # 0x14a24
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x712a
callq 0x5060
movl (%rax), %edi
callq 0x51c0
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
movq %rax, %rsi
callq 0x712a
movl 0x8(%r14), %r8d
movl 0xc(%r14), %ecx
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xf906
xorl %ebp, %ebp
leaq 0x11430(%rip), %rsi     # 0x208b8
leaq 0x39f(%rip), %rdx       # 0xf82e
movq %rbx, %rdi
callq 0x5740
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5210
jmp 0xf4ac
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0xf4c0
jmp 0xf4c8
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x80, %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)
pushq $0x1
popq %rax
movl %eax, 0x8(%rdx)
movl %eax, (%rdx)
xorl %edi, %edi
movq %rbx, %rcx
callq 0x5510
testl %eax, %eax
jne 0xf516
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %ebp
andq $0x0, (%rbx)
pushq $0x50
popq %rdi
callq 0x5230
movq %rax, %rbx
leaq 0x5522(%rip), %rsi      # 0x14a50
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x712a
movl %ebp, %edi
callq 0x55e0
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
movq %rax, %rsi
callq 0x712a
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
pushq $-0x2
popq %r8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xf818
xorl %ebp, %ebp
leaq 0x1133d(%rip), %rsi     # 0x208b8
leaq 0x2ac(%rip), %rdx       # 0xf82e
movq %rbx, %rdi
callq 0x5740
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5210
jmp 0xf59f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0xf5b3
jmp 0xf5bb
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x2, 0x4c(%rdi)
movq (%rdi), %rax
movq 0x18(%rax), %rax
jne 0xfc3b
movq %rbx, %rdi
callq *%rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x5400
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5480
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5390
leaq 0x4ed6(%rip), %rsi      # 0x14adf
movq %rax, %rdi
callq 0x5400
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0x5750
pushq $0x28
popq %rsi
movq %rax, %rdi
callq 0x5480
movl 0x4c(%rbx), %esi
movq %rax, %rdi
callq 0x5750
leaq 0x477d(%rip), %rsi      # 0x143b6
jmp 0xfc83
movq %rbx, %rdi
callq *%rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x5400
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5480
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5390
leaq 0x4e76(%rip), %rsi      # 0x14adf
movq %rax, %rdi
callq 0x5400
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0x5750
leaq 0x4734(%rip), %rsi      # 0x143b7
movq %rax, %rdi
callq 0x5400
addq $0x28, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5390
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x7285
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
xorl %r15d, %r15d
movq %rbx, %r12
subq %r15, %r12
jbe 0xffb1
movq 0x10(%rsp), %rax
leaq (%rax,%r15), %r13
movl (%r14), %edi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
jns 0xffac
callq 0x5060
movl (%rax), %ebp
cmpl $0x4, %ebp
je 0xff89
jmp 0xffdc
addq %rax, %r15
jmp 0xff78
addq $0x4, %r14
leaq 0x11634(%rip), %rdi     # 0x215f0
leaq 0x4b47(%rip), %rdx      # 0x14b0a
pushq $0x5
popq %rsi
movq %r14, %rcx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1025c
movl (%r14), %edi
callq 0x5810
pushq $0x50
popq %rdi
callq 0x5230
movq %rax, %rbx
leaq 0x4b0d(%rip), %rsi      # 0x14b03
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x712a
movl %ebp, %edi
callq 0x51c0
leaq 0x18(%rsp), %rdi
leaq 0xe(%rsp), %rdx
movq %rax, %rsi
callq 0x712a
movl (%r14), %r8d
movl 0x4(%r14), %ecx
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x10246
xorl %ebp, %ebp
leaq 0x10a05(%rip), %rsi     # 0x20a48
leaq -0x81c(%rip), %rdx      # 0xf82e
movq %rbx, %rdi
callq 0x5740
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x5210
jmp 0x10067
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0x1007b
jmp 0x10083
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/network/CSocketIO.cpp
// Function: CSocketIO::recvData[abi:cxx11]() const
string CSocketIO::recvData() const {
	char buf[1024];
	ssize_t bytesRecvd;
	int errNo;
	string data;

	while ( 1 ) {
		bytesRecvd = recv( sockfd_m, buf, sizeof( buf ), 0 );

		errNo = errno;
		if ( bytesRecvd == 0 )
			break;
		else if ( bytesRecvd < 0 ) {
			if ( errNo == EINTR )
				continue;
			else
				throw SocketReceiverException( "recv()", strerror( errNo ), port_m, sockfd_m );
		}

		data.insert( data.end(), buf, buf + bytesRecvd );

		if ( data.size() >= 4 &&
			 data[data.size() - 4] == 13 &&
			 data[data.size() - 3] == 10 &&
			 data[data.size() - 2] == 13 &&
			 data[data.size() - 1] == 10 )
			break;

		/** An RFC2616 recommendation since someone may want to break the standard.*/
		if ( data.size() >= 2 &&
			 data[data.size() - 2] == 10 &&
			 data[data.size() - 1] == 10 )
			break;


	}

	if ( data.size() == 0 )
		throw EmptyDataException();

	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x450, %rsp            # imm = 0x450
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
leaq 0x50(%rsp), %r15
movl (%r14), %edi
movl $0x400, %edx            # imm = 0x400
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x51b0
movq %rax, %r12
callq 0x5060
testq %r12, %r12
je 0x10142
js 0x1011c
movq (%rbx), %rsi
addq 0x8(%rbx), %rsi
leaq (%rsp,%r12), %rcx
addq $0x50, %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1031a
movq 0x8(%rbx), %rax
cmpq $0x4, %rax
jb 0x10125
movq (%rbx), %rcx
cmpb $0xd, -0x4(%rcx,%rax)
jne 0x1012e
cmpb $0xa, -0x3(%rcx,%rax)
jne 0x1012e
cmpb $0xd, -0x2(%rcx,%rax)
jne 0x1012e
cmpb $0xa, -0x1(%rcx,%rax)
jne 0x1012e
jmp 0x1014d
movl (%rax), %ebp
cmpl $0x4, %ebp
je 0x100b6
jmp 0x10160
cmpq $0x2, %rax
jb 0x100b6
movq (%rbx), %rcx
cmpb $0xa, -0x2(%rcx,%rax)
jne 0x100b6
cmpb $0xa, -0x1(%rcx,%rax)
jne 0x100b6
jmp 0x1014d
cmpq $0x0, 0x8(%rbx)
je 0x101d0
movq %rbx, %rax
addq $0x450, %rsp            # imm = 0x450
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x5230
movq %rax, %r15
leaq 0x49bf(%rip), %rsi      # 0x14b31
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x712a
movl %ebp, %edi
callq 0x51c0
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
movq %rax, %rsi
callq 0x712a
movl (%r14), %r8d
movl 0x4(%r14), %ecx
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x10304
xorl %ebp, %ebp
leaq 0x108a1(%rip), %rsi     # 0x20a60
leaq -0x998(%rip), %rdx      # 0xf82e
movq %r15, %rdi
callq 0x5740
jmp 0x101f8
pushq $0x8
popq %rdi
callq 0x5230
leaq 0x10921(%rip), %rcx     # 0x20b00
movq %rcx, (%rax)
leaq 0x1088f(%rip), %rsi     # 0x20a78
leaq 0x154(%rip), %rdx       # 0x10344
movq %rax, %rdi
callq 0x5740
jmp 0x1022f
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5210
jmp 0x1020f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0x10223
jmp 0x10232
movq %rax, %r14
movq %r15, %rdi
callq 0x5300
jmp 0x10232
jmp 0x1022f
movq %rax, %r14
movq %rbx, %rdi
callq 0x5210
movq %r14, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %rcx
andl $0x0, (%rcx)
leaq 0x8(%rsp), %r15
pushq $0x20
popq %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x111de
movq %r15, %rdi
callq 0x11366
movl %eax, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x5210
cmpl $0x3, (%r14)
je 0x110cc
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %rcx
pushq $0x20
popq %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x111de
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x54d0
movq %r15, %rdi
callq 0x5210
cmpq $0x0, 0x10(%r14)
je 0x1112f
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %rbx
movq 0x28(%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x712a
leaq 0x3b3e(%rip), %rsi      # 0x14c2f
leaq 0x28(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x712a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1126a
xorl %ebp, %ebp
leaq 0xf9fa(%rip), %rsi      # 0x20b18
leaq 0x18f(%rip), %rdx       # 0x112b4
movq %rbx, %rdi
callq 0x5740
jmp 0x11190
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %rbx
movq 0x28(%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x712a
leaq 0x3ae8(%rip), %rsi      # 0x14c3c
leaq 0x28(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x712a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1126a
xorl %ebp, %ebp
leaq 0xf997(%rip), %rsi      # 0x20b18
leaq 0x12c(%rip), %rdx       # 0x112b4
movq %rbx, %rdi
callq 0x5740
jmp 0x11194
jmp 0x111a3
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5210
jmp 0x111a9
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0x111bf
jmp 0x111d6
jmp 0x111bc
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
jmp 0x111d6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %r14, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x28(%rsi), %r12
andq $0x0, 0x30(%rsi)
movq 0x28(%rsi), %rax
movb $0x0, (%rax)
movq (%rdx), %rdx
movq 0x8(%r15), %rax
movl (%rcx), %ecx
movl %ecx, %esi
cmpq %rsi, %rax
jbe 0x11241
cmpb %bpl, (%rdx,%rsi)
jne 0x11241
incl %ecx
movl %ecx, (%r14)
jmp 0x1120b
movq (%r15), %rax
cmpb %bpl, (%rax,%rcx)
je 0x11248
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movsbl (%rax,%rcx), %esi
movq %r12, %rdi
callq 0x5360
movl (%r14), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
ja 0x1121f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x55d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebp, %ebp
pushq $0x3
popq %rbx
cmpl $0x5, %ebp
je 0x11393
movl %ebp, %edi
callq 0x11348
movq %r14, %rdi
movq %rax, %rsi
callq 0xaac9
testb %al, %al
jne 0x11391
incl %ebp
jmp 0x11372
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/requests/response_generators/CAbstractGenerator.cpp
// Function: CAbstractGenerator::CAbstractGenerator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, EMethodType)
CAbstractGenerator::CAbstractGenerator( const string& resource, EMethodType method ) {
	if ( !config.checkMethod( method ) )
		throw MethodProhibitedException( method );
	code_m = 0;
	content_m = nullptr;
	resource_m = resource;
	EFileType ft;
	realPath_m = pathResolver.resolve( resource_m, ft );
	switch ( ft ) {
		case FT_REGULAR:
			content_m = new CFileContent( resource_m, realPath_m );
			break;
		case FT_DIRECTORY:
			content_m = new CDirContent( resource_m, realPath_m );
			break;
		case FT_EXECUTABLE:
			content_m = new CExternalContent( resource_m, realPath_m, false );
			break;
		case FT_SCRIPT:
			content_m = new CExternalContent( resource_m, realPath_m, true );
			break;
	}

	content_m->load();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
leaq 0xf74d(%rip), %rax      # 0x20b80
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x10089(%rip), %rdi     # 0x214f0
movl %edx, %esi
callq 0x643a
testb %al, %al
je 0x11579
andl $0x0, 0x50(%r15)
andq $0x0, 0x48(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5270
leaq 0x1014e(%rip), %rsi     # 0x215e0
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rcx
movq %rbx, %rdx
callq 0xd760
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x54d0
movq %r12, %rdi
callq 0x5210
movl 0xc(%rsp), %eax
cmpq $0x3, %rax
ja 0x1155e
leaq 0x37f7(%rip), %rcx      # 0x14cc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xa8, %edi
callq 0x5410
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc720
jmp 0x11558
movl $0xd0, %edi
callq 0x5410
movq %rax, %r12
pushq $0x1
popq %r8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xc0bc
jmp 0x11558
movl $0xd0, %edi
callq 0x5410
movq %rax, %r12
pushq $0x1
popq %rcx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %ecx, %r8d
callq 0xc0bc
jmp 0x11558
movl $0xa8, %edi
callq 0x5410
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xa2b8
movq %r12, 0x48(%r15)
jmp 0x11562
movq 0x48(%r15), %r12
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5230
leaq 0xf630(%rip), %rcx      # 0x20bb8
movq %rcx, (%rax)
movl %ebp, 0x8(%rax)
leaq 0xf59b(%rip), %rsi      # 0x20b30
leaq -0x1258(%rip), %rdx     # 0x10344
movq %rax, %rdi
callq 0x5740
jmp 0x115a6
movq %rax, %r15
movl $0xa8, %esi
jmp 0x115ba
jmp 0x115b2
movq %rax, %r15
movl $0xd0, %esi
movq %r12, %rdi
callq 0x5420
jmp 0x115cb
jmp 0x115c8
jmp 0x115c8
movq %rax, %r15
movq %r14, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
movq %r15, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/requests/response_generators/CErrorGenerator.cpp
// Function: CErrorGenerator::generate[abi:cxx11]()
string CErrorGenerator::generate() {
	ostringstream response;

	response << "HTTP/1.1 " << code_m << ' ' << getCodeMsg( code_m ) << http_endl;
	response << "Date: " << content_m->getCreateTime() << http_endl;
	response << "Last-Modified: " << content_m->getModTime() << http_endl;
	response << "Content-Length: " << content_m->getSize() << http_endl;
	response << http_endl;
	for ( auto it : content_m->getData() )
		response.put( it );

	return response.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x5590
leaq 0x35ff(%rip), %rsi      # 0x14d75
movq %r15, %rdi
callq 0x5400
movl 0x50(%r14), %esi
movq %rax, %rdi
callq 0x5750
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %r15
movl 0x50(%r14), %esi
movq %r14, %rdi
callq 0x1139c
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
leaq 0xfcb2(%rip), %r12      # 0x21468
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
leaq 0x35b6(%rip), %rsi      # 0x14d7f
movq %rsp, %rdi
callq 0x5400
movq %rax, %r15
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
leaq 0x358a(%rip), %rsi      # 0x14d86
movq %rsp, %rdi
callq 0x5400
movq %rax, %r15
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
leaq 0x3567(%rip), %rsi      # 0x14d96
movq %rsp, %rdi
callq 0x5400
movq %rax, %r15
movq 0x48(%r14), %rdi
callq 0xa21a
movq %r15, %rdi
movq %rax, %rsi
callq 0x52a0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
movq (%r12), %rsi
movq %rsp, %rdi
callq 0x5400
movq 0x48(%r14), %rdi
callq 0xa22e
movq (%rax), %r15
movq 0x8(%rax), %r12
movq %rsp, %r14
cmpq %r12, %r15
je 0x1188f
movsbl (%r15), %esi
movq %r14, %rdi
callq 0x5040
incq %r15
jmp 0x11879
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56b0
movq %rsp, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x118ba
jmp 0x118ba
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5110
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/requests/response_generators/CHeadGenerator.cpp
// Function: CHeadGenerator::generate[abi:cxx11]()
string CHeadGenerator::generate() {
	ostringstream response;

	response << "HTTP/1.1 " << code_m << ' ' << getCodeMsg( code_m ) << http_endl;
	response << "Date: " << content_m->getCreateTime() << http_endl;
	response << "Last-Modified: " << content_m->getModTime() << http_endl;
	response << "Content-Length: " << content_m->getSize() << http_endl;
	response << http_endl;

	return response.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x5590
leaq 0x326f(%rip), %rsi      # 0x14d75
movq %r15, %rdi
callq 0x5400
movl 0x50(%r14), %esi
movq %rax, %rdi
callq 0x5750
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %r15
movl 0x50(%r14), %esi
movq %r14, %rdi
callq 0x1139c
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
leaq 0xf922(%rip), %r12      # 0x21468
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
leaq 0x3226(%rip), %rsi      # 0x14d7f
movq %rsp, %rdi
callq 0x5400
movq %rax, %r15
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
leaq 0x31fa(%rip), %rsi      # 0x14d86
movq %rsp, %rdi
callq 0x5400
movq %rax, %r15
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
leaq 0x31d7(%rip), %rsi      # 0x14d96
movq %rsp, %rdi
callq 0x5400
movq %rax, %r15
movq 0x48(%r14), %rdi
callq 0xa21a
movq %r15, %rdi
movq %rax, %rsi
callq 0x52a0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
movq (%r12), %rsi
movq %rsp, %rdi
callq 0x5400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56b0
movq %rsp, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5110
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/requests/response_generators/COptionsGenerator.cpp
// Function: COptionsGenerator::generate[abi:cxx11]()
string COptionsGenerator::generate() {
	ostringstream response;

	response << "HTTP/1.1 " << code_m << ' ' << getCodeMsg( code_m ) << http_endl;
	response << "Date: " << content_m->getCreateTime() << http_endl;
	response << "Allow: GET, HEAD, OPTIONS" << http_endl;
	response << http_endl;

	return response.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x5590
leaq 0x30e7(%rip), %rsi      # 0x14d75
movq %r15, %rdi
callq 0x5400
movl 0x50(%r14), %esi
movq %rax, %rdi
callq 0x5750
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %r15
movl 0x50(%r14), %esi
movq %r14, %rdi
callq 0x1139c
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
leaq 0xf79a(%rip), %r12      # 0x21468
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
leaq 0x309e(%rip), %rsi      # 0x14d7f
movq %rsp, %rdi
callq 0x5400
movq %rax, %r15
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x5400
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
leaq 0x30c6(%rip), %rsi      # 0x14dda
movq %rsp, %rdi
callq 0x5400
movq (%r12), %rsi
movq %rax, %rdi
callq 0x5400
movq (%r12), %rsi
movq %rsp, %rdi
callq 0x5400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56b0
movq %rsp, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5110
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/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 0x54f0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5670
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5670
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x5670
pushq $0xd
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/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
orl $-0x1, (%rbx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x11d84
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x5670
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51a0
movl (%rbx), %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x5280
leaq -0x28(%rip), %rax       # 0x11e24
movq %rax, -0x8(%r14)
movq %rsp, %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x5500
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf731(%rip), %rdi      # 0x215f0
leaq 0x2f42(%rip), %rdx      # 0x14e08
leaq 0x2f9d(%rip), %r8       # 0x14e6a
pushq $0x9
popq %rsi
movq %rcx, 0x10(%rsp)
callq 0x11fe8
leaq 0x10(%r14), %r12
xorl %r13d, %r13d
movl %r13d, 0x4(%rsp)
movq 0x28(%r14), %rbx
movl $0xa0, %edi
callq 0x5410
movq %rax, %rbp
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0xf3c2
movl 0x18(%rsp), %r15d
movq %r12, %rdi
callq 0xf814
movq %rbp, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x103c0
movq %rbp, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1209c
incl %r13d
testb %al, %al
jne 0x11ee1
movq 0x28(%r14), %rdi
callq 0xe5e6
addq $0x20, %r14
leaq 0x4(%rsp), %rax
leaq 0xf6a0(%rip), %rbx      # 0x215f0
leaq 0x2ec1(%rip), %rdx      # 0x14e18
leaq 0x27b4(%rip), %r9       # 0x14712
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rcx
pushq %rax
leaq 0x10(%rsp), %rax
pushq %rax
callq 0x1212e
popq %rax
popq %rcx
leaq 0x2e87(%rip), %rdx      # 0x14e08
leaq 0x2eb0(%rip), %r8       # 0x14e38
pushq $0x9
popq %rsi
movq %rbx, %rdi
movq 0x10(%rsp), %rcx
callq 0x12222
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11fac
movq %rdx, %r12
movq %rax, %rbx
jmp 0x11fc7
movq %rdx, %r12
movq %rax, %rbx
movl $0xa0, %esi
movq %rbp, %rdi
callq 0x5420
cmpl $0x1, %r12d
jne 0x11fdf
movq %rbx, %rdi
callq 0x51f0
callq 0x5700
jmp 0x11f37
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13208
leaq 0x328(%r14), %r15
movq %r15, %rdi
callq 0x131de
movb 0x398(%r14), %bl
cmpb $0x1, %bl
jne 0x120e7
movq %r13, %rdi
callq 0x1320e
movq %r15, %rdi
callq 0x131f2
jmp 0x1211e
movq (%r12), %rax
movl 0x320(%r14), %ecx
movq %rax, (%r14,%rcx,8)
leal 0x1(%rcx), %eax
pushq $0x64
popq %rcx
xorl %edx, %edx
divl %ecx
movl %edx, 0x320(%r14)
movq %r15, %rdi
callq 0x131f2
addq $0x350, %r14            # imm = 0x350
movq %r14, %rdi
callq 0x1320e
xorb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf05e(%rip), %r14      # 0x215f0
leaq 0x28c3(%rip), %rdx      # 0x14e5c
pushq $0x9
popq %rsi
movq %r14, %rdi
callq 0x125da
callq 0x11de2
leaq 0x4(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x28c8(%rip), %rdx      # 0x14e7f
leaq 0x28c8(%rip), %r8       # 0x14e86
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1266e
movq 0x8(%rbx), %rdi
callq 0xef2e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rax
movq %rsi, %rdi
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movslq %eax, %rcx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
imulq $0xf4240, %rdx, %rcx    # imm = 0xF4240
movq %rcx, 0x8(%rax)
xorl %esi, %esi
movq %rax, %rdx
callq 0x52e0
testl %eax, %eax
sete %al
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x1c(%rsp)
leaq 0x8(%rdi), %rbx
leaq 0xeca9(%rip), %rdi      # 0x215f0
leaq 0x256b(%rip), %r12      # 0x14eb9
leaq 0x2515(%rip), %r8       # 0x14e6a
pushq $0x9
popq %rbp
movl %ebp, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x12af8
leaq 0x255b(%rip), %r13      # 0x14ec7
leaq 0x10(%rsp), %r15
movq 0x18(%r14), %rdi
callq 0x12bac
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x12a66
leaq 0xec61(%rip), %rdi      # 0x215f0
movl %ebp, %esi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x12c36
movq 0x10(%rsp), %rdi
callq 0x108e8
movq 0x10(%rsp), %rdi
callq 0x1047a
movq 0x10(%rsp), %rdi
callq 0x1086c
movq 0x10(%rsp), %rdi
callq 0x108aa
incl 0x1c(%rsp)
movq %r15, %rdi
callq 0x12cea
jmp 0x12971
movq %rdx, 0x20(%rsp)
movq %rax, (%rsp)
jmp 0x129f1
movq %rdx, 0x20(%rsp)
movq %rax, (%rsp)
movq %r15, %rdi
callq 0x12cea
movq 0x20(%rsp), %rax
cmpl $0x3, %eax
jne 0x12a20
movq (%rsp), %rdi
callq 0x51f0
leaq 0xebe5(%rip), %rdi      # 0x215f0
pushq $0x5
popq %rsi
movq %rax, %rdx
callq 0x12d98
callq 0x5700
jmp 0x12971
cmpl $0x2, %eax
jne 0x12a4a
movq (%rsp), %rdi
callq 0x51f0
leaq 0xebbb(%rip), %rdi      # 0x215f0
pushq $0x4
popq %rsi
movq %rax, %rdx
callq 0x12d04
callq 0x5700
jmp 0x12971
cmpl $0x1, %eax
jne 0x12ae6
movq (%rsp), %rdi
callq 0x51f0
callq 0x5700
jmp 0x12971
leaq 0x10(%rsp), %rdi
callq 0x12cea
leaq 0x1c(%rsp), %rax
leaq 0xe(%rsp), %r10
leaq 0xeb6f(%rip), %r14      # 0x215f0
leaq 0x244b(%rip), %rdx      # 0x14ed3
leaq 0x1c83(%rip), %r9       # 0x14712
pushq $0x2
popq %rsi
leaq 0xf(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rcx
pushq %rax
pushq %r10
callq 0x12e2c
popq %rax
popq %rcx
leaq 0x240b(%rip), %rdx      # 0x14eb9
leaq 0x2383(%rip), %r8       # 0x14e38
pushq $0x9
popq %rsi
movq %r14, %rdi
movq %rbx, %rcx
callq 0x12f20
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
callq 0x5700
jmp 0x12ae6
movq %rax, (%rsp)
callq 0x5700
movq (%rsp), %rdi
callq 0x5770
movq %rax, %rdi
callq 0x7285
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13208
leaq 0x328(%rbx), %r12
movq %r12, %rdi
callq 0x131de
movl 0x324(%rbx), %eax
cmpb $0x1, 0x398(%rbx)
jne 0x12bf9
cmpl 0x320(%rbx), %eax
jne 0x12bf9
movq %r12, %rdi
callq 0x131f2
xorl %r15d, %r15d
jmp 0x12c1e
movq (%rbx,%rax,8), %r15
incl %eax
pushq $0x64
popq %rcx
xorl %edx, %edx
divl %ecx
movl %edx, 0x324(%rbx)
movq %r12, %rdi
callq 0x131f2
addq $0x370, %rbx            # imm = 0x370
movq %rbx, %r14
movq %r14, %rdi
callq 0x1320e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
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 0x242c
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), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x10(%rsp), %rdx
movq %rdi, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
callq 0x2130
testl %eax, %eax
js 0x2491
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x22a0
movq 0x8(%rsp), %rdi
callq 0x2180
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
movq 0x5b40(%rip), %rax      # 0x7fd8
movq (%rax), %rcx
leaq 0x2da1(%rip), %rdi      # 0x5243
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x22b0
pushq $0x1
popq %rdi
callq 0x2190
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movl %edx, 0x34(%rdi)
orl $-0x1, 0x38(%rdi)
movq %rsi, %r15
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 0x2b62(%rip), %rsi      # 0x52c8
movq %r15, %rdi
callq 0x2170
testq %rax, %rax
je 0x282b
movq %rax, %r14
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2120
movq 0x30(%r12), %rax
pushq $0x6
popq %rcx
cqto
idivq %rcx
movq %rax, %r13
cmpl $0x7fff, %r13d          # imm = 0x7FFF
ja 0x2848
leaq 0x40048(%rbx), %r15
leaq 0x40060(%rbx), %r12
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
jne 0x27e1
cmpq $0x7fff, %rbp           # imm = 0x7FFF
ja 0x27e1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x305e
movq %rax, 0x48(%rbx,%rbp,8)
incq %rbp
jmp 0x27b7
movq %rbx, %rdi
callq 0x308c
movl 0x30(%rbx), %ecx
cmpl %r13d, %ecx
ja 0x2866
movl 0x4(%rbx), %esi
addl (%rbx), %esi
movq %r15, %rdi
callq 0x3254
movl 0x20(%rbx), %esi
addl 0x18(%rbx), %esi
addl 0x1c(%rbx), %esi
addl 0xc(%rbx), %esi
movq %r12, %rdi
callq 0x3254
movq %r14, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2140
movq 0x57a6(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
leaq 0x2a8e(%rip), %rsi      # 0x52ca
movq %r15, %rdx
xorl %eax, %eax
callq 0x2200
jmp 0x2881
movq 0x5789(%rip), %rax      # 0x7fd8
movq (%rax), %rcx
leaq 0x2a86(%rip), %rdi      # 0x52df
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x22b0
jmp 0x2881
movq 0x576b(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
leaq 0x2a78(%rip), %rsi      # 0x52ef
movl %r13d, %edx
xorl %eax, %eax
callq 0x2200
pushq $0x1
popq %rdi
callq 0x2190
jmp 0x288b
movq %rax, %rbx
movq %r12, %rdi
callq 0x3284
movq %r15, %rdi
callq 0x3284
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
movzbl %sil, %ebp
movl $0xffffff, %r12d        # imm = 0xFFFFFF
cmpq %r14, %r15
je 0x2936
leal 0x3(%r14), %r13d
movl 0x4b(%rbx,%r13,8), %edx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x3a68
movl 0x48(%rbx,%r13,8), %edx
andl %r12d, %edx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x3a68
incq %r14
jmp 0x2901
cmpb $0x0, 0x40(%rbx)
je 0x2948
leaq 0x2e21(%rip), %rdi      # 0x5764
callq 0x2220
pushq $0x20
popq %r12
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x2a28
movq 0x40060(%rbx), %rax
cmpq $0x0, -0x18(%rax,%r12)
je 0x297d
cmpb $0x1, 0x40(%rbx)
jne 0x2987
leaq 0x2bb4(%rip), %rdi      # 0x5528
xorl %eax, %eax
callq 0x2030
jmp 0x299a
pushq $0x20
popq %rdi
callq 0x21e0
jmp 0x299a
movq -0x20(%rax,%r12), %rsi
leaq 0x2b98(%rip), %rdi      # 0x552b
xorl %eax, %eax
callq 0x2030
leal 0x3(%r13), %ebp
movq 0x48(%rbx,%rbp,8), %r14
movq %r14, %rdx
shrq $0x18, %rdx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3d0a
andl $0xffffff, %r14d        # imm = 0xFFFFFF
cmpq $0x90000, %r14          # imm = 0x90000
jne 0x2a06
movq 0x48(%rbx,%rbp,8), %rax
movabsq $0xf8000000000, %rcx    # imm = 0xF8000000000
andq %rcx, %rax
movabsq $0xc8000000000, %rcx    # imm = 0xC8000000000
cmpq %rcx, %rax
je 0x2a1c
movq 0x40060(%rbx), %rdi
cmpq $0x0, 0x8(%rdi,%r12)
jne 0x2a1c
addq %r12, %rdi
leaq 0x2d20(%rip), %rsi      # 0x571f
callq 0x22a0
jmp 0x2a1c
pushq $0x20
popq %rdi
callq 0x21e0
movq %rbx, %rdi
movl %r13d, %esi
movl %r14d, %edx
callq 0x3d0a
incq %r13
addq $0x20, %r12
jmp 0x294f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/dtran.cc
// Function: Dtran::prconst(unsigned int, unsigned int, bool)
void prconst (uint32 addr, uint32 len, bool litconst) {
    for (uint cur = addr; cur < addr + len; ++cur) {
        uint64 val = memory[cur+3];
        if (litconst) {
            printf(" /%d:", cur-cmd_len);
        } else if (labels[cur].empty()) {
            printf(" ");
        } else {
            printf(" %s:", labels[cur].c_str());
        }
        if ((val >> 24) == 064000000) {
            uint d = val & 077777777;
            if (d > 200000)
                printf(",INT,%08oB\n", d);
            else
                printf(",INT,%d\n", d);
        } else if (is_likely_iso(val)) {
            printf(",ISO, 6H%s . %s\n", get_iso_word(val).c_str(), get_bytes(val).c_str());
        } else if (is_likely_text(val)) {
            printf(",TEXT, 8H%s\n", get_text_word(val).c_str());
        } else {
            printf(",LOG,%llo\n", val);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x4(%rsp)
movq %rdi, %r15
addl %esi, %edx
movq %rdx, 0x10(%rsp)
movl %esi, %r13d
movq %r13, %rbp
shlq $0x5, %rbp
orq $0x8, %rbp
leaq 0x2c6e(%rip), %r14      # 0x56d7
leaq 0x18(%rsp), %rbx
cmpq 0x10(%rsp), %r13
jae 0x2bcf
leal 0x3(%r13), %eax
movq 0x48(%r15,%rax,8), %r12
cmpb $0x0, 0x4(%rsp)
je 0x2a9e
movl 0x18(%r15), %eax
movl %r13d, %esi
subl %eax, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
jmp 0x2ac9
movq 0x40060(%r15), %rax
cmpq $0x0, (%rax,%rbp)
je 0x2ac1
movq -0x8(%rax,%rbp), %rsi
leaq 0x2a73(%rip), %rdi      # 0x552b
xorl %eax, %eax
callq 0x2030
jmp 0x2ac9
pushq $0x20
popq %rdi
callq 0x21e0
movq %r12, %rax
shrq $0x18, %rax
cmpq $0xd00000, %rax         # imm = 0xD00000
jne 0x2aee
cmpl $0x30d41, %r12d         # imm = 0x30D41
jb 0x2b65
leaq 0x2bf1(%rip), %rdi      # 0x56dd
jmp 0x2b6c
movq %r15, %rdi
movq %r12, %rsi
callq 0x4316
testb %al, %al
je 0x2b82
movq %rbp, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x433e
movq 0x18(%rsp), %rbp
leaq 0x38(%rsp), %rdi
movq %r15, %r14
movq %r15, %rsi
movq %r12, %rdx
callq 0x44e0
movq 0x38(%rsp), %rdx
leaq 0x2bba(%rip), %rdi      # 0x56f2
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x38(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq 0x8(%rsp), %rbp
movq %r14, %r15
leaq 0x2b74(%rip), %r14      # 0x56d7
jmp 0x2b76
leaq 0x2b7d(%rip), %rdi      # 0x56e9
movl %r12d, %esi
xorl %eax, %eax
callq 0x2030
incq %r13
addq $0x20, %rbp
jmp 0x2a6e
movq %r15, %rdi
movq %r12, %rsi
callq 0x43cc
testb %al, %al
je 0x2bbc
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x32a6
movq 0x18(%rsp), %rsi
leaq 0x2b58(%rip), %rdi      # 0x5703
xorl %eax, %eax
callq 0x2030
movq %rbx, %rdi
callq 0x20b0
jmp 0x2b76
leaq 0x2b4d(%rip), %rdi      # 0x5710
movq %r12, %rsi
xorl %eax, %eax
callq 0x2030
jmp 0x2b76
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/dtran.cc
// Function: Dtran::prsets()
void prsets() {
    for (uint cur = table_off - set_len; cur < table_off; ++cur) {
        uint64 word = memory[cur];
        uint len = word >> 36;
        uint from = (word >> 24) & 03777;
        uint cnt = (word >> 12) & 07777;
        uint to = word & 03777;
        std::string src = symtab[from];
        if (len == 1 && src[0] == '*') {
            char * end;
            uint off = strtol(src.c_str()+1, &end, 8);
            do {
                switch (*end) {
                case '\0': break;
                case '+':
                    if (isdigit(end[1]))
                        off += atoi(end+1);
                    else
                        off = ~0;
                    break;
                case 'B':
                    ++end;
                    continue;
                default:
                    off = ~0;
                    break;
                }
                break;
            } while (1);
        }
        printf(" %d,SET,%s\n", len, src.c_str());
        printf(" %d,   ,%s\n", cnt, symtab[to].c_str());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x24(%rdi), %eax
movl %eax, %r12d
subl 0x10(%rdi), %r12d
leaq 0x8(%rsp), %r14
movl %eax, %eax
cmpq %rax, %r12
jae 0x302e
movq 0x48(%rbx,%r12,8), %r15
movq %r15, %r13
shrq $0x24, %r13
movq %r15, %rsi
shrq $0x18, %rsi
andl $0x7ff, %esi            # imm = 0x7FF
shll $0x5, %esi
addq 0x40048(%rbx), %rsi
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rsp), %rdx
cmpq $0x1, %r13
jne 0x2fd8
cmpb $0x2a, (%rdx)
jne 0x2fd8
incq %rdx
movq %rdx, %rdi
movq %rsp, %rsi
pushq $0x8
popq %rdx
callq 0x21f0
movq 0x8(%rsp), %rdx
movl %r15d, %ebp
shrl $0xc, %ebp
andl $0xfff, %ebp            # imm = 0xFFF
andl $0x7ff, %r15d           # imm = 0x7FF
leaq 0x274b(%rip), %rdi      # 0x573d
movl %r13d, %esi
xorl %eax, %eax
callq 0x2030
movq 0x40048(%rbx), %rax
shll $0x5, %r15d
movq (%rax,%r15), %rdx
leaq 0x2737(%rip), %rdi      # 0x5749
movl %ebp, %esi
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0x20b0
incq %r12
movl 0x24(%rbx), %eax
jmp 0x2f7c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/dtran.cc
// Function: Dtran::freadw(_IO_FILE*)
uint64
freadw (FILE *fd)
{
    uint64 val = 0;
    int i;
    for (i = 0; i < 6; ++i) {
        val <<= 8;
        val |= getc (fd);
    }
    return val;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
pushq $0x6
popq %rbp
xorl %r14d, %r14d
subl $0x1, %ebp
jb 0x3083
shlq $0x8, %r14
movq %rbx, %rdi
callq 0x2060
cltq
orq %rax, %r14
jmp 0x306b
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop