LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::findSplit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
string findSplit (string &s,
                  char c)
{
	const size_t pos = s. find (c);
	if (pos == string::npos)
	{
		const string s1 (s);
		s. clear ();
		return s1;
	}
	const string before (s. substr (0, pos));
	s. erase (0, pos + 1);
	return before;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xa740
cmpq $-0x1, %rax
je 0x39220
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xa5d0
incq %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xa100
jmp 0x39247
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c212
movq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x3926a
movq (%rbx), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::rfindSplit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
string rfindSplit (string &s,
                   char c)
{
	const size_t pos = s. rfind (c);
	if (pos == string::npos)
	{
		const string s1 (s);
		s. clear ();
		return s1;
	}
	const string after (s. substr (pos + 1));
	s. erase (pos);
	return after;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
movq $-0x1, %rdx
callq 0xab00
cmpq $-0x1, %rax
je 0x392c2
movq %rax, %r15
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0xa5d0
movq 0x8(%r14), %rcx
cmpq %r15, %rcx
jb 0x392f2
movq %r15, 0x8(%r14)
movq (%r14), %rax
addq %r15, %rax
jmp 0x392e6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c212
movq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x55bfb(%rip), %rdi     # 0x8eef4
leaq 0x55c42(%rip), %rsi     # 0x8ef42
movq %r15, %rdx
xorl %eax, %eax
callq 0xa890
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x39324
movq (%rbx), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::str2list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
List<string> str2list (const string &s,
                       char c) 
{
	List<string> res;
	string s1 (s);
	while (! s1. empty ())
	  res << std::move (findSplit (s1, c));
	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x2c212
cmpq $0x0, 0x30(%rsp)
je 0x39be7
leaq 0x18(%rsp), %r13
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x391de
movl $0x30, %edi
callq 0xa590
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdx
cmpq %r13, %rdx
je 0x39b91
movq %rdx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x39b99
movups (%r13), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %r13, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa090
incq 0x10(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x39bdb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpq $0x0, 0x30(%rsp)
jne 0x39b56
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x39bfe
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x39c4b
movq %rax, %r14
jmp 0x39c34
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x39c34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x39c4b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0x2f9d4
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::list2str(Common_sp::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string list2str (const List<string> &strList,
                 const string &sep) 
{
	string s;
	bool first = true;
	for (const string& e : strList)
	{
    if (! first)
			s += sep;
	  s += e;
	  first = false;
	}
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movb $0x1, %bpl
movq %rsi, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x39cba
testb $0x1, %bpl
jne 0x39ca6
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa190
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xa190
jmp 0x39c88
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x39ce3
movq (%r12), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::concatTextDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void concatTextDir (const string &inDirName,
                    const string &outFName)
{
  RawDirItemGenerator dig (0, inDirName, false);
  OFStream outF (outFName);
  string item;
  while (dig. next (item))
    copyText (inDirName + "/" + item, 0, outF);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp            # imm = 0x2E8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x51554
leaq 0xe8(%rsp), %rdi
movq %r14, %rsi
callq 0x2e7fc
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x58(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x48(%rsp), %r12
leaq 0x8(%rsp), %rbp
leaq 0xe8(%rsp), %r13
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3bc26
testb %al, %al
je 0x3bb3a
movq %r14, 0x48(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x2c212
movq %r12, %rdi
leaq 0x51833(%rip), %rsi     # 0x8d2d0
callq 0xaac0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0xa190
movq %r15, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3bad7
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x3bade
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x3ab79
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3bb1a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ba65
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x3ba65
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3bb56
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x72ee3(%rip), %rax     # 0xaea40
leaq 0x1e0(%rsp), %rbx
movq %rax, -0xf8(%rbx)
leaq 0x72ef5(%rip), %rax     # 0xaea68
movq %rax, (%rbx)
leaq 0xf0(%rsp), %rdi
callq 0xa4b0
movq %rbx, %rdi
callq 0xa1c0
leaq 0x68(%rsp), %rdi
callq 0x5169e
addq $0x2e8, %rsp            # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3bc14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3bbcf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x3bbcf
jmp 0x3bbcc
jmp 0x3bbe8
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x3bbeb
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x3bbeb
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3bc07
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0xe8(%rsp), %rdi
callq 0x2e8ce
leaq 0x68(%rsp), %rdi
callq 0x5169e
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::readLine(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void readLine (istream &is,
               string &s)
{
  s. clear ();
  for (;;)
  {	
    char c;
    if (! getChar (is, c))
      break;
	  if (c == '\n')  // UNIX
	  	break;
	  s += c;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rsi)
movq (%rsi), %rax
movb $0x0, (%rax)
leaq 0xf(%rsp), %rsi
callq 0x3e63c
testb %al, %al
je 0x3ed72
leaq 0xf(%rsp), %r15
movb 0xf(%rsp), %al
cmpb $0xa, %al
je 0x3ed72
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa4d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e63c
testb %al, %al
jne 0x3ed50
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::StringVector::toString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string StringVector::toString (const string& sep) const
{ 
//ASSERT (! sep. empty ());
  
  string res;
  for (const string& s : *this)
  { 
    if (! res. empty ())
      res += sep;
    res += s;
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x4015c
movq %rdx, %r14
cmpq $0x0, 0x8(%rbx)
je 0x40142
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa190
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xa190
addq $0x20, %r12
cmpq %r13, %r12
jne 0x4012c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4017f
movq (%r15), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Threads::Threads(unsigned long, bool)
Threads::Threads (size_t threadsToStart_arg, 
                  bool quiet_arg)
{ 
  if (! isMainThread ())
	  throw logic_error ("Threads are started not from the main thread");
  if (! empty ())
	  throw logic_error ("Previous threads have not finished");

	threadsToStart = threadsToStart_arg;
	if (threadsToStart >= threads_max)
		throw logic_error ("Too many threads to start");
		
  quiet = quiet_arg;
		
	threads. reserve (threadsToStart);
	
	if (! quiet && verbose (1) && threadsToStart)
	{
    const OColor c (cerr, Color::green, false, true);  // Cf. Progress::report() 
    cerr << "# Threads started: " << threadsToStart + 1/*main thread*/ << endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x649aa
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x6fe4c(%rip), %r15     # 0xb05b8
cmpq $0x1, %r15
je 0x40784
callq 0xa500
cmpq 0x7034a(%rip), %rax     # 0xb0ac8
jne 0x408c6
cmpq $0x0, 0x70374(%rip)     # 0xb0b00
jne 0x4088a
movq %r14, 0x70367(%rip)     # 0xb0b00
cmpq %r14, %r15
jbe 0x408a8
movb %bpl, 0x7035f(%rip)     # 0xb0b08
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64a18
cmpb $0x0, 0x7034d(%rip)     # 0xb0b08
jne 0x4087f
movb $0x1, %al
cmpq $0x1, 0x6fded(%rip)     # 0xb05b8
je 0x407dc
callq 0xa500
cmpq 0x702ef(%rip), %rax     # 0xb0ac8
sete %al
testb %al, %al
je 0x4087f
cmpl $0x0, 0x70321(%rip)     # 0xb0b0c
js 0x4087f
cmpq $0x0, 0x70307(%rip)     # 0xb0b00
je 0x4087f
movq 0x6f7da(%rip), %rsi     # 0xaffe0
leaq 0x8(%rsp), %rdi
movl $0x20, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2f4e2
movq 0x6f7bc(%rip), %rdi     # 0xaffe0
leaq 0x4c9fd(%rip), %rsi     # 0x8d228
movl $0x13, %edx
callq 0xa640
movq 0x702c4(%rip), %rsi     # 0xb0b00
incq %rsi
movq 0x6f79a(%rip), %rdi     # 0xaffe0
callq 0xa3e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xa570
movsbl %al, %esi
movq %r14, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3f0
leaq 0x8(%rsp), %rdi
callq 0x2f5bc
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x4c94d(%rip), %rsi     # 0x8d1eb
movq %rax, %rdi
callq 0xa7f0
jmp 0x408e2
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x4c952(%rip), %rsi     # 0x8d20e
movq %rax, %rdi
callq 0xa7f0
jmp 0x408e2
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x4c8e4(%rip), %rsi     # 0x8d1be
movq %rax, %rdi
callq 0xa7f0
movq 0x6f6d7(%rip), %rsi     # 0xaffc0
movq 0x6f698(%rip), %rdx     # 0xaff88
movq %r14, %rdi
callq 0xa9b0
jmp 0x4091a
jmp 0x408fe
jmp 0x408fe
movq %rax, %r15
movq %r14, %rdi
callq 0xa440
jmp 0x4091d
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x2f5bc
jmp 0x4091d
movq %rax, %r15
movq %rbx, %rdi
callq 0x64ac4
movb $0x0, 0x70255(%rip)     # 0xb0b81
movq %r15, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Threads::~Threads()
Threads::~Threads ()
{ 
  {
    Progress prog (threads. size () + 1, ! quiet);
    const string step ("consecutive threads finished");
    prog (step);  // Main thread
    for (auto& t : threads) 
    { 
      t. join ();
      prog (step);
  	}
  }
	  
	threads. clear ();
	threadsToStart = 0;
	quiet = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x3, %rsi
incq %rsi
movzbl 0x701ae(%rip), %edx     # 0xb0b08
xorq $0x1, %rdx
leaq 0x28(%rsp), %rdi
callq 0x434f4
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4c8c4(%rip), %rsi     # 0x8d23c
leaq 0x4c8d9(%rip), %rdx     # 0x8d258
leaq 0x8(%rsp), %rdi
callq 0x2fa1a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x40a4e
movq (%rbx), %r14
movq 0x8(%rbx), %rbp
cmpq %rbp, %r14
je 0x409ca
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
callq 0xa9a0
movq %r15, %rdi
movq %r12, %rsi
callq 0x40a4e
addq $0x8, %r14
cmpq %rbp, %r14
jne 0x409ae
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x409e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x28(%rsp), %rdi
callq 0x436fc
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x40a0d
movq %rax, %rdx
cmpq $0x0, (%rdx)
jne 0x40a3f
addq $0x8, %rdx
cmpq %rcx, %rdx
jne 0x409fa
movq %rax, 0x8(%rbx)
movq $0x0, 0x700e8(%rip) # 0xb0b00
xorl %ebp, %ebp
movb %bpl, 0x700e7(%rip)     # 0xb0b08
movq %rbx, %rdi
callq 0x64ac4
movb %bpl, 0x70151(%rip)     # 0xb0b81
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa150
jmp 0x40a46
movq %rax, %rdi
callq 0x2c2a7
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Progress::operator() (const string& step_arg)
{ 
	n++;
	step = step_arg;
	if (   active 
		  && n % displayPeriod == 0
		 )
	{ 
		report ();
	  return true;
	}
	return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
incq 0x18(%rdi)
addq $0x20, %rdi
callq 0xa320
cmpb $0x1, 0x8(%rbx)
jne 0x40a82
movq 0x18(%rbx), %rax
xorl %ecx, %ecx
xorl %edx, %edx
divq 0x10(%rbx)
testq %rdx, %rdx
jne 0x40a84
movq %rbx, %rdi
callq 0x43576
movb $0x1, %cl
jmp 0x40a84
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Xml::TextFile::printRawText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Xml::TextFile::printRawText (const string &s) 
{ 
	string res;  res. reserve (s. size ());
	for (const char c : s)
		switch (c)
		{
			case '<': res += "&lt;"; break;
			case '>': res += "&gt;"; break;
			case '&': res += "&amp;"; break;
			default:  res += c;
		}
	printRaw (res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
movq %rsp, %rdi
callq 0xa8d0
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x40b1e
movq (%r14), %r13
xorl %ebp, %ebp
leaq 0x4c78b(%rip), %r15     # 0x8d25e
movq %rsp, %r14
leaq 0x4c77c(%rip), %rbx     # 0x8d259
movzbl (%r13,%rbp), %eax
cmpl $0x26, %eax
je 0x40afa
movq %r15, %rsi
cmpl $0x3e, %eax
je 0x40b01
cmpl $0x3c, %eax
jne 0x40b0b
movq %rbx, %rsi
jmp 0x40b01
leaq 0x4c762(%rip), %rsi     # 0x8d263
movq %r14, %rdi
callq 0xaac0
jmp 0x40b16
movsbl %al, %esi
movq %r14, %rdi
callq 0xa4d0
incq %rbp
cmpq %rbp, %r12
jne 0x40add
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xa640
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x40b50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40b61
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x40b7f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Root::saveFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void visualizeTrailingSpaces (string &s)
{
	size_t spaces = 0;
	while (   ! s. empty ()
	       && s. back () == ' '
	      )
	{
		s. erase (s. size () - 1);
		spaces++;
	}
	FFOR (size_t, i, spaces)
	  s += nonPrintable2str (' ');
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
cmpq $0x0, 0x8(%rsi)
je 0x424a9
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e7fc
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rax)
leaq 0x6c5c2(%rip), %rax     # 0xaea40
leaq 0x100(%rsp), %rbx
movq %rax, -0xf8(%rbx)
leaq 0x6c5d4(%rip), %rax     # 0xaea68
movq %rax, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0xa4b0
movq %rbx, %rdi
callq 0xa1c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2e8ce
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Named::qc() const
void Named::qc () const
{
  if (! qc_on)
    return;
  Root::qc ();
    
  if (! goodName (name))
    throw runtime_error (FUNC "Bad name: " + strQuote (name));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
cmpb $0x1, 0x6e5e0(%rip)     # 0xb0ac0
jne 0x42519
movq %rdi, %r14
movq 0x10(%rdi), %rax
addq $0x8, %r14
testq %rax, %rax
je 0x42529
movq (%r14), %rcx
cmpb $0x20, (%rcx)
je 0x42529
cmpb $0x20, -0x1(%rcx,%rax)
je 0x42529
xorl %edx, %edx
movb (%rcx,%rdx), %sil
addb $-0x20, %sil
cmpb $0x5f, %sil
jae 0x42529
incq %rdx
cmpq %rdx, %rax
jne 0x42503
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4aeec(%rip), %rsi     # 0x8d432
leaq 0x4af0e(%rip), %rdx     # 0x8d45b
movq %rsp, %rdi
callq 0x2fa1a
leaq 0x4af00(%rip), %rsi     # 0x8d45c
movq %rsp, %rdi
callq 0xaac0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x42587
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x42594
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38a3a
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2d152
movb $0x1, %bpl
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x6d9fd(%rip), %rsi     # 0xaffe8
movq 0x6d96e(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42620
movq 0x70(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x42620
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42643
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x42643
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x4265a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x42670
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x42695
jmp 0x4269d
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x42695
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x42695
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::StringVector::StringVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, bool)
StringVector::StringVector (const string &s,
                            char sep,
                            bool trimP)
{
	string s1 (s);
	while (! s1. empty ())
	  *this << std::move (findSplit (s1, sep));
	if (! s. empty () && s. back () == sep)
	  *this << noString;
	  
	if (trimP)
	  for (string& member : *this)
	    trim (member);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x4(%rsp)
movl %edx, (%rsp)
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rdi)
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2c212
cmpq $0x0, 0x10(%rsp)
je 0x42c25
leaq 0x38(%rsp), %r14
movsbl (%rsp), %r12d
leaq 0x28(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movl %r12d, %edx
callq 0x391de
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2fc7a
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x42c06
movb $0x0, 0x18(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x42c1d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpq $0x0, 0x10(%rsp)
jne 0x42bdc
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x42c5a
movq (%r15), %rcx
movl (%rsp), %edx
cmpb %dl, -0x1(%rcx,%rax)
jne 0x42c5a
leaq 0x6de97(%rip), %rsi     # 0xb0ad8
movq %rbx, %rdi
callq 0x309da
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x42c5a
movb $0x0, 0x18(%rbx)
cmpb $0x0, 0x4(%rsp)
je 0x42c83
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x42c83
movq %r14, %rdi
callq 0x37275
movq %r14, %rdi
callq 0x384ed
addq $0x20, %r14
jmp 0x42c68
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x42c9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42cb7
movq %rax, %r15
jmp 0x42cf2
jmp 0x42cb7
movq %rax, %r15
jmp 0x42cd6
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x42cd6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x42cf2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0x327d2
movq %r15, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::DisjointCluster::merge(Common_sp::DisjointCluster&)
void DisjointCluster::merge (DisjointCluster &other)
// Trying to keep rank's small
{ 
  if (this == & other)
    return;
  DisjointCluster* root1 =        getDisjointCluster ();
  DisjointCluster* root2 = other. getDisjointCluster ();
	if (root1->rankDC > root2->rankDC)
		root2->parentDC = root1;
	else
	{
		root1->parentDC = root2;
		if (root1->rankDC == root2->rankDC)
			root2->rankDC ++;
	}
}

// Assembly:
cmpq %rsi, %rdi
je 0x431e2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x431e4
movq %rax, %rbx
movq %r14, %rdi
callq 0x431e4
movq 0x8(%rbx), %rcx
cmpq 0x8(%rax), %rcx
jbe 0x431cf
movq %rbx, (%rax)
jmp 0x431db
movq %rax, (%rbx)
jne 0x431db
incq %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::Progress(unsigned long, unsigned long)
Progress::Progress (size_t n_max_arg,
	                  size_t displayPeriod_arg)
: n_max (n_max_arg)
, active (enabled () && displayPeriod_arg && (! n_max_arg || displayPeriod_arg <= n_max_arg))
, displayPeriod (displayPeriod_arg)
{ 
	if (active) 
	  beingUsed++; 
	if (active)
	  report ();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
callq 0x64b90
testq %r14, %r14
setne %cl
andb %al, %cl
testq %r15, %r15
sete %al
cmpq %r15, %r14
setbe %dl
orb %al, %dl
leaq 0x30(%rbx), %r15
xorl %eax, %eax
andb %cl, %dl
movb %dl, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movb $0x0, 0x30(%rbx)
je 0x43550
incq 0x6d5d0(%rip)           # 0xb0b18
movq %rbx, %rdi
callq 0x43576
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rbx), %rdi
cmpq %r15, %rdi
je 0x4356d
movq (%r15), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::report() const
void Progress::report () const
{ 
  if (! n)
    return;
  cerr << '\r';
#ifndef _MSC_VER
  cerr << "\033[2K";
  const OColor c (cerr, Color::green, false, true);  // PAR
#endif
  cerr << n; 
	if (n_max)
		cerr << " / " << n_max;
	if (! step. empty ())
		cerr << ' ' << step;
	cerr << ' ';
	if (! Threads::empty () && ! contains (step, "thread"))
	  cerr << "(main thread) ";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpq $0x0, 0x18(%rdi)
je 0x436dc
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movb $0xd, (%rsi)
movq 0x6ca46(%rip), %r14     # 0xaffe0
movl $0x1, %edx
movq %r14, %rdi
callq 0xa640
leaq 0x49f88(%rip), %rsi     # 0x8d536
movl $0x4, %edx
movq %r14, %rdi
callq 0xa640
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl $0x20, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2f4e2
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xa3e0
cmpq $0x0, (%rbx)
je 0x4360e
movq 0x6c9f2(%rip), %rdi     # 0xaffe0
leaq 0x49f46(%rip), %rsi     # 0x8d53b
movl $0x3, %edx
callq 0xa640
movq (%rbx), %rsi
movq 0x6c9d7(%rip), %rdi     # 0xaffe0
callq 0xa3e0
cmpq $0x0, 0x28(%rbx)
je 0x4363e
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movq 0x6c9bc(%rip), %rdi     # 0xaffe0
movl $0x1, %edx
callq 0xa640
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %rax, %rdi
callq 0xa640
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movq 0x6c993(%rip), %rdi     # 0xaffe0
movl $0x1, %edx
callq 0xa640
cmpq $0x0, 0x6d4a1(%rip)     # 0xb0b00
je 0x436d2
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x49b73(%rip), %rsi     # 0x8d1e4
leaq 0x49b72(%rip), %rdx     # 0x8d1ea
leaq 0x8(%rsp), %rdi
callq 0x2fa1a
addq $0x20, %rbx
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa9e0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x436b4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpq $-0x1, %rbx
jne 0x436d2
movq 0x6c91f(%rip), %rdi     # 0xaffe0
leaq 0x49e77(%rip), %rsi     # 0x8d53f
movl $0xe, %edx
callq 0xa640
leaq 0x28(%rsp), %rdi
callq 0x2f5bc
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x436e6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2f5bc
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::~Progress()
Progress::~Progress () 
{ 
	if (! active)
		return;

	report ();
  if (n)
    cerr << endl;
  beingUsed--;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x4374b
movq %rbx, %rdi
callq 0x43576
cmpq $0x0, 0x18(%rbx)
je 0x43744
movq 0x6c8c4(%rip), %rdi     # 0xaffe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0xa570
movsbl %al, %esi
movq 0x6c8a9(%rip), %rdi     # 0xaffe0
callq 0xa040
movq %rax, %rdi
callq 0xa3f0
decq 0x6d3cd(%rip)           # 0xb0b18
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x43764
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xa5a0
popq %rbx
retq
movq %rax, %rdi
callq 0x2c2a7
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::CharInput::getLine[abi:cxx11]()
string CharInput::getLine ()
{
  string s;
  while (! eof)
  {
    const char c = get ();
    if (tp. eol ())
      break;
    s += c;
  }
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpb $0x0, 0x218(%r14)
jne 0x45871
movq %r14, %rdi
callq 0x44bbc
cmpl $-0x1, 0x264(%r14)
je 0x45871
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa4d0
jmp 0x45848
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x45890
movq (%r15), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Token::saveText(std::ostream&) const
void Token::saveText (ostream &os) const 
{ 
  if (empty ())
    return;
    
  switch (type)
	{ 
	  case eName:      
	  case eDateTime:  os << name; 
	                   break;
		case eText:      if (quote)
		                   os << quote;
		                 os << name;
		                 if (quote)
		                   os << quote; 
		                 break;
		case eInteger:   os << n;             
		                 break;
		case eDouble:    { 
		                   const ONumber on (os, decimals, scientific); 
		                   os << d; 
		                 } 
		                 break;
		case eDelimiter: os << name;          
		                 break;
 		default: throw logic_error ("Token: Unknown type");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x47b4a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%r14), %eax
cmpq $0x5, %rax
ja 0x47c4d
leaq 0x44a95(%rip), %rcx     # 0x8c5f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa640
movb 0x30(%r14), %al
testb %al, %al
je 0x47b9e
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0xa640
movb 0x30(%r14), %al
testb %al, %al
je 0x47b3f
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
jmp 0x47b3f
movq 0x48(%r14), %rax
movq (%rbx), %rcx
movq -0x18(%rcx), %rdx
movq 0x8(%rbx,%rdx), %r15
movl 0x18(%rbx,%rdx), %ebp
movl %ebp, %esi
andl $0xfffffefb, %esi       # imm = 0xFFFFFEFB
cmpb $0x0, 0x50(%r14)
movl $0x100, %edi            # imm = 0x100
movl $0x4, %r8d
cmovnel %edi, %r8d
orl %esi, %r8d
movl %r8d, 0x18(%rbx,%rdx)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rbx,%rcx)
movsd 0x40(%r14), %xmm0
movq %rbx, %rdi
callq 0xa910
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl %ebp, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq %r15, 0x8(%rbx,%rax)
jmp 0x47b3f
movq 0x38(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa200
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x45c1c(%rip), %rsi     # 0x8d87d
movq %rax, %rdi
callq 0xa7f0
movq 0x68350(%rip), %rsi     # 0xaffc0
movq 0x68311(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
jmp 0x47ca3
movq %rax, %r14
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl %ebp, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq %r15, 0x8(%rbx,%rax)
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Token::operator<(Common_sp::Token const&) const
bool Token::operator< (const Token &other) const
{
  LESS_PART (*this, other, type);
  switch (type)
  { 
    case eName:
    case eText:
    case eDateTime:
    case eDelimiter: LESS_PART (*this, other, name); break;
    case eInteger:   LESS_PART (*this, other, n);    break; 
    case eDouble:    LESS_PART (*this, other, d);    break;
  }  
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x8(%rdi), %eax
movl 0x8(%rsi), %ecx
movb $0x1, %bl
cmpl %ecx, %eax
jl 0x47d00
jg 0x47cfe
cmpl $0x5, %eax
ja 0x47cfe
movq %rsi, %r15
movq %rdi, %r14
movl %eax, %eax
leaq 0x44939(%rip), %rcx     # 0x8c60c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x10, %r14
addq $0x10, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa050
testl %eax, %eax
js 0x47d00
movq %r15, %rdi
movq %r14, %rsi
callq 0xa050
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movsd 0x40(%r15), %xmm0
ucomisd 0x40(%r14), %xmm0
jbe 0x47cfe
jmp 0x47d00
movq 0x38(%r14), %rax
cmpq 0x38(%r15), %rax
setl %bl
jmp 0x47d00
jmp 0x47d27
movq %rax, %rdi
callq 0x2c2a7
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::csvLine2vec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
StringVector csvLine2vec (const string &line)
{
  StringVector words;  words. reserve (256);  // PAR
  Csv csv (line);
  string s;
  while (csv. goodPos ())
  {
    s = csv. getWord ();
    trim (s);
    words << std::move (s);
  }
  return words;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rdi)
movups %xmm0, (%rdi)
movl $0x100, %esi            # imm = 0x100
callq 0x2fb76
movq %r14, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
cmpq %rax, 0x8(%r14)
je 0x4e25b
leaq 0x48(%rsp), %rbp
leaq 0x38(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4dbfa
movq %r12, %rdi
movq %r14, %rsi
callq 0xa6e0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4e208
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r12, %rdi
callq 0x37275
movq %r12, %rdi
callq 0x384ed
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2fc7a
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x4e234
movb $0x0, 0x18(%rbx)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rax), %rcx
jb 0x4e1db
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x4e25b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4e28e
jmp 0x4e274
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x4e28e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0x327d2
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::toStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string Json::toStr (const string& s)
{ 
  if (isNatural (s, false))
    return s;
    
  // https://www.json.org/json-en.html
  string res ("\"");
  for (const char c : s)
    switch (c)
    {
      case '\"': res += "\\\""; break;
      case '\\': res += "\\\\"; break;
      case '\n': res += "\\n"; break;
      case '\r': res += "\\t"; break;
      case '\t': res += "\\t"; break;
      default:   res += c;
    }
  return res + "\""; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x37ea3
testb %al, %al
je 0x4ebd2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c212
jmp 0x4ecb5
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3dde6(%rip), %rsi     # 0x8c9c8
leaq 0x3dde0(%rip), %rdx     # 0x8c9c9
leaq 0x8(%rsp), %rdi
callq 0x2fa1a
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x4ec6e
movq (%r14), %r13
xorl %ebp, %ebp
leaq 0x3dfa5(%rip), %r15     # 0x8cbad
leaq 0x8(%rsp), %r14
movb (%r13,%rbp), %al
movzbl %al, %ecx
cmpl $0xc, %ecx
jle 0x4ec35
cmpl $0xd, %ecx
je 0x4ec48
movq %r15, %rsi
cmpl $0x5c, %ecx
je 0x4ec4f
cmpl $0x22, %ecx
jne 0x4ec61
leaq 0x3f0b1(%rip), %rsi     # 0x8dce4
jmp 0x4ec4f
cmpl $0x9, %ecx
je 0x4ec48
cmpl $0xa, %ecx
jne 0x4ec61
leaq 0x3df6a(%rip), %rsi     # 0x8cbb0
jmp 0x4ec4f
leaq 0x3f098(%rip), %rsi     # 0x8dce7
movq %r14, %rdi
callq 0xaac0
incq %rbp
cmpq %rbp, %r12
jne 0x4ec0d
jmp 0x4ec6e
movsbl %al, %esi
movq %r14, %rdi
callq 0xa4d0
jmp 0x4ec57
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c212
leaq 0x3dd37(%rip), %rsi     # 0x8c9c8
movq %rbx, %rdi
callq 0xaac0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4ecb5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4ece4
movq (%r15), %rsi
incq %rsi
callq 0xa5a0
jmp 0x4ece4
jmp 0x4ece1
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4ed00
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getString[abi:cxx11]() const
string Json::getString () const
{ 
  const auto* this_ = this;
  if (! this_ || asJsonNull ())
    throw logic_error ("undefined");
  if (const JsonString* j = asJsonString ())
    return j->s;
  throw logic_error ("Not a JsonString");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x48(%rax)
testq %rax, %rax
jne 0x4f10d
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
testq %rax, %rax
je 0x4f12b
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c212
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3ebeb(%rip), %rsi     # 0x8dd0c
movq %rax, %rdi
callq 0xa7f0
jmp 0x4f147
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3ebd7(%rip), %rsi     # 0x8dd16
movq %rax, %rdi
callq 0xa7f0
movq 0x60e72(%rip), %rsi     # 0xaffc0
movq 0x60e33(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
jmp 0x4f15f
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getInt() const
long long Json::getInt () const
{ 
  const auto* this_ = this;
  if (! this_ || asJsonNull ())
    throw logic_error ("undefined");
  if (const JsonInt* j = asJsonInt ())
    return j->n;
  throw logic_error ("Not a JsonInt");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
jne 0x4f19e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
testq %rax, %rax
je 0x4f1bc
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3eb5a(%rip), %rsi     # 0x8dd0c
movq %rax, %rdi
callq 0xa7f0
jmp 0x4f1d8
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3eb57(%rip), %rsi     # 0x8dd27
movq %rax, %rdi
callq 0xa7f0
movq 0x60de1(%rip), %rsi     # 0xaffc0
movq 0x60da2(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
jmp 0x4f1f0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getDouble() const
double Json::getDouble () const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return numeric_limits<double>::quiet_NaN ();
  if (const JsonDouble* j = asJsonDouble ())
    return j->n;
  throw logic_error ("Not a JsonDouble");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
je 0x4f220
movsd 0x3d37a(%rip), %xmm0    # 0x8c598
jmp 0x4f233
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
testq %rax, %rax
je 0x4f23b
movsd 0x8(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3eae6(%rip), %rsi     # 0x8dd35
movq %rax, %rdi
callq 0xa7f0
movq 0x60d62(%rip), %rsi     # 0xaffc0
movq 0x60d23(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getBoolean() const
bool Json::getBoolean () const
{ 
  const auto* this_ = this;
  if (! this_ || asJsonNull ())
    throw logic_error ("undefined");
  if (const JsonBoolean* j = asJsonBoolean ())
    return j->b;
  throw logic_error ("Not a JsonBoolean");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
jne 0x4f2ab
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
testq %rax, %rax
je 0x4f2c9
movb 0x8(%rax), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3ea4d(%rip), %rsi     # 0x8dd0c
movq %rax, %rdi
callq 0xa7f0
jmp 0x4f2e5
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3ea69(%rip), %rsi     # 0x8dd46
movq %rax, %rdi
callq 0xa7f0
movq 0x60cd4(%rip), %rsi     # 0xaffc0
movq 0x60c95(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
jmp 0x4f2fd
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::at(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const Json* Json::at (const string& name_arg) const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return nullptr;
  if (const JsonMap* j = asJsonMap ())
    return findPtr (j->data, name_arg);
  throw logic_error ("Not a JsonMap");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
je 0x4f329
xorl %eax, %eax
jmp 0x4f353
movq (%r14), %rax
movq %r14, %rdi
callq *0x78(%rax)
testq %rax, %rax
je 0x4f35b
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x745bc
addq $0x10, %r14
cmpq %r14, %rax
je 0x4f325
movq 0x40(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e9e9(%rip), %rsi     # 0x8dd58
movq %rax, %rdi
callq 0xa7f0
movq 0x60c42(%rip), %rsi     # 0xaffc0
movq 0x60c03(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::at(unsigned long) const
const Json* Json::at (size_t index) const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return nullptr;
  if (const JsonArray* j = asJsonArray ())
  {
    if (index >= j->data. size ())
      throw runtime_error (FUNC "Index out of range");
    else
      return j->data [index];
  }
  throw logic_error ("Not a JsonArray");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
je 0x4f3c1
xorl %eax, %eax
jmp 0x4f3f2
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x4f3ff
movq 0x10(%rax), %rcx
subq 0x8(%rax), %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x4f431
addq $0x8, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x65516
movq (%rax), %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e996(%rip), %rsi     # 0x8dda9
movq %rax, %rdi
callq 0xa7f0
movq 0x60b9e(%rip), %rsi     # 0xaffc0
movq 0x60b5f(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3e918(%rip), %rsi     # 0x8dd66
leaq 0x3e93e(%rip), %rdx     # 0x8dd93
movq %rsp, %rdi
callq 0x2fa1a
leaq 0x3e930(%rip), %rsi     # 0x8dd94
movq %rsp, %rdi
callq 0xaac0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4f48f
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x4f49c
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x60b1c(%rip), %rsi     # 0xaffe8
movq 0x60a8d(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x4f4f5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4f50b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x4f532
jmp 0x4f53a
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4f532
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x4f532
jmp 0x4f52f
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getSize() const
size_t Json::getSize () const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return 0;
  if (const JsonArray* j = asJsonArray ())
    return j->data. size ();
  throw logic_error ("Not a JsonArray");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
je 0x4f558
xorl %eax, %eax
jmp 0x4f575
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x4f57d
movq %rax, %rcx
movq 0x10(%rax), %rax
subq 0x8(%rcx), %rax
sarq $0x3, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e818(%rip), %rsi     # 0x8dda9
movq %rax, %rdi
callq 0xa7f0
movq 0x60a20(%rip), %rsi     # 0xaffc0
movq 0x609e1(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::FileItemGenerator::next(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool FileItemGenerator::next (string &item)
{ 
  if (f. eof ())
    return false;
    
	readLine (f, item);
  if (! tsv)
    trim (item);
  if (item. empty () && f. eof ())
    return false;

  prog (item);
    
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x68(%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x88(%rdi,%rax)
jne 0x5154c
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %r15
movq %r15, %rdi
callq 0x3ed20
cmpb $0x0, 0x270(%r14)
jne 0x51523
movq %rbx, %rdi
callq 0x37275
movq %rbx, %rdi
callq 0x384ed
cmpq $0x0, 0x8(%rbx)
jne 0x51539
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r15,%rax)
jne 0x5154c
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40a4e
movb $0x1, %al
jmp 0x5154e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq