LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CLogger::init( const string& logFile ) {
	if ( logFile == "stdout" ) {
		logStreamIsCOUT = true;
		logStream_m = &cout;
	}
	else {
		logStreamIsCOUT = false;
		ofstream * lfile = new ofstream( logFile.c_str() );
		if ( !lfile->is_open() ) {
			delete lfile;
			throw FileNotFoundException( logFile.c_str(), MSG_CRIT_ERR );
		}
		logStream_m = lfile;
	}
	initialized_m = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc119(%rip), %rsi      # 0x2c09f
callq 0x16f30
testb $0x1, %al
jne 0x1ff91
jmp 0x1ffa8
movq -0x80(%rbp), %rax
movb $0x1, 0x8(%rax)
movq 0x1f030(%rip), %rcx     # 0x3efd0
movq %rcx, (%rax)
jmp 0x2016e
movq -0x80(%rbp), %rax
movb $0x0, 0x8(%rax)
movl $0x200, %edi            # imm = 0x200
callq 0x64d0
movq %rax, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6240
movq -0x88(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x6560
jmp 0x1ffe7
movq -0x90(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x63d0
testb $0x1, %al
jne 0x20163
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0x20021
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, -0x72(%rbp)
movl $0x48, %edi
callq 0x6280
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6240
movq %rax, -0xa8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6930
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xa9d0
jmp 0x2006f
leaq 0x1f4ca(%rip), %rax     # 0x3f540
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6930
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0xa9d0
jmp 0x200a9
movq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xaa80
jmp 0x200bf
movq -0xb0(%rbp), %rdi
movb $0x0, -0x72(%rbp)
leaq 0x1e2ff(%rip), %rsi     # 0x3e3d0
leaq -0x15608(%rip), %rdx    # 0xaad0
callq 0x68e0
jmp 0x20188
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x200, %esi            # imm = 0x200
callq 0x64e0
jmp 0x2017f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x20144
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x20132
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6310
leaq -0x71(%rbp), %rdi
callq 0x6550
leaq -0x48(%rbp), %rdi
callq 0x6310
leaq -0x49(%rbp), %rdi
callq 0x6550
testb $0x1, -0x72(%rbp)
jne 0x20155
jmp 0x20161
movq -0xb0(%rbp), %rdi
callq 0x63b0
jmp 0x2017f
movq -0x80(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x80(%rbp), %rax
movb $0x1, 0x3c(%rax)
addq $0xc0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6920
nopl (%rax,%rax)
// File: metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::printTimestamp()
void CLogger::printTimestamp() {
	time_t ltime;
	tm result;
	char stime[32];

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq (%rax), %rdi
movl $0x28, %esi
callq 0x65b0
movq %rax, %rdi
movq -0x80(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x6900
movq %rax, %rdi
movl $0x29, %esi
callq 0x65b0
movq %rax, %rdi
movl $0x20, %esi
callq 0x65b0
xorl %eax, %eax
movl %eax, %edi
callq 0x6490
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x62a0
leaq -0x70(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x6090
movl $0x1, -0x74(%rbp)
cmpl $0x20, -0x74(%rbp)
jge 0x20238
movslq -0x74(%rbp), %rax
cmpb $0x0, -0x70(%rbp,%rax)
jne 0x2022b
movl -0x74(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x0, -0x70(%rbp,%rax)
jmp 0x20238
jmp 0x2022d
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x2020b
movq -0x80(%rbp), %rax
movq (%rax), %rdi
leaq -0x70(%rbp), %rsi
callq 0x64c0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::error(ELogFlags, int)
void CLogger::error( ELogFlags level, int errNo ) {
	if ( !initialized_m || config.checkLogFlag( level ) ) {
		mutex_m.lock();
		printTimestamp();
		*logStream_m << '\t' << logflagsNS::logFlagsToString( level ) << '\t' << strerror( errNo ) << endl;
		mutex_m.unlock();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x3c(%rax)
je 0x202d8
movl -0xc(%rbp), %esi
leaq 0x1f316(%rip), %rdi     # 0x3f5e0
callq 0x8490
testb $0x1, %al
jne 0x202d8
jmp 0x20358
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x2b990
movq -0x18(%rbp), %rdi
callq 0x20190
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x9, %esi
callq 0x65b0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x207c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x64c0
movq %rax, %rdi
movl $0x9, %esi
callq 0x65b0
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %edi
callq 0x61f0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x64c0
movq %rax, %rdi
movq 0x1ec72(%rip), %rsi     # 0x3efb8
callq 0x6520
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x2b9e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::options()
void CLogger::options() {
	if ( initialized_m ) {
		*logStream_m << "Log options: ";
		for ( int i = 0; i < E_LOG_FLAGS_MAX; i++ )
			if ( config.checkLogFlag( ELogFlags( i ) ) )
				*logStream_m << logflagsNS::logFlagsToString( ELogFlags( i ) ) << ' ';
		*logStream_m << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x3c(%rax)
je 0x203ff
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0xc35f(%rip), %rsi      # 0x2c6eb
callq 0x64c0
movl $0x0, -0xc(%rbp)
cmpl $0xc, -0xc(%rbp)
jge 0x203ec
movl -0xc(%rbp), %esi
leaq 0x1f238(%rip), %rdi     # 0x3f5e0
callq 0x8490
testb $0x1, %al
jne 0x203b3
jmp 0x203df
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x207c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x64c0
movq %rax, %rdi
movl $0x20, %esi
callq 0x65b0
jmp 0x203e1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x20398
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0x1ebbe(%rip), %rsi     # 0x3efb8
callq 0x6520
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/logger/ELogFlags.cpp
// Function: logflagsNS::logFlagsToString(ELogFlags)
const char * logflagsNS::logFlagsToString( ELogFlags f ) {
	switch ( f ) {
		case SILENT:
			return "SILENT";
		case CRITICAL:
			return "CRITICAL";
		case INFO:
			return "INFO";
		case DEBUG_ALL:
			return "DBG_ALL";
		case NETWORK:
			return "NETWORK";
		case DEBUG_NETWORK:
			return "DBG_NETWORK";
		case DEBUG_REQUEST:
			return "DBG_REQUEST";
		case REQUEST:
			return "REQUEST";
		case DEBUG_PARSER:
			return "DBG_PARSER";
		case THREADS:
			return "THREADS";
		case STATISTICS:
			return "STATISTICS";
		default:
			return "UNDEFINED";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0x20881
movq -0x18(%rbp), %rax
leaq 0xbf51(%rip), %rcx      # 0x2c734
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xbf99(%rip), %rax      # 0x2c78c
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xb934(%rip), %rax      # 0x2c137
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xb92d(%rip), %rax      # 0x2c140
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf73(%rip), %rax      # 0x2c793
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf72(%rip), %rax      # 0x2c79f
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf61(%rip), %rax      # 0x2c79b
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf60(%rip), %rax      # 0x2c7a7
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf57(%rip), %rax      # 0x2c7ab
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf52(%rip), %rax      # 0x2c7b3
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf50(%rip), %rax      # 0x2c7be
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf4b(%rip), %rax      # 0x2c7c6
movq %rax, -0x8(%rbp)
jmp 0x2088c
leaq 0xbf49(%rip), %rax      # 0x2c7d1
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: metopa[P]HTTP_Server/src/logger/ELogFlags.cpp
// Function: logflagsNS::logFlagsFromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
ELogFlags logflagsNS::logFlagsFromString( std::string& str ) {
	for ( int i = 0; i < E_LOG_FLAGS_MAX; i++ )
		if ( str.compare( logFlagsToString( (ELogFlags) i ) ) == 0 )
			return (ELogFlags) i;
	return UNDEFINED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0x209cf
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x207c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x61b0
cmpl $0x0, %eax
jne 0x209c2
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x209d6
jmp 0x209c4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x20993
movl $0xb, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: metopa[P]HTTP_Server/src/threads/CThreadSafeQueue.h
// Function: CThreadSafeQueue<CRequest*, (CRequest*)0, 100u>::notifyProducerStopped()
void CThreadSafeQueue<T, defVal, TArraySize>::notifyProducerStopped() {
	mutex_m.lock();
	activeProducers_m--;
	mutex_m.unlock();
	if ( activeProducers_m == 0 )
		disable();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x328, %rdi            # imm = 0x328
callq 0x2b990
movq -0x10(%rbp), %rdi
movq 0x390(%rdi), %rax
addq $-0x1, %rax
movq %rax, 0x390(%rdi)
addq $0x328, %rdi            # imm = 0x328
callq 0x2b9e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x390(%rax)
jne 0x213b9
movq -0x10(%rbp), %rdi
callq 0x23030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: metopa[P]HTTP_Server/src/threads/CThreadPool.h
// Function: CThreadPool::CThreadPool<std::shared_ptr<CRunnable>>(std::shared_ptr<CRunnable> const&, void* (*)(void*))
CThreadPool( const T& e, void * (* func)( void * ) = CRunnable::threadRunner ) {
		pthread_attr_t attr;
		pthread_attr_init( &attr );
		pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
		int retCode;

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

		pthread_attr_destroy( &attr );
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x232f0
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x65f0
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0x66d0
movq -0x78(%rbp), %rdi
movq $0x0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x23310
jmp 0x2150d
movq -0x88(%rbp), %rdi
callq 0x23340
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23380
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
movq %rax, %rcx
leaq -0x50(%rbp), %rsi
callq 0x6960
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
je 0x2159d
movq -0x88(%rbp), %rdi
callq 0x233b0
leaq 0x1e177(%rip), %rdi     # 0x3f6e0
leaq 0xb33f(%rip), %rdx      # 0x2c8af
movl $0x1, %esi
leaq -0x6d(%rbp), %rcx
leaq -0x54(%rbp), %r8
callq 0x233e0
jmp 0x21584
jmp 0x2159d
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x21cd0
jmp 0x215af
leaq -0x50(%rbp), %rdi
callq 0x6890
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6920
nopl (%rax,%rax)
// File: metopa[P]HTTP_Server/src/threads/CThreadPool.h
// Function: CThreadPool::CThreadPool<__gnu_cxx::__normal_iterator<std::shared_ptr<CRunnable>*, std::vector<std::shared_ptr<CRunnable>, std::allocator<std::shared_ptr<CRunnable>>>>>(__gnu_cxx::__normal_iterator<std::shared_ptr<CRunnable>*, std::vector<std::shared_ptr<CRunnable>, std::allocator<std::shared_ptr<CRunnable>>>> const&, __gnu_cxx::__normal_iterator<std::shared_ptr<CRunnable>*, std::vector<std::shared_ptr<CRunnable>, std::allocator<std::shared_ptr<CRunnable>>>> const&, void* (*)(void*))
CThreadPool( const InputIterator& beginIter, const InputIterator& endIter,
				 void * (* func)( void * ) = CRunnable::threadRunner ) {
		pthread_attr_t attr;
		pthread_attr_init( &attr );
		pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
		int retCode;

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

		pthread_attr_destroy( &attr );
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x232f0
leaq -0x58(%rbp), %rdi
callq 0x65f0
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x66d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x23de0
testb $0x1, %al
jne 0x21680
jmp 0x2174e
movq -0x90(%rbp), %rdi
movq $0x0, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x23310
jmp 0x2169a
movq -0x90(%rbp), %rdi
callq 0x23340
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x22ea0
movq %rax, %rdi
callq 0x23380
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
leaq -0x58(%rbp), %rsi
callq 0x6960
movl %eax, -0x5c(%rbp)
cmpl $0x0, %eax
je 0x21735
movq -0x90(%rbp), %rdi
callq 0x233b0
leaq 0x1dfe2(%rip), %rdi     # 0x3f6e0
leaq 0xb1aa(%rip), %rdx      # 0x2c8af
movl $0x1, %esi
leaq -0x7d(%rbp), %rcx
leaq -0x5c(%rbp), %r8
callq 0x233e0
jmp 0x21719
jmp 0x21735
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x21cd0
jmp 0x21760
jmp 0x21737
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x23e20
movq %rax, -0x88(%rbp)
jmp 0x2166a
leaq -0x58(%rbp), %rdi
callq 0x6890
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x6920
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
xorl %esi, %esi
callq 0x24b50
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
callq 0x241c0
movq -0x70(%rbp), %rdx
movl %eax, %edi
movq %rdx, %rsi
addq $0x8, %rsi
addq $0x88, %rdx
callq 0x61c0
movq -0x70(%rbp), %rdi
movl %eax, (%rdi)
cmpl $-0x1, (%rdi)
jne 0x2438e
movb $0x1, -0x62(%rbp)
movl $0x50, %edi
callq 0x6280
movq %rax, -0x90(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6930
movq -0x88(%rbp), %rdx
leaq 0x87a6(%rip), %rsi      # 0x2ca27
leaq -0x28(%rbp), %rdi
callq 0xa9d0
jmp 0x2428c
callq 0x6080
movl (%rax), %edi
callq 0x61f0
movq %rax, -0xa0(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x6930
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0xa9d0
jmp 0x242c8
movq -0x78(%rbp), %rdi
movl 0xc(%rdi), %eax
movl %eax, -0xa8(%rbp)
addq $0x8, %rdi
callq 0x241c0
movl %eax, -0xa4(%rbp)
jmp 0x242e6
movl -0xa4(%rbp), %r8d
movl -0xa8(%rbp), %ecx
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x24b70
jmp 0x24309
movq -0x90(%rbp), %rdi
movb $0x0, -0x62(%rbp)
leaq 0x1a535(%rip), %rsi     # 0x3e850
leaq 0x73e(%rip), %rdx       # 0x24a60
callq 0x68e0
jmp 0x243c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2436f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2435d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6310
leaq -0x61(%rbp), %rdi
callq 0x6550
leaq -0x28(%rbp), %rdi
callq 0x6310
leaq -0x29(%rbp), %rdi
callq 0x6550
testb $0x1, -0x62(%rbp)
jne 0x24380
jmp 0x2438c
movq -0x90(%rbp), %rdi
callq 0x63b0
jmp 0x243bf
movq -0x70(%rbp), %r8
movq -0x78(%rbp), %rdx
addq $0xc, %rdx
leaq 0x1b33f(%rip), %rdi     # 0x3f6e0
movl $0x5, %esi
leaq 0x8683(%rip), %rcx      # 0x2ca30
callq 0x24bc0
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6920
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x62c0
movq -0xb0(%rbp), %rcx
movl $0x0, -0x3c(%rbp)
movl $0x1, -0x38(%rbp)
movl $0x1, -0x40(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq -0x40(%rbp), %rdx
callq 0x6650
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
je 0x24575
movq -0xb0(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0xa2(%rbp)
movl $0x50, %edi
callq 0x6280
movq %rax, -0xc0(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6930
movq -0xb8(%rbp), %rdx
leaq 0x85d8(%rip), %rsi      # 0x2ca53
leaq -0x68(%rbp), %rdi
callq 0xa9d0
jmp 0x24486
movl -0x44(%rbp), %edi
callq 0x6740
movq %rax, -0xd0(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x6930
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0xa9d0
jmp 0x244c4
movq -0xc0(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0x68(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x24a00
jmp 0x244e7
movq -0xc0(%rbp), %rdi
movb $0x0, -0xa2(%rbp)
leaq 0x1a354(%rip), %rsi     # 0x3e850
leaq 0x55d(%rip), %rdx       # 0x24a60
callq 0x68e0
jmp 0x24587
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x24553
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2453e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x6310
leaq -0xa1(%rbp), %rdi
callq 0x6550
leaq -0x68(%rbp), %rdi
callq 0x6310
leaq -0x69(%rbp), %rdi
callq 0x6550
testb $0x1, -0xa2(%rbp)
jne 0x24567
jmp 0x24573
movq -0xc0(%rbp), %rdi
callq 0x63b0
jmp 0x2457e
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x6920
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $-0x2, 0x4c(%rax)
jne 0x2503e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, -0x28(%rbp)
jmp 0x24f70
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x64c0
movq %rax, -0x38(%rbp)
jmp 0x24f83
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x65b0
movq %rax, -0x40(%rbp)
jmp 0x24f97
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x6460
movq %rax, -0x48(%rbp)
jmp 0x24fae
movq -0x48(%rbp), %rdi
leaq 0x7b29(%rip), %rsi      # 0x2cae2
callq 0x64c0
movq %rax, -0x50(%rbp)
jmp 0x24fc4
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x6900
movq %rax, -0x58(%rbp)
jmp 0x24fda
movq -0x58(%rbp), %rdi
movl $0x28, %esi
callq 0x65b0
movq %rax, -0x60(%rbp)
jmp 0x24fee
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %esi
callq 0x6900
movq %rax, -0x68(%rbp)
jmp 0x25004
movq -0x68(%rbp), %rdi
leaq 0x73a7(%rip), %rsi      # 0x2c3b6
callq 0x64c0
movq %rax, -0x70(%rbp)
jmp 0x2501a
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
callq 0x6460
movq %rax, -0x78(%rbp)
jmp 0x25031
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25128
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, -0x80(%rbp)
jmp 0x2505c
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x64c0
movq %rax, -0x90(%rbp)
jmp 0x25075
movq -0x90(%rbp), %rdi
movl $0x20, %esi
callq 0x65b0
movq %rax, -0x98(%rbp)
jmp 0x2508f
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x6460
movq %rax, -0xa0(%rbp)
jmp 0x250ac
movq -0xa0(%rbp), %rdi
leaq 0x7a28(%rip), %rsi      # 0x2cae2
callq 0x64c0
movq %rax, -0xa8(%rbp)
jmp 0x250c8
movq -0xa8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x6900
movq %rax, -0xb0(%rbp)
jmp 0x250e4
movq -0xb0(%rbp), %rdi
leaq 0x72c5(%rip), %rsi      # 0x2c3b7
callq 0x64c0
movq %rax, -0xb8(%rbp)
jmp 0x25100
movq -0xb8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
callq 0x6460
movq %rax, -0xc0(%rbp)
jmp 0x2511d
movq -0xc0(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb060
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2589e
movq -0x98(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x6290
movq %rax, -0x28(%rbp)
callq 0x6080
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x2588d
cmpl $0x4, -0x2c(%rbp)
jne 0x25749
jmp 0x256fa
movq -0x98(%rbp), %rax
movl (%rax), %edi
callq 0x69e0
movb $0x1, -0x8a(%rbp)
movl $0x50, %edi
callq 0x6280
movq %rax, -0xa8(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6930
movq -0xa0(%rbp), %rdx
leaq 0x7379(%rip), %rsi      # 0x2cb06
leaq -0x50(%rbp), %rdi
callq 0xa9d0
jmp 0x25798
movl -0x2c(%rbp), %edi
callq 0x61f0
movq %rax, -0xb8(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6930
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0xa9d0
jmp 0x257d6
movq -0xa8(%rbp), %rdi
movq -0x98(%rbp), %rax
movl (%rax), %r8d
movl 0x4(%rax), %ecx
leaq -0x50(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x25da0
jmp 0x257fc
movq -0xa8(%rbp), %rdi
movb $0x0, -0x8a(%rbp)
leaq 0x19207(%rip), %rsi     # 0x3ea18
leaq 0x5d8(%rip), %rdx       # 0x25df0
callq 0x68e0
jmp 0x258d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2586b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x25856
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6310
leaq -0x89(%rbp), %rdi
callq 0x6550
leaq -0x50(%rbp), %rdi
callq 0x6310
leaq -0x51(%rbp), %rdi
callq 0x6550
testb $0x1, -0x8a(%rbp)
jne 0x2587f
jmp 0x2588b
movq -0xa8(%rbp), %rdi
callq 0x63b0
jmp 0x258ca
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x256fa
movq -0x98(%rbp), %rcx
addq $0x4, %rcx
leaq 0x19e30(%rip), %rdi     # 0x3f6e0
movl $0x5, %esi
leaq 0x7251(%rip), %rdx      # 0x2cb0d
callq 0x25e10
addq $0xc0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6920
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
callq 0x66c0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movq -0x50(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x41(%rbp)
jae 0x27bfe
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6580
movsbl (%rax), %eax
movsbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x27c07
jmp 0x27c14
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x27bba
jmp 0x27c16
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x27c92
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6580
movsbl (%rax), %eax
movsbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
jne 0x27c64
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x28, %rsi
callq 0x6250
jmp 0x27ca3
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
movl %eax, %eax
movl %eax, %esi
callq 0x6580
movq -0x30(%rbp), %rdi
movb (%rax), %al
addq $0x28, %rdi
movsbl %al, %esi
callq 0x6320
jmp 0x27c16
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x28, %rsi
callq 0x6250
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: metopa[P]HTTP_Server/src/requests/EMethodType.cpp
// Function: methodTypeNS::methodToString(EMethodType)
const char * methodTypeNS::methodToString( EMethodType e ) {
	switch ( e ) {
		case RT_GET:
			return "GET";
		case RT_HEAD:
			return "HEAD";
		case RT_OPTIONS:
			return "OPTIONS";
		case RT_ALL:
			return "ALL";
		default:
			return "UNSUPPORTED";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x27ecc
movq -0x18(%rbp), %rax
leaq 0x4de9(%rip), %rcx      # 0x2cc78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ded(%rip), %rax      # 0x2cc8c
movq %rax, -0x8(%rbp)
jmp 0x27ed7
leaq 0x4de4(%rip), %rax      # 0x2cc90
movq %rax, -0x8(%rbp)
jmp 0x27ed7
leaq 0x4f0f(%rip), %rax      # 0x2cdc8
movq %rax, -0x8(%rbp)
jmp 0x27ed7
leaq 0x48d1(%rip), %rax      # 0x2c797
movq %rax, -0x8(%rbp)
jmp 0x27ed7
leaq 0x4dc2(%rip), %rax      # 0x2cc95
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x27f30
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x27e70
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x16f30
testb $0x1, %al
jne 0x27f1b
jmp 0x27f23
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x27f37
jmp 0x27f25
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x27ef3
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0xc8, %eax
je 0x27fae
jmp 0x27f5a
movl -0x18(%rbp), %eax
subl $0x190, %eax            # imm = 0x190
je 0x27fbb
jmp 0x27f66
movl -0x18(%rbp), %eax
subl $0x193, %eax            # imm = 0x193
je 0x27fc8
jmp 0x27f72
movl -0x18(%rbp), %eax
subl $0x194, %eax            # imm = 0x194
je 0x27fd5
jmp 0x27f7e
movl -0x18(%rbp), %eax
subl $0x195, %eax            # imm = 0x195
je 0x27fe2
jmp 0x27f8a
movl -0x18(%rbp), %eax
subl $0x199, %eax            # imm = 0x199
je 0x27fef
jmp 0x27f96
movl -0x18(%rbp), %eax
subl $0x1f5, %eax            # imm = 0x1F5
je 0x27ffc
jmp 0x27fa2
movl -0x18(%rbp), %eax
subl $0x1f7, %eax            # imm = 0x1F7
je 0x28009
jmp 0x28016
leaq 0x4d14(%rip), %rax      # 0x2ccc9
movq %rax, -0x8(%rbp)
jmp 0x28021
leaq 0x4d0a(%rip), %rax      # 0x2cccc
movq %rax, -0x8(%rbp)
jmp 0x28021
leaq 0x4d09(%rip), %rax      # 0x2ccd8
movq %rax, -0x8(%rbp)
jmp 0x28021
leaq 0x4d06(%rip), %rax      # 0x2cce2
movq %rax, -0x8(%rbp)
jmp 0x28021
leaq 0x4d03(%rip), %rax      # 0x2ccec
movq %rax, -0x8(%rbp)
jmp 0x28021
leaq 0x4d09(%rip), %rax      # 0x2ccff
movq %rax, -0x8(%rbp)
jmp 0x28021
leaq 0x4d05(%rip), %rax      # 0x2cd08
movq %rax, -0x8(%rbp)
jmp 0x28021
leaq 0x4d08(%rip), %rax      # 0x2cd18
movq %rax, -0x8(%rbp)
jmp 0x28021
leaq 0x4d0f(%rip), %rax      # 0x2cd2c
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x66e0
movq -0x1a8(%rbp), %rdi
leaq 0x3aa1(%rip), %rsi      # 0x2cd51
callq 0x64c0
movq %rax, -0x1a0(%rbp)
jmp 0x292be
movq -0x1a0(%rbp), %rdi
movq -0x1b0(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x6900
movq %rax, -0x1c8(%rbp)
jmp 0x292dd
movq -0x1c8(%rbp), %rdi
movl $0x20, %esi
callq 0x65b0
movq %rax, -0x1d0(%rbp)
jmp 0x292f7
movq -0x1b0(%rbp), %rdi
movl 0x50(%rdi), %esi
callq 0x27f40
movq %rax, -0x1d8(%rbp)
jmp 0x2930f
movq -0x1d8(%rbp), %rsi
movq -0x1d0(%rbp), %rdi
callq 0x64c0
movq %rax, -0x1e0(%rbp)
jmp 0x2932b
movq -0x1e0(%rbp), %rdi
leaq 0x1621f(%rip), %rax     # 0x3f558
movq (%rax), %rsi
callq 0x64c0
jmp 0x29343
leaq 0x3a11(%rip), %rsi      # 0x2cd5b
leaq -0x188(%rbp), %rdi
callq 0x64c0
movq %rax, -0x1e8(%rbp)
jmp 0x2935f
movq -0x1b0(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, -0x1f0(%rbp)
jmp 0x2937c
movq -0x1f0(%rbp), %rsi
movq -0x1e8(%rbp), %rdi
callq 0x64c0
movq %rax, -0x1f8(%rbp)
jmp 0x29398
movq -0x1f8(%rbp), %rdi
leaq 0x161b2(%rip), %rax     # 0x3f558
movq (%rax), %rsi
callq 0x64c0
jmp 0x293b0
leaq 0x39ff(%rip), %rsi      # 0x2cdb6
leaq -0x188(%rbp), %rdi
callq 0x64c0
movq %rax, -0x200(%rbp)
jmp 0x293cc
movq -0x200(%rbp), %rdi
leaq 0x1617e(%rip), %rax     # 0x3f558
movq (%rax), %rsi
callq 0x64c0
jmp 0x293e4
leaq 0x1616d(%rip), %rax     # 0x3f558
movq (%rax), %rsi
leaq -0x188(%rbp), %rdi
callq 0x64c0
jmp 0x293fc
movq -0x1c0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x64f0
jmp 0x29411
leaq -0x188(%rbp), %rdi
callq 0x6140
movq -0x1b8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x6140
movq -0x190(%rbp), %rdi
callq 0x6920
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6630
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x67f0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x67f0
movq -0x8(%rbp), %rdi
movl $0xf, %esi
callq 0x67f0
movq -0x8(%rbp), %rdi
movl $0xd, %esi
callq 0x67f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x88(%rbp), %rdi
callq 0x294b0
leaq -0x88(%rbp), %rdi
movl $0xa, %esi
callq 0x67f0
leaq -0x88(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0x61d0
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x62c0
leaq -0x38(%rip), %rax       # 0x29590
movq %rax, -0xa0(%rbp)
movl -0x4(%rbp), %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x6640
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
addq $0x8, %rcx
leaq 0x1603b(%rip), %rdi     # 0x3f6e0
movl $0x9, %esi
leaq 0x3733(%rip), %rdx      # 0x2cde4
leaq 0x378e(%rip), %r8       # 0x2ce46
callq 0x29890
movl $0x0, -0xc(%rbp)
movq -0xd0(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xe0(%rbp)
movl $0xa0, %edi
callq 0x64d0
movq %rax, -0xd8(%rbp)
jmp 0x296e9
movq -0xd0(%rbp), %rsi
addq $0x10, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x241f0
jmp 0x29702
leaq -0xb8(%rbp), %rdi
callq 0x29a20
movl %eax, -0xe4(%rbp)
jmp 0x29716
movq -0xd0(%rbp), %rdi
addq $0x10, %rdi
callq 0x249e0
movl %eax, -0xe8(%rbp)
jmp 0x2972e
movl -0xe8(%rbp), %edx
movl -0xe4(%rbp), %esi
movq -0xd8(%rbp), %rdi
callq 0x26170
jmp 0x29748
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x29960
movb %al, -0xe9(%rbp)
jmp 0x2976b
movb -0xe9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x29779
jmp 0x297cd
jmp 0x297db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x297a6
movq -0xd8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xa0, %esi
callq 0x64e0
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x29863
movq -0x20(%rbp), %rdi
callq 0x6230
movq %rax, -0xc0(%rbp)
callq 0x6880
jmp 0x297db
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x296c4
movq -0xd0(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x21360
movq -0xd0(%rbp), %rcx
addq $0x20, %rcx
leaq 0x15ee3(%rip), %rdi     # 0x3f6e0
movl $0x2, %esi
leaq 0x35eb(%rip), %rdx      # 0x2cdf4
leaq -0xc1(%rbp), %r8
leaq 0x2efb(%rip), %r9       # 0x2c712
leaq -0xc2(%rbp), %r10
leaq -0xc(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x29a30
movq -0xd0(%rbp), %rcx
addq $0x8, %rcx
leaq 0x15e9e(%rip), %rdi     # 0x3f6e0
movl $0x9, %esi
leaq 0x3596(%rip), %rdx      # 0x2cde4
leaq 0x35bf(%rip), %r8       # 0x2ce14
callq 0x29b20
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6920
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x370, %rdi            # imm = 0x370
callq 0x2ba50
movq -0x20(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
callq 0x2b990
movq -0x20(%rbp), %rax
testb $0x1, 0x398(%rax)
je 0x299c7
movq -0x20(%rbp), %rdi
addq $0x370, %rdi            # imm = 0x370
callq 0x2ba70
movq -0x20(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
callq 0x2b9e0
movb $0x0, -0x1(%rbp)
jmp 0x29a14
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movl 0x320(%rdi), %eax
movq %rcx, (%rdi,%rax,8)
movl 0x320(%rdi), %eax
addl $0x1, %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, 0x320(%rdi)
addq $0x328, %rdi            # imm = 0x328
callq 0x2b9e0
movq -0x20(%rbp), %rdi
addq $0x350, %rdi            # imm = 0x350
callq 0x2ba70
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x15575(%rip), %rdi     # 0x3f6e0
movl $0x9, %esi
leaq 0x2cc1(%rip), %rdx      # 0x2ce38
callq 0x2a1c0
callq 0x29540
movl %eax, -0xc(%rbp)
leaq 0x15555(%rip), %rdi     # 0x3f6e0
movl $0x1, %esi
leaq 0x2cc4(%rip), %rdx      # 0x2ce5b
leaq -0xc(%rbp), %rcx
leaq 0x2cc0(%rip), %r8       # 0x2ce62
callq 0x2a280
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23030
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
cltq
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdx
callq 0x6380
cmpl $0x0, %eax
sete %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x350, %rdi            # imm = 0x350
callq 0x2ba50
movq -0x20(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
callq 0x2b990
movq -0x20(%rbp), %rax
testb $0x1, 0x398(%rax)
je 0x2ac7f
movq -0x20(%rbp), %rcx
movl 0x324(%rcx), %eax
cmpl 0x320(%rcx), %eax
je 0x2accf
movq -0x20(%rbp), %rdi
movl 0x324(%rdi), %eax
movq (%rdi,%rax,8), %rax
movq %rax, -0x18(%rbp)
movl 0x324(%rdi), %eax
addl $0x1, %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, 0x324(%rdi)
addq $0x328, %rdi            # imm = 0x328
callq 0x2b9e0
movq -0x20(%rbp), %rdi
addq $0x370, %rdi            # imm = 0x370
callq 0x2ba70
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2acf7
movq -0x20(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
callq 0x2b9e0
movq -0x20(%rbp), %rdi
addq $0x350, %rdi            # imm = 0x350
callq 0x2ba70
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x110(%rbp)
movq %rdi, %r10
movq %r10, -0x108(%rbp)
testb %al, %al
je 0x350f
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x32b0
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x31a0
cmpl $0x0, %eax
jge 0x3598
movq 0x7a5b(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x4d0c(%rip), %rsi      # 0x8293
movb $0x0, %al
callq 0x32e0
movl $0x1, %edi
callq 0x3250
movq -0x110(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x32a0
jmp 0x35aa
movq -0x20(%rbp), %rdi
callq 0x3240
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x35e5
jmp 0x35d9
movq -0x110(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3110
jmp 0x35f5
movq -0x110(%rbp), %rdi
callq 0x3110
movq -0x108(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3370
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x6, -0x1c(%rbp)
jge 0x496f
movq -0x18(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3080
cltq
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x493f
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x32b0
movl $0x2a, -0x20(%rbp)
cmpl $0x2a, -0x20(%rbp)
ja 0x4e21
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rax
movb -0x20(%rbp), %cl
shrq %cl, %rax
movzbl %al, %edx
leaq -0x40(%rbp), %rdi
callq 0x4e50
jmp 0x4dd9
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3280
jmp 0x4de8
leaq -0x40(%rbp), %rdi
callq 0x3110
movl -0x20(%rbp), %eax
subl $0x6, %eax
movl %eax, -0x20(%rbp)
jmp 0x4db7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4e3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3110
jmp 0x4e3e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4e34
movq -0x68(%rbp), %rdi
callq 0x3110
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3110
movq -0x48(%rbp), %rdi
callq 0x3370