LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12762
addq $0xc, %r14
leaq 0xfe83(%rip), %rdi      # 0x225c0
leaq 0x62d9(%rip), %rcx      # 0x18a1d
movl $0x5, %esi
movq %r14, %rdx
movq %rbx, %r8
callq 0x12ddc
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 0x6295(%rip), %rsi      # 0x18a14
leaq 0x6296(%rip), %rdx      # 0x18a1c
leaq 0x8(%rsp), %rdi
callq 0x8e2c
callq 0x5060
movl (%rax), %edi
callq 0x51b0
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x7ae4
movl 0x8(%r14), %r8d
movl 0xc(%r14), %ecx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1344a
leaq 0xf1f6(%rip), %rax      # 0x219c8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf0aa(%rip), %rsi      # 0x21888
leaq 0x49f(%rip), %rdx       # 0x12c84
movq %rbx, %rdi
callq 0x56f0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1280b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x12822
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
testb %bpl, %bpl
jne 0x12848
jmp 0x12850
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x12848
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x12848
movq %rax, %r14
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/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 0x128a4
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 0x6176(%rip), %rsi      # 0x18a40
leaq 0x617c(%rip), %rdx      # 0x18a4d
leaq 0x10(%rsp), %rdi
callq 0x8e2c
movl %ebp, %edi
callq 0x5590
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x7ae4
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x131a4
leaq 0xf0af(%rip), %rax      # 0x219c8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xef63(%rip), %rsi      # 0x21888
leaq 0x358(%rip), %rdx       # 0x12c84
movq %rbx, %rdi
callq 0x56f0
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12952
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x12969
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
testb %bpl, %bpl
jne 0x1298f
jmp 0x12997
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1298f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x1298f
movq %rax, %r14
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x132e5
movq %rbx, %rdi
callq *%rax
movq %rax, %r15
testq %rax, %rax
je 0x13311
movq %r15, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x13329
movq %rbx, %rdi
callq *%rax
movq %rax, %r15
testq %rax, %rax
je 0x133a9
movq %r15, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x133c1
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x56e0
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 0x5777(%rip), %rsi      # 0x18acf
movl $0x9, %edx
movq %rax, %rdi
callq 0x5450
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x5700
leaq 0xe(%rsp), %rsi
movb $0x28, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5450
movl 0x4c(%rbx), %esi
movq %rax, %rdi
callq 0x5700
movq %rax, %r14
leaq 0x5038(%rip), %rsi      # 0x183d2
movl $0x3, %edx
movq %rax, %rdi
callq 0x5450
jmp 0x1341f
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x56e0
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 0x56df(%rip), %rsi      # 0x18acf
movl $0x9, %edx
movq %rax, %rdi
callq 0x5450
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x5700
movq %rax, %r14
leaq 0x4fc1(%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 0x7cac
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13797
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 0x1378c
callq 0x5060
movl (%rax), %ebp
cmpl $0x4, %ebp
je 0x13769
jmp 0x137c4
addq %rax, %r15
movq %rbx, %r12
subq %r15, %r12
ja 0x13760
addq $0x4, %r14
leaq 0xee1e(%rip), %rdi      # 0x225c0
leaq 0x5351(%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 0x13ac8
movl (%r14), %edi
callq 0x57b0
movl $0x50, %edi
callq 0x5200
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x530a(%rip), %rsi      # 0x18af3
leaq 0x5309(%rip), %rdx      # 0x18af9
leaq 0x18(%rsp), %rdi
callq 0x8e2c
movl %ebp, %edi
callq 0x51b0
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x7ae4
movl (%r14), %r8d
movl 0x4(%r14), %ecx
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x1344a
leaq 0xe23a(%rip), %rax      # 0x21a70
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe1d6(%rip), %rsi      # 0x21a18
leaq -0xbc5(%rip), %rdx      # 0x12c84
movq %rbx, %rdi
callq 0x56f0
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1386f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x13886
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53f0
testb %bpl, %bpl
jne 0x138ac
jmp 0x138b4
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x138ac
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x138ac
movq %rax, %r14
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x20, %r8d
callq 0x14f44
movq %r15, %rdi
callq 0x151af
movl %eax, (%rbx)
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x14d80
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x14dd8
leaq 0x8(%rsp), %r15
leaq 0x2c(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x20, %r8d
callq 0x14f44
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x54a0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x14dc4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
cmpq $0x0, 0x10(%rbx)
je 0x14e48
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 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7ae4
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3e17(%rip), %rsi      # 0x18c1f
leaq 0x3e1c(%rip), %rdx      # 0x18c2b
leaq 0x30(%rsp), %rdi
callq 0x8e2c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x14ffe
xorl %ebp, %ebp
leaq 0xccb1(%rip), %rsi      # 0x21ae8
leaq 0x240(%rip), %rdx       # 0x1507e
movq %r14, %rdi
callq 0x56f0
jmp 0x14eb6
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
movq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7ae4
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3db4(%rip), %rsi      # 0x18c2c
leaq 0x3db5(%rip), %rdx      # 0x18c34
leaq 0x30(%rsp), %rdi
callq 0x8e2c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x14ffe
xorl %ebp, %ebp
leaq 0xcc41(%rip), %rsi      # 0x21ae8
leaq 0x1d0(%rip), %rdx       # 0x1507e
movq %r14, %rdi
callq 0x56f0
jmp 0x14eba
jmp 0x14ef2
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x14ed4
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x14eeb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
testb %bpl, %bpl
jne 0x14f13
jmp 0x14f3b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x14f13
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x14f13
jmp 0x14f10
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
jmp 0x14f3b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14f3b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/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), %rdx
movl (%rcx), %eax
cmpq %rax, %rdx
jbe 0x14f91
movq (%r12), %rsi
cmpb %bpl, (%rsi,%rax)
jne 0x14f96
incl %eax
movl %eax, (%r15)
movq %rax, %rcx
cmpq %rax, %rdx
ja 0x14f7c
jmp 0x14f98
movq %rax, %rcx
jmp 0x14f98
movl %eax, %ecx
cmpq %rcx, %rdx
jbe 0x14fc8
leaq 0x28(%r14), %r13
movq (%r12), %rdx
cmpb %bpl, (%rdx,%rcx)
je 0x14fc8
incl %eax
movl %eax, (%r15)
movsbl (%rdx,%rcx), %esi
movq %r13, %rdi
callq 0x5340
movl (%r15), %ecx
movl %ecx, %eax
cmpq %rcx, 0x8(%r12)
ja 0x14fa1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x8d96
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_O3/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 0xc97d(%rip), %r15      # 0x21b40
leaq 0x3aa4(%rip), %r12      # 0x18c6e
movq %r12, %rsi
cmpl $0x4, %ebx
ja 0x151d5
movq (%r15), %rsi
movq %r14, %rdi
callq 0x5150
testl %eax, %eax
je 0x151f1
incl %ebx
addq $0x8, %r15
cmpl $0x5, %ebx
jne 0x151ca
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_O3/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 0x1522b
leal -0x190(%rsi), %eax
cmpl $0x9, %eax
ja 0x15243
leaq 0x3a62(%rip), %rcx      # 0x18c7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3aa2(%rip), %rax      # 0x18ccc
retq
cmpl $0x1f5, %esi            # imm = 0x1F5
je 0x1527b
cmpl $0x1f7, %esi            # imm = 0x1F7
jne 0x15253
leaq 0x3ad6(%rip), %rax      # 0x18d18
retq
cmpl $0xc8, %esi
jne 0x15253
leaq 0x3a77(%rip), %rax      # 0x18cc9
retq
leaq 0x3ad2(%rip), %rax      # 0x18d2c
retq
leaq 0x3a8a(%rip), %rax      # 0x18cec
retq
leaq 0x3a78(%rip), %rax      # 0x18ce2
retq
leaq 0x3a66(%rip), %rax      # 0x18cd8
retq
leaq 0x3a85(%rip), %rax      # 0x18cff
retq
leaq 0x3a86(%rip), %rax      # 0x18d08
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5620
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5620
movq %rbx, %rdi
movl $0xf, %esi
callq 0x5620
movq %rbx, %rdi
movl $0xd, %esi
popq %rbx
jmp 0x5620
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5620
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_O3/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 0x5260
leaq -0x28(%rip), %rax       # 0x16481
movq %rax, -0x8(%r14)
movq %rsp, %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x54d0
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc0a5(%rip), %rdi      # 0x225c0
leaq 0x28c2(%rip), %rdx      # 0x18de4
leaq 0x291d(%rip), %r8       # 0x18e46
movl $0x9, %esi
movq %rcx, 0x10(%rsp)
callq 0x1664c
leaq 0x10(%r14), %r12
xorl %r13d, %r13d
movl %r13d, 0x4(%rsp)
movq 0x28(%r14), %rbx
movl $0xa0, %edi
callq 0x53e0
movq %rax, %rbp
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x126f8
movl 0x18(%rsp), %r15d
movq %r12, %rdi
callq 0x12c80
movq %rbp, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x13ccc
movq %rbp, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x167c4
incl %r13d
testb %al, %al
jne 0x1653f
movq 0x28(%r14), %rdi
callq 0x117ee
addq $0x20, %r14
leaq 0x4(%rsp), %rax
leaq 0xc012(%rip), %rbx      # 0x225c0
leaq 0x283f(%rip), %rdx      # 0x18df4
leaq 0x2172(%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 0x1685e
addq $0x10, %rsp
leaq 0x2801(%rip), %rdx      # 0x18de4
leaq 0x282a(%rip), %r8       # 0x18e14
movq %rbx, %rdi
movl $0x9, %esi
movq 0x10(%rsp), %rcx
callq 0x16990
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16610
movq %rdx, %r12
movq %rax, %rbx
jmp 0x1662b
movq %rdx, %r12
movq %rax, %rbx
movl $0xa0, %esi
movq %rbp, %rdi
callq 0x53f0
cmpl $0x1, %r12d
jne 0x16643
movq %rbx, %rdi
callq 0x51e0
callq 0x56a0
jmp 0x16595
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17b78
leaq 0x328(%r14), %r15
movq %r15, %rdi
callq 0x17b4e
movb 0x398(%r14), %bl
cmpb $0x1, %bl
jne 0x1680f
movq %r13, %rdi
callq 0x17b7e
movq %r15, %rdi
callq 0x17b62
jmp 0x1684f
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 0x17b62
addq $0x350, %r14            # imm = 0x350
movq %r14, %rdi
callq 0x17b7e
xorb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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      # 0x225c0
leaq 0x21e7(%rip), %rdx      # 0x18e38
movq %r14, %rdi
movl $0x9, %esi
callq 0x16cb4
callq 0x1643a
leaq 0x4(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x21ea(%rip), %rdx      # 0x18e5b
leaq 0x21ea(%rip), %r8       # 0x18e62
movq %r14, %rdi
movl $0x1, %esi
callq 0x16dc0
movq 0x8(%rbx), %rbx
movb $0x1, 0x398(%rbx)
leaq 0x350(%rbx), %rdi
callq 0x17b7e
addq $0x370, %rbx            # imm = 0x370
movq %rbx, %rdi
callq 0x17b7e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x1c(%rsp)
leaq 0x8(%rdi), %rbx
leaq 0xb4e2(%rip), %r15      # 0x225c0
leaq 0x1db0(%rip), %r12      # 0x18e95
leaq 0x1d5a(%rip), %r8       # 0x18e46
movq %r15, %rdi
movl $0x9, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x17292
leaq 0x1d9d(%rip), %r13      # 0x18ea3
leaq 0x10(%rsp), %rbp
movq 0x18(%r14), %rdi
callq 0x1740a
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x171fb
movq %r15, %rdi
movl $0x9, %esi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x1749c
movq 0x10(%rsp), %rdi
callq 0x142d6
movq 0x10(%rsp), %rdi
callq 0x13dd8
movq 0x10(%rsp), %rdi
callq 0x14220
movq 0x10(%rsp), %rdi
callq 0x14270
incl 0x1c(%rsp)
movq %rbp, %rdi
callq 0x17614
jmp 0x1710b
movq %rdx, 0x20(%rsp)
movq %rax, (%rsp)
jmp 0x1718a
movq %rdx, 0x20(%rsp)
movq %rax, (%rsp)
movq %rbp, %rdi
callq 0x17614
movq 0x20(%rsp), %rax
cmpl $0x3, %eax
jne 0x171b7
movq (%rsp), %rdi
callq 0x51e0
movq %r15, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x17748
callq 0x56a0
jmp 0x1710b
cmpl $0x2, %eax
jne 0x171df
movq (%rsp), %rdi
callq 0x51e0
movq %r15, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x17648
callq 0x56a0
jmp 0x1710b
cmpl $0x1, %eax
jne 0x17281
movq (%rsp), %rdi
callq 0x51e0
callq 0x56a0
jmp 0x1710b
leaq 0x10(%rsp), %rdi
callq 0x17614
leaq 0x1c(%rsp), %rax
leaq 0xe(%rsp), %r10
leaq 0xb3aa(%rip), %r14      # 0x225c0
leaq 0x1c92(%rip), %rdx      # 0x18eaf
leaq 0x150a(%rip), %r9       # 0x1872e
leaq 0xf(%rsp), %r8
movq %r14, %rdi
movl $0x2, %esi
movq %rbx, %rcx
pushq %rax
pushq %r10
callq 0x17848
addq $0x10, %rsp
leaq 0x1c4e(%rip), %rdx      # 0x18e95
leaq 0x1bc6(%rip), %r8       # 0x18e14
movq %r14, %rdi
movl $0x9, %esi
movq %rbx, %rcx
callq 0x179bc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
callq 0x56a0
jmp 0x17281
movq %rax, (%rsp)
callq 0x56a0
movq (%rsp), %rdi
callq 0x5720
movq %rax, %rdi
callq 0x7cac
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17b78
leaq 0x328(%rbx), %r12
movq %r12, %rdi
callq 0x17b4e
movl 0x324(%rbx), %eax
cmpb $0x1, 0x398(%rbx)
jne 0x17457
cmpl 0x320(%rbx), %eax
jne 0x17457
movq %r12, %rdi
callq 0x17b62
xorl %r15d, %r15d
jmp 0x17485
movq (%rbx,%rax,8), %r15
incl %eax
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
shrq $0x25, %rcx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x324(%rbx)
movq %r12, %rdi
callq 0x17b62
addq $0x370, %rbx            # imm = 0x370
movq %rbx, %r14
movq %r14, %rdi
callq 0x17b7e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x298f(%rip), %rsi      # 0x52c8
movq %r15, %rdi
callq 0x2160
testq %rax, %rax
je 0x2a2b
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 0x2a33
movq %r14, %rdi
callq 0x2200
testl %eax, %eax
jne 0x29d3
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 0x2999
movq %rax, 0x48(%rbx,%r12,8)
movq %r14, %rdi
callq 0x2200
testl %eax, %eax
jne 0x29d3
leaq 0x1(%r12), %rax
cmpq $0x7fff, %r12           # imm = 0x7FFF
movq %rax, %r12
jb 0x2992
leaq 0x40048(%rbx), %r12
leaq 0x40060(%rbx), %r13
movq %rbx, %rdi
callq 0x33da
movl 0x30(%rbx), %esi
cmpl %r15d, %esi
ja 0x2a38
movl 0x4(%rbx), %esi
addl (%rbx), %esi
movq %r12, %rdi
callq 0x3594
movl 0x20(%rbx), %esi
addl 0x18(%rbx), %esi
addl 0x1c(%rbx), %esi
addl 0xc(%rbx), %esi
movq %r13, %rdi
callq 0x3594
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 0x35c4
movq %r12, %rdi
callq 0x35c4
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2af3
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 0x3e1c
movl 0x48(%rbx,%r13,8), %edx
andl %r12d, %edx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x3e1c
incq %r14
cmpq %r14, %r15
jne 0x2ac0
cmpb $0x0, 0x40(%rbx)
je 0x2b05
leaq 0x2c64(%rip), %rdi      # 0x5764
callq 0x21e0
testq %r15, %r15
je 0x2bf7
movl $0x20, %r14d
xorl %r13d, %r13d
movq 0x40060(%rbx), %rax
cmpq $0x0, -0x18(%rax,%r14)
je 0x2b3c
cmpb $0x1, 0x40(%rbx)
jne 0x2b48
leaq 0x29f5(%rip), %rdi      # 0x5528
xorl %eax, %eax
callq 0x2030
jmp 0x2b5b
movl $0x20, %edi
callq 0x21b0
jmp 0x2b5b
movq -0x20(%rax,%r14), %rsi
leaq 0x29d7(%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 0x4078
andl $0xffffff, %ebp         # imm = 0xFFFFFF
cmpq $0x90000, %rbp          # imm = 0x90000
jne 0x2bd0
movq 0x48(%rbx,%r12,8), %rax
movabsq $0xf8000000000, %rcx    # imm = 0xF8000000000
andq %rcx, %rax
movabsq $0xc8000000000, %rcx    # imm = 0xC8000000000
cmpq %rcx, %rax
je 0x2be7
movq 0x40060(%rbx), %rdi
cmpq $0x0, 0x8(%rdi,%r14)
jne 0x2be7
addq %r14, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
leaq 0x2b56(%rip), %rcx      # 0x571f
callq 0x21f0
jmp 0x2be7
movl $0x20, %edi
callq 0x21b0
movq %rbx, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x4078
incq %r13
addq $0x20, %r14
cmpq %r13, %r15
jne 0x2b17
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x24(%rdi), %ecx
movl %ecx, %eax
subl 0x10(%rdi), %eax
cmpl %ecx, %eax
jae 0x33d8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl %eax, %r12d
movq 0x48(%rbx,%r12,8), %rbp
movq %rbp, %r13
shrq $0x24, %r13
movq %rbp, %rax
shrq $0x18, %rax
andl $0x7ff, %eax            # imm = 0x7FF
movq 0x40048(%rbx), %rcx
shll $0x5, %eax
movq %r14, (%rsp)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x497c
movq (%rsp), %rdx
cmpq $0x1, %r13
jne 0x3361
cmpb $0x2a, (%rdx)
jne 0x3361
incq %rdx
movq %rdx, %rdi
leaq 0x20(%rsp), %rsi
movl $0x8, %edx
callq 0x21c0
movq (%rsp), %rdx
movl %ebp, %r15d
shrl $0xc, %r15d
andl $0xfff, %r15d           # imm = 0xFFF
andl $0x7ff, %ebp            # imm = 0x7FF
leaq 0x23c1(%rip), %rdi      # 0x573d
movl %r13d, %esi
xorl %eax, %eax
callq 0x2030
movq 0x40048(%rbx), %rax
shll $0x5, %ebp
movq (%rax,%rbp), %rdx
leaq 0x23ae(%rip), %rdi      # 0x5749
movl %r15d, %esi
xorl %eax, %eax
callq 0x2030
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x33bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
incq %r12
movl 0x24(%rbx), %eax
cmpq %rax, %r12
jb 0x32ff
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/dtran.cc
// Function: Dtran::get_text_word[abi:cxx11](unsigned long long)
std::string get_text_word(uint64 word) {
        std::string ret;
        for (uint i = 42; i <= 42; i-=6) {
            ret += get_text_char(word >> i);
        }
        return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x2a, %r15d
leaq 0x19d1(%rip), %rbp      # 0x502c
leaq 0x18(%rsp), %r12
leaq 0xf(%rsp), %r13
movq %r14, %rax
movl %r15d, %ecx
shrq %cl, %rax
andl $0x3f, %eax
movslq (%rbp,%rax,4), %rsi
addq %rbp, %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x3714
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x2060
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x36b2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2140
addq $-0x6, %r15
cmpq $0x2b, %r15
jb 0x3665
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x36f2
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x36f2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2140
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x370c
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/dtran.cc
// Function: Dtran::gak[abi:cxx11](unsigned int)
std::string gak(uint i) {
        std::string ret("G");
        ret += 'A'+i/128;
        ret += 'K'+i/8%16;
        ret += '/';
        ret += '0'+i%8;
        return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x16a8(%rip), %rsi      # 0x5444
leaq 0x16a2(%rip), %rdx      # 0x5445
callq 0x3752
movl %ebp, %eax
shrl $0x7, %eax
addb $0x41, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x20f0
movl %ebp, %eax
shrb $0x3, %al
andb $0xf, %al
addb $0x4b, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x20f0
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x20f0
andb $0x7, %bpl
orb $0x30, %bpl
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3e13
movq (%r15), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/dtran.cc
// Function: Dtran::get_literal[abi:cxx11](unsigned int)
std::string get_literal(uint32 addr) {
    uint64 val = memory[addr + 3];
    std::string ret;
    if ((val >> 24) == 064000000) {
        uint d = val & 077777777;
        if (d > 10000)
            ret = strprintf("%08oB", d);
        else
            ret = strprintf("(%d)", d);
    } else if (is_likely_iso(val)) {
        ret = strprintf("iso('%s')", get_iso_word(val).c_str());
    } else if (is_likely_text(val)) {
        ret = strprintf("%lloC(*\"%s\"*)", val, get_text_word(val).c_str());
    } else if (val >= 0101 && val < 96) {
        ret = strprintf("char('%c')", char(val));
    } else {
        ret = strprintf("(%lloC)", val);
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
addl $0x3, %edx
movq 0x48(%rsi,%rdx,8), %r14
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %r14, %rax
shrq $0x18, %rax
cmpq $0xd00000, %rax         # imm = 0xD00000
jne 0x45a3
cmpl $0x2711, %r14d          # imm = 0x2711
jb 0x45f2
leaq 0x109c(%rip), %rsi      # 0x562e
leaq 0x8(%rsp), %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x254c
jmp 0x4608
movq %rsi, %r15
xorl %ecx, %ecx
movq %r14, %rax
shrq %cl, %rax
movzbl %al, %eax
addl $-0x20, %eax
cmpq $0x27, %rcx
ja 0x45c3
addq $0x8, %rcx
cmpl $0x5f, %eax
jb 0x45a8
cmpl $0x5e, %eax
ja 0x4630
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x474a
movq 0x28(%rsp), %rdx
leaq 0x1055(%rip), %rsi      # 0x5639
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x254c
jmp 0x466a
leaq 0x103b(%rip), %rsi      # 0x5634
leaq 0x8(%rsp), %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x254c
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2190
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x46af
movq 0x18(%rsp), %rsi
jmp 0x46a7
movq %r15, %rdi
movq %r14, %rsi
callq 0x4824
testb %al, %al
je 0x46be
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3622
movq 0x28(%rsp), %rcx
leaq 0xfe8(%rip), %rsi       # 0x5643
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x254c
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2190
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4694
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46af
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq -0x41(%r14), %rax
cmpq $0x1e, %rax
ja 0x46e3
leaq 0xf82(%rip), %rsi       # 0x5651
leaq 0x8(%rsp), %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x254c
jmp 0x4608
leaq 0xf72(%rip), %rsi       # 0x565c
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x254c
jmp 0x4608
jmp 0x472a
jmp 0x472a
jmp 0x4706
jmp 0x472a
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x472d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x472d
jmp 0x472a
jmp 0x472a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4741
movq (%r12), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/dtran.cc
// Function: Dtran::get_iso_word[abi:cxx11](unsigned long long)
std::string get_iso_word(uint64 word) {
        std::string ret;
        for (uint i = 40; i <= 40; i-=8) {
            ret += get_iso_char(word >> i);
        }
        return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x28, %r12d
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r13
movq %r14, %rax
movl %r12d, %ecx
shrq %cl, %rax
movzbl %al, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x48b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2060
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x47c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
addq $-0x8, %r12
cmpq $0x29, %r12
jb 0x4788
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4803
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4803
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x481b
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/dtran.cc
// Function: Dtran::is_likely_text(unsigned long long)
bool is_likely_text(uint64 word) {
        // Of all groups of 6 bits, they should be left-
        // or right-aligned, there must be no spaces in the middle,
        // and no unused codes or Cyrillics.
        int seen0 = 0, seen_char = 0;
        bool last0 = false;
        for (uint i = 42; i <= 42; i-=6) {
            uint val = (word >> i) & 077;
            switch (val) {
            case 001 ... 011:
            case 013 ... 016:
            case 032 ... 034:
            case 037:
            case 040:
            case 073 ... 077:
                return false;
            case 0:
                if (seen_char && seen0 && !last0) return false;
                ++seen0;
                last0 = true;
                break;
            default:
                if (seen_char && seen0 && last0) return false;
                ++seen_char;
                last0 = false;
            }
        }
        return seen_char > 1;
    }

// Assembly:
xorl %r8d, %r8d
movl $0x2a, %ecx
movabsq $-0x7fffffe63ff8402, %rdx # imm = 0xF80000019C007BFE
xorl %eax, %eax
xorl %edi, %edi
movq %rsi, %r9
shrq %cl, %r9
andl $0x3f, %r9d
cmpl $0x3f, %r9d
ja 0x4855
testq %r9, %r9
je 0x4877
btq %r9, %rdx
jb 0x48a5
testl %eax, %eax
setne %r9b
testl %edi, %edi
setne %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x4870
testb $0x1, %r8b
jne 0x48a5
incl %eax
xorl %r8d, %r8d
jmp 0x4897
testl %eax, %eax
setne %r9b
testl %edi, %edi
setne %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x4892
testb $0x1, %r8b
je 0x48a5
incl %edi
movb $0x1, %r8b
addq $-0x6, %rcx
cmpq $0x2b, %rcx
jb 0x483a
movb $0x1, %cl
jmp 0x48a7
xorl %ecx, %ecx
cmpl $0x2, %eax
setge %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/dtran.cc
// Function: Dtran::get_bytes[abi:cxx11](unsigned long long)
std::string get_bytes(uint64 word) {
        std::string ret;
        for (uint i = 40; i <= 40; i-=8) {
            ret += strprintf("%03o ", int(word >> i) & 0377);
        }
        return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x28, %r15d
leaq 0x18(%rsp), %rbp
leaq 0xccc(%rip), %r12       # 0x571b
leaq 0x8(%rsp), %r13
movq %r14, %rax
movl %r15d, %ecx
shrq %cl, %rax
movzbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x254c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2060
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4a96
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
addq $-0x8, %r15
cmpq $0x29, %r15
jb 0x4a54
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4ad1
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4ad1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x4ae9
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/y/board.h
// Function: Morat::Y::Board::update_hash(Morat::MoveValid const&, Morat::Side)
void update_hash(const MoveValid & pos, Side side) {
		int turn = side.to_i();
		if(num_moves_ > unique_depth){ //simple update, no rotations/symmetry
			hash.update(0, 3 * pos.xy + turn);
			return;
		}

		//mirror is simply flip x,y
		int x = pos.x,
		    y = pos.y,
		    z = sizem1_ - x - y;

		hash.update(0,  3*xy(x, y) + turn);
		hash.update(1,  3*xy(z, y) + turn);
		hash.update(2,  3*xy(z, x) + turn);
		hash.update(3,  3*xy(x, z) + turn);
		hash.update(4,  3*xy(y, z) + turn);
		hash.update(5,  3*xy(y, x) + turn);
	}

// Assembly:
cmpw $0x6, 0x4(%rdi)
movsbl %dl, %eax
jl 0x13ae3
movswl 0x2(%rsi), %esi
addq $0x28, %rdi
jmp 0x13b7b
movsbl 0x1(%rsi), %r8d
movsbl (%rsi), %ecx
movsbl 0x1(%rdi), %edx
movsbl (%rdi), %r10d
subl %ecx, %edx
subl %r8d, %edx
movl %r10d, %esi
imull %ecx, %esi
leal (%rsi,%r8), %r9d
addl %edx, %esi
leal (%r9,%r9,2), %r9d
leal (%rsi,%rsi,2), %esi
addl %eax, %r9d
addl %eax, %esi
movslq %r9d, %r11
leaq 0x22e76(%rip), %r9      # 0x36990
movslq %esi, %rsi
movq (%r9,%r11,8), %r11
xorq %r11, 0x28(%rdi)
movq (%r9,%rsi,8), %rsi
xorq %rsi, 0x30(%rdi)
movl %r10d, %esi
imull %r8d, %esi
leal (%rsi,%rdx), %r11d
imull %r10d, %edx
addl %ecx, %esi
leal (%r11,%r11,2), %r11d
addl %eax, %r11d
addl %edx, %r8d
addl %ecx, %edx
movslq %r11d, %r11
leal (%r8,%r8,2), %r8d
leal (%rdx,%rdx,2), %edx
movq (%r9,%r11,8), %r11
addl %eax, %r8d
addl %eax, %edx
movslq %r8d, %r8
movslq %edx, %rdx
xorq %r11, 0x38(%rdi)
movq (%r9,%r8,8), %r8
xorq %r8, 0x40(%rdi)
movq (%r9,%rdx,8), %rdx
xorq %rdx, 0x48(%rdi)
addq $0x50, %rdi
leaq 0x22e0e(%rip), %rdx     # 0x36990
leal (%rsi,%rsi,2), %ecx
addl %eax, %ecx
movslq %ecx, %rax
movq (%rdx,%rax,8), %rax
xorq %rax, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/y/board.h
// Function: Morat::Y::Board::test_outcome(Morat::MoveValid const&, Morat::Side) const
Outcome test_outcome(const MoveValid & pos, Side turn) const {
		if(test_local(pos, turn)){
			Cell testcell = cells_[find_group(pos.xy)];
			int numgroups = 0;
			auto it = neighbors_small(pos);
			for (const MoveValid *i = it.begin(), *e = it.end(); i < e; i++) {
				if(i->on_board() && turn == get(i->xy)){
					const Cell * g = & cells_[find_group(i->xy)];
					testcell.edge   |= g->edge;
					testcell.size   += g->size;
					i++; //skip the next one
					numgroups++;
				}
			}

			if(testcell.numedges() == 3)
				return +turn;
		}

		return Outcome::UNKNOWN;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movswl 0x2(%rsi), %esi
movl %edx, %ebx
movq %rdi, %r14
callq 0x18564
cmpl $0x3, %eax
jne 0x17dd7
movswl 0x2(%r15), %esi
movq 0x10(%r14), %rax
movq %rsi, %rdi
shlq $0x4, %rdi
movslq %esi, %rdx
movzwl 0x4(%rax,%rdi), %ecx
cmpl %edx, %ecx
je 0x17d3f
leaq 0x4(%rax,%rdi), %rsi
movl %ecx, %ecx
shlq $0x4, %rcx
movzwl 0x4(%rax,%rcx), %edi
movzwl %di, %ecx
movl %ecx, %r8d
shll $0x4, %r8d
cmpw 0x4(%rax,%r8), %di
jne 0x17d1c
movw %cx, (%rsi)
movq %rcx, %rsi
shlq $0x4, %rsi
leaq (%rdx,%rdx,8), %rdx
movb 0x6(%rax,%rsi), %cl
movq 0x58(%r14), %rsi
leaq 0x2(%rsi,%rdx,8), %rdx
xorl %esi, %esi
movswq (%rdx,%rsi), %r8
cmpq $-0x1, %r8
je 0x17dba
movq %r8, %rdi
shlq $0x4, %rdi
cmpb %bl, (%rax,%rdi)
jne 0x17dba
movl %r8d, %r9d
movq %r9, %r10
shlq $0x4, %r10
movzwl 0x4(%rax,%r10), %edi
cmpl %r8d, %edi
je 0x17dad
leaq 0x4(%rax,%r10), %r8
movl %edi, %edi
shlq $0x4, %rdi
movzwl 0x4(%rax,%rdi), %r9d
movzwl %r9w, %edi
movl %edi, %r10d
shll $0x4, %r10d
cmpw 0x4(%rax,%r10), %r9w
jne 0x17d87
movq %rdi, %r9
movw %di, (%r8)
shlq $0x4, %r9
addq $0x4, %rsi
orb 0x6(%rax,%r9), %cl
leaq 0x4(%rsi), %rdi
cmpq $0x14, %rsi
movq %rdi, %rsi
jl 0x17d56
movzbl %cl, %eax
leaq 0x1ba9f(%rip), %rcx     # 0x33870
cmpb $0x3, (%rax,%rcx)
je 0x17de0
leaq 0x1ea88(%rip), %rax     # 0x36866
movb (%rax), %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq