LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::load(int, char**)
void CConfig::load( int argc, char * argv[] ) {
	const char * iniFile;
	if ( argc > 1 )
		iniFile = argv[1];
	else
		iniFile = DEFAULT_INIFILE;

	ifstream ifile( iniFile );
	if ( !ifile.is_open() )
		throw FileNotFoundException( iniFile, MSG_CRIT_ERR );

	ini_struct_t defVals;
	loadDefVals( defVals );
	parse( CParserINI( ifile, defVals ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, %rbx
cmpl $0x2, %esi
jge 0x5ba2
leaq 0x1c890(%rip), %rdx     # 0x22430
jmp 0x5ba6
addq $0x8, %rdx
movq (%rdx), %r14
leaq 0xb8(%rsp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5770
leaq 0x130(%rsp), %rdi
callq 0x50f0
testb %al, %al
je 0x5c88
leaq 0x10(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x8(%rsp), %rsi
callq 0x5d94
leaq 0x38(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x9fdc
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x86a2
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x64ec
leaq 0x88(%rsp), %rdi
callq 0x8c36
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c5b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x38(%rsp), %rdi
callq 0x8c36
leaq 0x8(%rsp), %rdi
callq 0x8c36
leaq 0xb8(%rsp), %rdi
callq 0x5110
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbx
popq %r14
popq %rbp
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x7bea
leaq 0x1c77a(%rip), %rax     # 0x22428
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x7bea
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x857a
leaq 0x1b734(%rip), %rax     # 0x21410
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1b6b8(%rip), %rsi     # 0x213a0
leaq 0x1f39(%rip), %rdx      # 0x7c28
movq %rbx, %rdi
callq 0x5700
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d1d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x5d1d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d40
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x5d40
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5d7f
movq %rbx, %rdi
callq 0x52e0
jmp 0x5d7f
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x8c36
jmp 0x5d64
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x7c6a
jmp 0x5d75
jmp 0x5d72
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8c36
leaq 0xb8(%rsp), %rdi
callq 0x5110
movq %r14, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: operator<<(std::ostream&, CConfig&)
ostream& operator <<( ostream& out, CConfig& c ) {
	out << "Ports:";
	for ( auto it = c.getPorts().begin(); it != c.getPorts().end(); it++ ) {
		out << ' ' << *it;
	}
	out << endl;

	out << "Working directory: " << c.getWorkDir() << endl;

	out << "Logger flags:";
	for ( int i = 0; i < E_LOG_FLAGS_MAX; i++ )
		if ( c.logFlags_m[i] )
			out << ' ' << logflagsNS::logFlagsToString( (ELogFlags) i );

	out << endl;
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x11780(%rip), %rsi     # 0x18061
movl $0x6, %edx
callq 0x5450
movq 0x18(%r14), %r12
cmpq 0x20(%r14), %r12
je 0x692a
leaq 0x6(%rsp), %r15
movb $0x20, 0x6(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5450
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rax, %rdi
callq 0x5450
addq $0x20, %r12
cmpq 0x20(%r14), %r12
jne 0x68fa
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
leaq 0x11710(%rip), %rsi     # 0x18068
movl $0x13, %edx
movq %rbx, %rdi
callq 0x5450
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x5450
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
leaq 0x116d6(%rip), %rsi     # 0x1807c
movl $0xd, %edx
movq %rbx, %rdi
callq 0x5450
xorl %r15d, %r15d
leaq 0x7(%rsp), %r12
cmpb $0x1, (%r14,%r15)
jne 0x6a1d
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5450
movq %rax, %r13
movl %r15d, %edi
callq 0x11084
testq %rax, %rax
je 0x6a02
movq %rax, %rbp
movq %rax, %rdi
callq 0x51f0
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x6a1d
movq (%r13), %rax
movq -0x18(%rax), %rax
movq %r13, %rdi
addq %rax, %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x56f0
incq %r15
cmpq $0xc, %r15
jne 0x69bb
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::parseMapper(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>>>&)
void CConfig::parseMapper( map<string, map<string, vector<string>>>::iterator& data ) {
	for ( auto it = data->second.begin(); it != data->second.end(); it++ )
		fileMapping_m.push_back( make_pair( it->first, it->second.front() ) );

	auto comp = []( const pair<string, string>& a, const pair<string, string>& b ) -> bool {
		return a.first.length() > b.first.length();
	};

	sort( fileMapping_m.begin(), fileMapping_m.end(), comp );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, (%rsp)
movq (%rsi), %rax
movq 0x58(%rax), %r15
addq $0x48, %rax
cmpq %rax, %r15
je 0x717c
movq %rsi, %r14
movq (%rsp), %rax
leaq 0x78(%rax), %r12
leaq 0x38(%rsp), %rbp
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r13
leaq 0x20(%r15), %rsi
movq 0x40(%r15), %rdx
movq %r13, %rdi
callq 0x8e06
movq %r12, %rdi
movq %r13, %rsi
callq 0x92dc
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x714e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x7165
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %r15, %rdi
callq 0x52a0
movq %rax, %r15
movq (%r14), %rax
addq $0x48, %rax
cmpq %rax, %r15
jne 0x711c
movq (%rsp), %rax
movq 0x78(%rax), %r14
movq 0x80(%rax), %rbx
cmpq %rbx, %r14
je 0x71ee
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x6, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x738d
cmpq $0x401, %r15            # imm = 0x401
jl 0x71e3
leaq 0x400(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7a09
cmpq %rbx, %r15
je 0x71ee
movq %r15, %rdi
callq 0x7ad6
addq $0x40, %r15
jmp 0x71d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a09
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x812e
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::parseExec(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>>>&)
void CConfig::parseExec( map<string, map<string, vector<string>>>::iterator& data ) {
	auto it = data->second.find( "regular_exe_ext" );
	if ( it != data->second.end() ) {
		regExeExt_m.insert( it->second.begin(), it->second.end() );
	}
	it = data->second.find( "script_exe_ext" );
	if ( it != data->second.end() ) {
		scriptExeExt_m.insert( it->second.begin(), it->second.end() );
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x10efa(%rip), %rsi     # 0x18134
leaq 0x10f02(%rip), %rdx     # 0x18143
movq %rsp, %rdi
callq 0x8f0e
addq $0x40, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x95a8
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7271
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq (%r14), %rax
addq $0x48, %rax
cmpq %rax, %r15
je 0x72c8
movq %r14, 0x20(%rsp)
leaq 0x90(%rbx), %r12
movq 0x40(%r15), %r13
movq 0x48(%r15), %r14
movq %r12, (%rsp)
cmpq %r14, %r13
je 0x72be
leaq 0x98(%rbx), %r15
movq %rsp, %rbp
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x95ee
addq $0x20, %r13
cmpq %r14, %r13
jne 0x72a4
movq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r12
movq (%r14), %r15
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x10e6c(%rip), %rsi     # 0x18144
leaq 0x10e73(%rip), %rdx     # 0x18152
callq 0x8f0e
addq $0x40, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x95a8
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x730c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq (%r14), %rax
addq $0x48, %rax
cmpq %rax, %r15
je 0x7354
leaq 0xc0(%rbx), %r14
movq 0x40(%r15), %r12
movq 0x48(%r15), %r13
movq %r14, (%rsp)
cmpq %r13, %r12
je 0x7354
addq $0xc8, %rbx
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x95ee
addq $0x20, %r12
cmpq %r13, %r12
jne 0x733a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7367
jmp 0x7382
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7385
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x7385
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void CParserINI::parseLine( string& line ) {
	unsigned int pos = 0;
	skipWS( line, pos );
	if ( pos == line.size() )
		return;

	switch ( line[pos] ) {
		case ';':
		case '#':
			return;
		case '[':
			parseNewBlock( line, pos );
			return;
		default:
			string id = getID( line, pos );
			vector<string> args = getArgs( line, pos );
			addParam( id, args );
			return;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xa181
movq (%r14), %rdx
xorl %ecx, %ecx
movl 0xc(%rsp), %esi
movzbl (%rdx,%rcx), %edi
cmpl $0x20, %edi
je 0xa170
cmpl $0x9, %edi
jne 0xa17b
incl %ecx
movl %ecx, %esi
cmpq %rcx, %rax
ja 0xa162
jmp 0xa17d
movl %esi, %ecx
movl %ecx, 0xc(%rsp)
movl 0xc(%rsp), %ecx
cmpq %rcx, %rax
jne 0xa197
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movzbl (%rax,%rcx), %eax
cmpl $0x23, %eax
je 0xa18a
cmpl $0x3b, %eax
je 0xa18a
cmpl $0x5b, %eax
jne 0xa1bf
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa382
jmp 0xa18a
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %r15
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xa4dc
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xa5d0
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x8e7e
leaq 0x50(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x8048
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0xa2da
leaq 0x50(%rsp), %rdi
callq 0x80d2
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xa24c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x68(%rsp), %rdi
callq 0x80d2
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa18a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xa18a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x80d2
jmp 0xa28c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xa2a8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xa2a8
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x80d2
jmp 0xa2b7
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa2d2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::parseNewBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
void CParserINI::parseNewBlock( string& line, unsigned int& pos ) {
	string newBlock( "" );
	pos++;
	for ( ; pos < line.size() && isValidArgChar( line[pos] ); pos++ )
		newBlock.insert( newBlock.end(), line[pos] );
	if ( pos == line.size() )
		throw INIParserException( "End of line reached (']' expected)" );
	if ( line[pos] != ']' )
		throw INIParserException( "Unrecognized symbol (']' expected): ", line[pos] );

	currentBlock = newBlock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xeb24(%rip), %rdx      # 0x18ecc
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x8f0e
movl (%r14), %eax
incl %eax
movl %eax, (%r14)
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jbe 0xa40e
movq (%rbx), %rdx
movb (%rdx,%rax), %dl
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
jb 0xa3f4
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
setae %sil
cmpb $0x5f, %dl
setne %dil
testb %sil, %dil
jne 0xa40e
movq 0x8(%rsp), %rsi
movsbl %dl, %r8d
movl $0x1, %ecx
movq %r12, %rdi
xorl %edx, %edx
callq 0x5790
jmp 0xa3b6
cmpq %rax, %rcx
je 0xa44f
movq (%rbx), %rcx
cmpb $0x5d, (%rcx,%rax)
jne 0xa46d
addq $0x30, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x5250
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa441
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r15
leaq 0xde55(%rip), %rsi      # 0x182b8
movq %rax, %rdi
callq 0xaad8
jmp 0xa493
movl $0x48, %edi
callq 0x5200
movq %rax, %r15
movl (%r14), %eax
movq (%rbx), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xde50(%rip), %rsi      # 0x182db
movq %r15, %rdi
callq 0xac78
leaq 0x1702e(%rip), %rsi     # 0x214c8
leaq -0x249b(%rip), %rdx     # 0x8006
movq %r15, %rdi
callq 0x5700
jmp 0xa4ab
movq %rax, %rbx
movq %r15, %rdi
callq 0x52e0
jmp 0xa4bd
jmp 0xa4ba
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa4d3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::getID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
string CParserINI::getID( string& line, unsigned int& pos ) {
	string id = getIdentifier( line, pos );
	skipWS( line, pos );
	if ( pos == line.size() )
		throw INIParserException( "End of line reached ('=' expected)" );
	if ( line[pos++] != '=' )
		throw INIParserException( "Unrecognized symbol ('=' expected): ", line[pos] );
	return id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
callq 0xa69e
movq 0x8(%r14), %rax
movl (%r15), %esi
cmpq %rsi, %rax
jbe 0xa51e
movq (%r14), %rcx
leal 0x1(%rsi), %edx
movzbl (%rcx,%rsi), %esi
cmpl $0x20, %esi
je 0xa512
cmpl $0x9, %esi
jne 0xa51e
movl %edx, (%r15)
movl %edx, %esi
incl %edx
cmpq %rsi, %rax
ja 0xa504
movl (%r15), %ecx
cmpq %rcx, %rax
je 0xa544
leal 0x1(%rcx), %eax
movl %eax, (%r15)
movq (%r14), %rax
cmpb $0x3d, (%rax,%rcx)
jne 0xa562
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r12
leaq 0xdda8(%rip), %rsi      # 0x18300
movq %rax, %rdi
callq 0xaad8
jmp 0xa588
movl $0x48, %edi
callq 0x5200
movq %rax, %r12
movl (%r15), %eax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xdda3(%rip), %rsi      # 0x18323
movq %r12, %rdi
callq 0xac78
leaq 0x16f39(%rip), %rsi     # 0x214c8
leaq -0x2590(%rip), %rdx     # 0x8006
movq %r12, %rdi
callq 0x5700
jmp 0xa5a0
movq %rax, %r14
movq %r12, %rdi
callq 0x52e0
jmp 0xa5b0
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xa5c7
movq (%rbx), %rsi
incq %rsi
callq 0x53f0
movq %r14, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::getArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
vector<string> CParserINI::getArgs( string& line, unsigned int& pos ) {
	vector<string> args;
	while ( 1 ) {
		args.push_back( getIdentifier( line, pos ) );
		if ( !getComma( line, pos ) )
			break;
	}

	return args;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xa69e
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb0f4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa62b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %r15, %rsi
movq %r14, %rdx
callq 0xa86e
testb %al, %al
jne 0xa5fc
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xa668
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa66b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xa66b
movq %rax, %r14
movq %rbx, %rdi
callq 0x80d2
movq %r14, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::getComma(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
bool CParserINI::getComma( string& line, unsigned int& pos ) {
	skipWS( line, pos );
	if ( pos == line.size() || line[pos] == ';' || line[pos] == '#' )
		return false;
	if ( line[pos] != ',' )
		throw INIParserException( "Unrecognized symbol (',' expected): ", line[pos] );
	pos++;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
movl (%rdx), %esi
cmpq %rsi, %rax
jbe 0xa8a3
movq (%r14), %rcx
leal 0x1(%rsi), %edx
movzbl (%rcx,%rsi), %esi
cmpl $0x20, %esi
je 0xa898
cmpl $0x9, %esi
jne 0xa8a3
movl %edx, (%rbx)
movl %edx, %esi
incl %edx
cmpq %rsi, %rax
ja 0xa88a
movl (%rbx), %ecx
cmpq %rcx, %rax
jne 0xa8ae
xorl %eax, %eax
jmp 0xa907
movq (%r14), %rax
movzbl (%rax,%rcx), %edx
xorl %eax, %eax
cmpl $0x23, %edx
je 0xa907
cmpl $0x2c, %edx
je 0xa901
cmpl $0x3b, %edx
je 0xa907
movl $0x48, %edi
callq 0x5200
movq %rax, %r15
movl (%rbx), %eax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xdace(%rip), %rsi      # 0x183b1
movq %r15, %rdi
callq 0xac78
leaq 0x16bd6(%rip), %rsi     # 0x214c8
leaq -0x28f3(%rip), %rdx     # 0x8006
movq %r15, %rdi
callq 0x5700
incl %ecx
movl %ecx, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/config/../logger/CLogger.h
// Function: void CLogger::ger<char [28], int, char [6], INIParserException>(ELogFlags, char const (&) [28], int const&, char const (&) [6], INIParserException const&)
void ger( ELogFlags level, const Args& ... args ) {
		if ( !initialized_m || config.checkLogFlag( level ) ) {
			mutex_m.lock();
			printTimestamp();
			*logStream_m << '\t' << logflagsNS::logFlagsToStringPrintable( level ) << ' ';
			print( args... );
			*logStream_m << endl;
			mutex_m.unlock();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %rbp
movl %esi, %r13d
movq %rdi, %r15
cmpb $0x1, 0x3c(%rdi)
jne 0xa97d
leaq 0x17b5b(%rip), %rdi     # 0x224c8
movl %r13d, %esi
callq 0x6848
testb %al, %al
je 0xaac9
movq %rbx, 0x8(%rsp)
leaq 0x10(%r15), %rdi
movq %rdi, 0x10(%rsp)
callq 0x17b62
movq %r15, %rdi
callq 0x10b00
movq (%r15), %rdi
leaq 0x3(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
callq 0x5450
movq %rax, %rbx
movl %r13d, %edi
callq 0x1109f
testq %rax, %rax
je 0xa9d8
movq %rax, %r13
movq %rax, %rdi
callq 0x51f0
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0xa9f1
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x56f0
movb $0x20, %r13b
leaq 0x4(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5450
movq (%r15), %rbx
movq %rbp, %rdi
callq 0x51f0
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x5450
movq (%r15), %rdi
leaq 0x5(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
callq 0x5450
movq (%r15), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
callq 0x5710
movq (%r15), %rdi
leaq 0x6(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
callq 0x5450
movq (%r15), %rbx
movq %r12, %rdi
callq 0x51f0
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x5450
movq (%r15), %rdi
leaq 0x7(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
callq 0x5450
movq (%r15), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r15), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
movq 0x10(%rsp), %rdi
callq 0x17b76
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CAbstractContent.cpp
// Function: CAbstractContent::creationTime()
void CAbstractContent::creationTime() {
	time_t ltime;
	tm result;

	ltime = time( NULL );
	localtime_r( &ltime, &result );
	asctime_r( &result, createTime_m );

	for ( int i = 1; i < 32; i++ )
		if ( !createTime_m[i] ) {
			createTime_m[i - 1] = 0;
			break;
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x5390
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x5220
leaq 0x68(%rbx), %rsi
movq %r14, %rdi
callq 0x5070
cmpb $0x0, 0x69(%rbx,%r15)
je 0xb4e0
incq %r15
cmpq $0x1f, %r15
jne 0xb4cd
jmp 0xb4e6
movb $0x0, 0x68(%rbx,%r15)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CDirContent.cpp
// Function: CDirContent::makeLink(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CDirContent::makeLink( const string& path ) {
	if ( userPath_m.back() == '/' )
		return userPath_m + path;
	else if ( path == "." )
		return userPath_m;
	else
		return userPath_m + '/' + path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
jne 0xbc76
addq $0x20, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc233
jmp 0xbd47
leaq 0xca2a(%rip), %rsi      # 0x186a7
movq %r14, %rdi
callq 0x5150
testl %eax, %eax
je 0xbcf7
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8e7e
movq 0x8(%r15), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x2f, %r8d
callq 0x5790
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5160
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xbd13
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xbd19
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x8e7e
jmp 0xbd47
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xbd47
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xbd58
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xbd72
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CDirContent.cpp
// Function: CDirContent::modificationTime()
void CDirContent::modificationTime() {
	struct stat attr;
	stat( realPath_m.c_str(), &attr );
	ctime_r( &attr.st_mtime, modTime_m );

	for ( int i = 1; i < 32; i++ )
		if ( !modTime_m[i] ) {
			modTime_m[i - 1] = 0;
			break;
		}
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movq %rsp, %rsi
callq 0x5380
leaq 0x58(%rsp), %rdi
leaq 0x88(%rbx), %rsi
callq 0x5470
xorl %eax, %eax
cmpb $0x0, 0x89(%rbx,%rax)
je 0xbdb9
incq %rax
cmpq $0x1f, %rax
jne 0xbda4
jmp 0xbdc1
movb $0x0, 0x88(%rbx,%rax)
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CExternalContent.cpp
// Function: CExternalContent::load()
void CExternalContent::load() {
	exec();
	if ( wrapNeeded_m )
		rawData_m = CHTMLGenerator( rawData_m ).substituteNL().wrap( userPath_m );
	data_m.insert( data_m.begin(), rawData_m.begin(), rawData_m.end() );
	size_m = data_m.size();
	creationTime();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0xe158
cmpb $0x1, 0xc8(%rbx)
jne 0xe0f5
leaq 0xa8(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xed5c
movq %r15, %rdi
callq 0xfde2
leaq 0x20(%rbx), %rdx
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xfea2
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x54a0
movq (%r15), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xe0da
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe0f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0xa8(%rbx), %rdx
movq 0xb0(%rbx), %rcx
addq %rdx, %rcx
callq 0xddb6
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0xb498
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe14f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CExternalContent.cpp
// Function: CExternalContent::exec()
void CExternalContent::exec() {
	int dataPipe[2];
	pipe( dataPipe );

	int chPID;
	if ( ( chPID = fork() ) == -1 ) {
		int errNo = errno;
		Log.ger<>( CRITICAL, "fork() failed, errno", errNo );
		close( dataPipe[0] );
		close( dataPipe[1] );
		throw InternalErrorException( realPath_m ); //TODO add args
	}

	if ( chPID == 0 ) {
		close( dataPipe[0] );
		dup2( dataPipe[1], STDOUT_FILENO );

		if ( isScript_m )
			exit( system( realPath_m.c_str() ) );
		else {
			execl( realPath_m.c_str(), realPath_m.c_str(), (char *) nullptr );
			exit( 127 );
		}
	}
	else {
		close( dataPipe[1] );
		readPipe( dataPipe[0] );
		close( dataPipe[0] );
		int rc;
		waitpid( chPID, &rc, 0 );
		if ( rc == 127 )
			throw PermissionDeniedException( realPath_m );
		if ( rc != 0 )
			throw ServiceUnavailableException( realPath_m );
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rdi
callq 0x5580
callq 0x5120
testl %eax, %eax
je 0xe1f1
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xe225
movl 0x8(%rsp), %edi
callq 0x57c0
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xe2ee
movl 0x4(%rsp), %edi
callq 0x57c0
leaq 0xc(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5310
movl (%r14), %eax
testl %eax, %eax
jne 0xe1c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x7f, %eax
jne 0xe289
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbf3a
leaq 0x133b4(%rip), %rsi     # 0x215a0
jmp 0xe280
movl 0x4(%rsp), %edi
callq 0x57c0
movl 0x8(%rsp), %edi
movl $0x1, %esi
callq 0x53a0
movq 0x40(%rbx), %rdi
cmpb $0x1, 0xc9(%rbx)
jne 0xe2bb
callq 0x5330
movl %eax, %edi
callq 0x5480
callq 0x5060
movl (%rax), %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x1438e(%rip), %rdi     # 0x225c8
leaq 0xa2c8(%rip), %rdx      # 0x18509
movl $0x1, %esi
callq 0xe3c8
movl 0x4(%rsp), %edi
callq 0x57c0
movl 0x8(%rsp), %edi
callq 0x57c0
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe4fa
leaq 0x13440(%rip), %rsi     # 0x216c0
leaq -0x665f(%rip), %rdx     # 0x7c28
jmp 0xe2b3
movl $0x28, %edi
callq 0x5200
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe546
leaq 0x1342c(%rip), %rsi     # 0x216d8
leaq 0x2bf(%rip), %rdx       # 0xe572
movq %r14, %rdi
callq 0x5700
movq %rdi, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x54b0
movl $0x7f, %edi
callq 0x5480
jmp 0xe2d5
jmp 0xe2d5
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CExternalContent.cpp
// Function: CExternalContent::readPipe(int)
void CExternalContent::readPipe( int fd ) {
	uint8_t buf[1024];
	ssize_t bytesRecvd;
	int errNo;

	while ( 1 ) {
		bytesRecvd = read( fd, buf, sizeof( buf ) );
		errNo = errno;
		if ( bytesRecvd == 0 )
			break;
		else if ( bytesRecvd < 0 ) {
			if ( errNo == EINTR )
				continue;
			else
				throw InternalErrorException( realPath_m );
		}

		rawData_m.insert( rawData_m.end(), buf, buf + bytesRecvd );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x400, %edx            # imm = 0x400
movl %ebp, %edi
callq 0x55c0
movq %rax, %r13
callq 0x5060
testq %r13, %r13
je 0xe371
movq %rax, %r14
leaq 0xa8(%rbx), %r15
movq %rsp, %r12
testq %r13, %r13
js 0xe354
movq 0xa8(%rbx), %rdx
addq 0xb0(%rbx), %rdx
leaq (%rsp,%r13), %r8
movq %r15, %rdi
movq %rdx, %rsi
movq %r12, %rcx
callq 0xe70e
jmp 0xe35a
cmpl $0x4, (%r14)
jne 0xe383
movl $0x400, %edx            # imm = 0x400
movl %ebp, %edi
movq %r12, %rsi
callq 0x55c0
movq %rax, %r13
testq %rax, %rax
jne 0xe32d
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe4fa
leaq 0x1331a(%rip), %rsi     # 0x216c0
leaq -0x6785(%rip), %rdx     # 0x7c28
movq %r14, %rdi
callq 0x5700
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CHTMLGenerator.cpp
// Function: CHTMLGenerator::enlarge(int)
CHTMLGenerator& CHTMLGenerator::enlarge( int sizeDelta ) {
	char buf[10];
	sprintf( buf, "%d", 6 + sizeDelta * 2 );
	applyAttr( "font", "size=" + string( buf ) );
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leal 0x6(%rsi,%rsi), %edx
leaq 0x8481(%rip), %rsi      # 0x180ec
leaq 0x6e(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x50d0
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8944(%rip), %rsi      # 0x185ce
leaq 0x8941(%rip), %rdx      # 0x185d2
leaq 0x48(%rsp), %rdi
callq 0x8f0e
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x51f0
leaq (%rsp,%rax), %rdx
addq $0x6e, %rdx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x8f0e
leaq 0x890a(%rip), %rcx      # 0x185d3
leaq 0x28(%rsp), %rdi
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5440
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xfd04
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xfd0b
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xf1aa
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfd4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xfd62
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xfd79
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfda7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xfda7
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xfdc3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xfdc3
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xfdda
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CHTMLGenerator.cpp
// Function: CHTMLGenerator::substituteNL()
CHTMLGenerator& CHTMLGenerator::substituteNL() {
	unsigned long int n = 0;
	string htmlNL = "<br>";
	while ( ( n = data_m.find( '\n', n ) ) != data_m.npos ) {
		data_m.insert( n, htmlNL );
		n += htmlNL.size() + 1;
	}
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x87db(%rip), %rsi      # 0x185d9
leaq 0x87d8(%rip), %rdx      # 0x185dd
movq %rsp, %rdi
callq 0x8f0e
movq %rbx, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x5530
cmpq $-0x1, %rax
je 0xfe5d
movq %rax, %r14
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5440
movq 0x8(%rsp), %rax
leaq (%r14,%rax), %rdx
incq %rdx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x5530
movq %rax, %r14
cmpq $-0x1, %rax
jne 0xfe25
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xfe73
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xfe99
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CHTMLGenerator.cpp
// Function: CHTMLGenerator::wrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CHTMLGenerator::wrap( const string& title ) {
	return "<html>\n"
				   "  <head>\n"
				   "    <title>" + title + "</title>\n"
				   "  </head>\n"
				   "  <body>\n      " +
		   data_m + "\n"
				   "  </body>\n"
				   "</html>";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8726(%rip), %rsi      # 0x185de
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x1010c
leaq 0x872e(%rip), %rsi      # 0x185fa
movq %r15, %rdi
callq 0x57b0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xfefa
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0xff01
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x5160
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xff4e
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0xff55
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x86a5(%rip), %rsi      # 0x1861d
callq 0x57b0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xff9f
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xffa5
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0xffd3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xffe9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10004
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x10030
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x10030
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1004b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x1004b
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10066
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CPathResolver.cpp
// Function: CPathResolver::unwindPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CPathResolver::unwindPath( const string& path ) {
	int depth = 0;
	int state = 0;
	for ( unsigned long int i = 0; i < path.length() && depth >= 0; i++ ) {
		switch ( state ) {
			case 0:
				if ( path[i] == '.' )
					state = 2;
				else if ( path[i] == '/' )
					state = 0;
				else state = 1;
				break;
			case 1:
				if ( path[i] == '/' ) {
					state = 0;
					depth++;
				}
				break;
			case 2:
				if ( path[i] == '.' )
					state = 3;
				else if ( path[i] == '/' )
					state = 0;
				else state = 1;
				break;
			case 3:
				if ( path[i] == '.' ) {
					state = 0;
					depth--;
				}
				else state = 1;
				break;
			default:
				break;
		}
	}
	if ( depth < 0 )
		throw PermissionDeniedException( path );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x1023a
movq %rsi, %rbx
movq (%rsi), %rdx
xorl %ecx, %ecx
movl $0x1, %esi
movb -0x1(%rdx,%rsi), %r9b
movl %ecx, %r8d
leaq 0x846f(%rip), %rdi      # 0x18630
movslq (%rdi,%r8,4), %r8
addq %rdi, %r8
jmpq *%r8
incq %rsi
movb -0x1(%rdx,%rsi), %r9b
movl %r8d, %r8d
movslq (%rdi,%r8,4), %r8
addq %rdi, %r8
jmpq *%r8
movl $0x2, %r8d
jmp 0x1021c
xorl %r10d, %r10d
xorl %r8d, %r8d
cmpb $0x2e, %r9b
sete %r10b
setne %r8b
subl %r10d, %ecx
jmp 0x1022d
xorl %r10d, %r10d
xorl %r8d, %r8d
cmpb $0x2f, %r9b
sete %r10b
setne %r8b
addl %r10d, %ecx
jmp 0x1022d
movl $0x3, %r8d
cmpb $0x2e, %r9b
je 0x1022d
xorl %r8d, %r8d
cmpb $0x2f, %r9b
setne %r8b
cmpq %rax, %rsi
jae 0x10236
testl %ecx, %ecx
jns 0x101cb
testl %ecx, %ecx
js 0x10242
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbf3a
leaq 0x1133f(%rip), %rsi     # 0x215a0
leaq -0x8640(%rip), %rdx     # 0x7c28
movq %r14, %rdi
callq 0x5700
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CPathResolver.cpp
// Function: CPathResolver::substitutePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string CPathResolver::substitutePath( string& path ) {
	for ( auto it = config.getFileMappings().begin(); it != config.getFileMappings().end(); it++ )
		if ( partialCompare( path, it->first ) ) {
			if ( it->second == "-" )
				throw PermissionDeniedException( path );
			else
				return it->second + path.substr( it->first.length() );
		}
	return config.getWorkDir() + path;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x1222b(%rip), %r15     # 0x224c8
movq %r15, %rdi
callq 0x68c4
movq (%rax), %r12
movq %r15, %rdi
callq 0x68c4
cmpq 0x8(%rax), %r12
sete %bpl
je 0x1031e
leaq 0x12207(%rip), %r15     # 0x224c8
movq 0x8(%r12), %rax
cmpq %rax, 0x8(%rbx)
jb 0x10308
testq %rax, %rax
sete %cl
je 0x10304
movq (%rbx), %rcx
movq (%r12), %rdx
movb (%rcx), %sil
cmpb (%rdx), %sil
jne 0x10308
movl $0x1, %edi
movq %rdi, %rsi
cmpq %rdi, %rax
je 0x102fe
movb (%rcx,%rsi), %r8b
leaq 0x1(%rsi), %rdi
cmpb (%rdx,%rsi), %r8b
je 0x102e8
cmpq %rax, %rsi
setae %cl
testb %cl, %cl
jne 0x10348
addq $0x40, %r12
movq %r15, %rdi
callq 0x68c4
cmpq 0x8(%rax), %r12
sete %bpl
jne 0x102c1
leaq 0x121a3(%rip), %rdi     # 0x224c8
callq 0x68b2
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xc233
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%r12), %rdi
leaq 0x82ec(%rip), %rsi      # 0x18640
callq 0x5150
testl %eax, %eax
je 0x103fa
movq 0x8(%r12), %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x5400
movq 0x20(%r12), %rcx
movq 0x28(%r12), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5440
leaq 0x10(%r14), %rdx
movq %rdx, (%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x103b3
movq %rsi, (%r14)
movq (%rcx), %rdx
movq %rdx, 0x10(%r14)
jmp 0x103b9
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x103eb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
testb $0x1, %bpl
jne 0x1031e
jmp 0x10338
movl $0x48, %edi
callq 0x5200
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbf3a
leaq 0x11187(%rip), %rsi     # 0x215a0
leaq -0x87f8(%rip), %rdx     # 0x7c28
movq %r14, %rdi
callq 0x5700
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
jmp 0x10453
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10453
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CPathResolver.cpp
// Function: CPathResolver::getExt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CPathResolver::getExt( const string& path ) {
	unsigned long int slash = path.find_last_of( '/' );
	unsigned long int dot = path.find_last_of( '.' );
	if ( dot > slash )
		return path.substr( dot + 1 );
	else
		return string();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x57d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x57d0
cmpq %r15, %rax
jbe 0x104f7
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x5400
jmp 0x1050a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/content/CStringContent.cpp
// Function: CStringContent::load()
void CStringContent::load() {
	string rawHtml = CHTMLGenerator( msg_m ).enlarge( 2 ).wrap( msg_m );
	size_m = rawHtml.size();
	data_m.insert( data_m.begin(), rawHtml.begin(), rawHtml.end() );
	creationTime();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xed5c
movq %r15, %rdi
movl $0x2, %esi
callq 0xfc52
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xfea2
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1082d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x10(%rsp), %rcx
movq %rcx, 0x60(%rbx)
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
addq %rdx, %rcx
callq 0xddb6
movq %rbx, %rdi
callq 0xb498
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1086e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1087a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x108b0
movq 0x18(%rsp), %rsi
jmp 0x108a8
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x108b0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5730
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::CLogger()
CLogger::CLogger() {
	logStream_m = &cerr;
	logStreamIsCOUT = true;
	pid_m = getpid();
	initialized_m = false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x17b54
movq 0x116a4(%rip), %rax     # 0x21ff0
movq %rax, (%rbx)
movb $0x1, 0x8(%rbx)
callq 0x55f0
movl %eax, 0x38(%rbx)
movb $0x0, 0x3c(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::~CLogger()
CLogger::~CLogger() {
	logStream_m->flush();
	if ( !logStreamIsCOUT ) {
		delete logStream_m;
		logStream_m = nullptr;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5290
cmpb $0x0, 0x8(%rbx)
jne 0x10989
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10982
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x17b5c
movq %rax, %rdi
callq 0x7db2
// File: /workspace/github_cpp_makefile_star2_O1/metopa[P]HTTP_Server/src/logger/CLogger.cpp
// Function: CLogger::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CLogger::init( const string& logFile ) {
	if ( logFile == "stdout" ) {
		logStreamIsCOUT = true;
		logStream_m = &cout;
	}
	else {
		logStreamIsCOUT = false;
		ofstream * lfile = new ofstream( logFile.c_str() );
		if ( !lfile->is_open() ) {
			delete lfile;
			throw FileNotFoundException( logFile.c_str(), MSG_CRIT_ERR );
		}
		logStream_m = lfile;
	}
	initialized_m = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7706(%rip), %rsi      # 0x180bb
movq %r14, %rdi
callq 0x5150
testl %eax, %eax
je 0x10a72
movb $0x0, 0x8(%rbx)
movl $0x200, %edi            # imm = 0x200
callq 0x53e0
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movl $0x10, %edx
callq 0x5420
movq %r15, %rdi
addq $0x70, %rdi
callq 0x50f0
testb %al, %al
jne 0x10a7d
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movl $0x48, %edi
callq 0x5200
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7bea
leaq 0x119ff(%rip), %rax     # 0x22428
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x7bea
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x857a
leaq 0x109b9(%rip), %rax     # 0x21410
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1093d(%rip), %rsi     # 0x213a0
leaq -0x8e42(%rip), %rdx     # 0x7c28
movq %rbx, %rdi
callq 0x5700
movb $0x1, 0x8(%rbx)
movq 0x11553(%rip), %r15     # 0x21fd0
movq %r15, (%rbx)
movb $0x1, 0x3c(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10ab5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x10ab5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10ad8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x10ad8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x10af7
movq %rbx, %rdi
callq 0x52e0
jmp 0x10af7
movq %rax, %r14
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
callq 0x53f0
movq %r14, %rdi
callq 0x5730
nop