LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/common.cpp
// Function: Common_sp::collapseSpace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void collapseSpace (string &s)
{
  string s1;
  do 
  {
    s1 = s;
    replaceStr (s, "  ", " ");
  }
  while (s1 != s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x58(%rsp), %r12
leaq 0x38(%rsp), %rbp
leaq 0x48(%rsp), %r13
leaq 0x5572b(%rip), %r14     # 0x8e811
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xa320
movq %r12, 0x48(%rsp)
movq %r13, %rdi
leaq 0x55708(%rip), %rsi     # 0x8e80f
leaq 0x55703(%rip), %rdx     # 0x8e811
callq 0x2fdd8
movq %rbp, 0x28(%rsp)
movq %r15, %rdi
leaq 0x556ee(%rip), %rsi     # 0x8e810
movq %r14, %rdx
callq 0x2fdd8
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x37703
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3914f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x39166
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x10(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x390eb
testq %rdx, %rdx
je 0x3918f
movq (%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0xa5c0
testl %eax, %eax
jne 0x390eb
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x391ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x391d9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x391d9
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x391f7
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x391f7
jmp 0x391f4
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x39213
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/common.cpp
// Function: Common_sp::visualizeTrailingSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0x39255
movq (%rbx), %rcx
cmpb $0x20, -0x1(%rcx,%rax)
jne 0x39255
leaq -0x1(%rax), %rdx
movq %rdx, 0x8(%rbx)
movb $0x0, -0x1(%rcx,%rax)
incq %r15
movq 0x8(%rbx), %rax
jmp 0x39230
testq %r15, %r15
je 0x3929f
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x20, %esi
callq 0x36e3e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xa190
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3929a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
decq %r15
jne 0x39264
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x392c5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/common.cpp
// Function: Common_sp::str2streamWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
string str2streamWord (const string &s,
                       size_t wordNum)
{
  istringstream iss (s);
  string word;
  FOR (size_t, i, wordNum + 1)
    if (iss. eof ())
    	return noString;
    else
      iss >> word;
  return word;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0xa980
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
cmpq $-0x1, %r14
je 0x39339
incq %r14
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x39357
movq %r15, %rdi
movq %r12, %rsi
callq 0xa720
decq %r14
jne 0x39319
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rcx
cmpq %r13, %rcx
je 0x39379
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x39381
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x77773(%rip), %rsi     # 0xb0ad8
movq 0x77774(%rip), %rdx     # 0xb0ae0
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c652
jmp 0x3939c
movups (%r13), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r13, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x393b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x76b9f(%rip), %rsi     # 0xaff58
leaq 0x20(%rsp), %rdi
callq 0xa7e0
leaq 0x98(%rsp), %rdi
callq 0xa1c0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x393e6
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x393ff
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x76b52(%rip), %rsi     # 0xaff58
leaq 0x20(%rsp), %rdi
callq 0xa7e0
leaq 0x98(%rsp), %rdi
callq 0xa1c0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3951b
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 0x39542
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c652
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 0x39565
movq (%rbx), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x395bd
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 0x395ed
movq %r15, 0x8(%r14)
movq (%r14), %rax
addq %r15, %rax
jmp 0x395e1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c652
movq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x55916(%rip), %rdi     # 0x8ef0a
leaq 0x5595d(%rip), %rsi     # 0x8ef58
movq %r15, %rdx
xorl %eax, %eax
callq 0xa890
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x3961f
movq (%rbx), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c652
cmpq $0x0, 0x30(%rsp)
je 0x3a0db
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 0x394d9
movl $0x30, %edi
callq 0xa590
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdx
cmpq %r13, %rdx
je 0x3a085
movq %rdx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x3a08d
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 0x3a0cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpq $0x0, 0x30(%rsp)
jne 0x3a04a
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3a0f2
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 0x3a13f
movq %rax, %r14
jmp 0x3a128
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a128
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3a13f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0x2fd92
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a1ae
testb $0x1, %bpl
jne 0x3a19a
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 0x3a17c
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 0x3a1d7
movq (%r12), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x51a64
leaq 0xe8(%rsp), %rdi
movq %r14, %rsi
callq 0x2ebf6
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 0x3c0d0
testb %al, %al
je 0x3bfe3
movq %r14, 0x48(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x2c652
movq %r12, %rdi
leaq 0x513a0(%rip), %rsi     # 0x8d2e6
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 0x3bf80
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x3bf87
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 0x3b044
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3bfc3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x3bf0e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x3bf0e
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3bfff
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x729fa(%rip), %rax     # 0xaea00
leaq 0x1e0(%rsp), %rbx
movq %rax, -0xf8(%rbx)
leaq 0x72a0c(%rip), %rax     # 0xaea28
movq %rax, (%rbx)
leaq 0xf0(%rsp), %rdi
callq 0xa4b0
movq %rbx, %rdi
callq 0xa1c0
leaq 0x68(%rsp), %rdi
callq 0x51bae
addq $0x2e8, %rsp            # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3c0bd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3c078
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x3c078
jmp 0x3c075
jmp 0x3c091
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x3c094
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x3c094
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3c0b0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0xe8(%rsp), %rdi
callq 0x2ecc8
leaq 0x68(%rsp), %rdi
callq 0x51bae
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ea7f
testb %al, %al
je 0x3f1a4
leaq 0xf(%rsp), %r15
movb 0xf(%rsp), %al
cmpb $0xa, %al
je 0x3f1a4
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa4d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ea7f
testb %al, %al
jne 0x3f182
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/common.cpp
// Function: Common_sp::Rand::run()
void Rand::run ()
{
	qc ();
  
  const long ia = 16807;
  const long iq = 127773;
  const long ir = 2836;

  const long k = seed / iq;
  seed = ia * (seed - k * iq) - ir * k;
  if (seed < 0)
  	seed += max_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3f770
movq (%rbx), %rcx
movabsq $0x41a705af1fe3fb79, %rdx # imm = 0x41A705AF1FE3FB79
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rax,%rcx), %rdx
addq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
addq %rcx, %rax
cmovnsq %rax, %rdx
movq %rdx, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4059e
movq %rdx, %r14
cmpq $0x0, 0x8(%rbx)
je 0x40584
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 0x4056e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x405c1
movq (%r15), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64e00
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x6f9b2(%rip), %r15     # 0xb05b8
cmpq $0x1, %r15
je 0x40c1e
callq 0xa500
cmpq 0x6feb0(%rip), %rax     # 0xb0ac8
jne 0x40d60
cmpq $0x0, 0x6feda(%rip)     # 0xb0b00
jne 0x40d24
movq %r14, 0x6fecd(%rip)     # 0xb0b00
cmpq %r14, %r15
jbe 0x40d42
movb %bpl, 0x6fec5(%rip)     # 0xb0b08
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64e6e
cmpb $0x0, 0x6feb3(%rip)     # 0xb0b08
jne 0x40d19
movb $0x1, %al
cmpq $0x1, 0x6f953(%rip)     # 0xb05b8
je 0x40c76
callq 0xa500
cmpq 0x6fe55(%rip), %rax     # 0xb0ac8
sete %al
testb %al, %al
je 0x40d19
cmpl $0x0, 0x6fe87(%rip)     # 0xb0b0c
js 0x40d19
cmpq $0x0, 0x6fe6d(%rip)     # 0xb0b00
je 0x40d19
movq 0x6f340(%rip), %rsi     # 0xaffe0
leaq 0x8(%rsp), %rdi
movl $0x20, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2f8a0
movq 0x6f322(%rip), %rdi     # 0xaffe0
leaq 0x4c579(%rip), %rsi     # 0x8d23e
movl $0x13, %edx
callq 0xa640
movq 0x6fe2a(%rip), %rsi     # 0xb0b00
incq %rsi
movq 0x6f300(%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 0x2f97a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x4c4c9(%rip), %rsi     # 0x8d201
movq %rax, %rdi
callq 0xa7f0
jmp 0x40d7c
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x4c4ce(%rip), %rsi     # 0x8d224
movq %rax, %rdi
callq 0xa7f0
jmp 0x40d7c
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x4c460(%rip), %rsi     # 0x8d1d4
movq %rax, %rdi
callq 0xa7f0
movq 0x6f23d(%rip), %rsi     # 0xaffc0
movq 0x6f1fe(%rip), %rdx     # 0xaff88
movq %r14, %rdi
callq 0xa9b0
jmp 0x40db4
jmp 0x40d98
jmp 0x40d98
movq %rax, %r15
movq %r14, %rdi
callq 0xa440
jmp 0x40db7
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x2f97a
jmp 0x40db7
movq %rax, %r15
movq %rbx, %rdi
callq 0x64f1a
movb $0x0, 0x6fdbb(%rip)     # 0xb0b81
movq %r15, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6fd14(%rip), %edx     # 0xb0b08
xorq $0x1, %rdx
leaq 0x28(%rsp), %rdi
callq 0x43982
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4c440(%rip), %rsi     # 0x8d252
leaq 0x4c455(%rip), %rdx     # 0x8d26e
leaq 0x8(%rsp), %rdi
callq 0x2fdd8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x40ee8
movq (%rbx), %r14
movq 0x8(%rbx), %rbp
cmpq %rbp, %r14
je 0x40e64
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
callq 0xa9a0
movq %r15, %rdi
movq %r12, %rsi
callq 0x40ee8
addq $0x8, %r14
cmpq %rbp, %r14
jne 0x40e48
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x40e7b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x28(%rsp), %rdi
callq 0x43b9a
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x40ea7
movq %rax, %rdx
cmpq $0x0, (%rdx)
jne 0x40ed9
addq $0x8, %rdx
cmpq %rcx, %rdx
jne 0x40e94
movq %rax, 0x8(%rbx)
movq $0x0, 0x6fc4e(%rip) # 0xb0b00
xorl %ebp, %ebp
movb %bpl, 0x6fc4d(%rip)     # 0xb0b08
movq %rbx, %rdi
callq 0x64f1a
movb %bpl, 0x6fcb7(%rip)     # 0xb0b81
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa150
jmp 0x40ee0
movq %rax, %rdi
callq 0x2c6e2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40f1c
movq 0x18(%rbx), %rax
xorl %ecx, %ecx
xorl %edx, %edx
divq 0x10(%rbx)
testq %rdx, %rdx
jne 0x40f1e
movq %rbx, %rdi
callq 0x43a04
movb $0x1, %cl
jmp 0x40f1e
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40fb8
movq (%r14), %r13
xorl %ebp, %ebp
leaq 0x4c307(%rip), %r15     # 0x8d274
movq %rsp, %r14
leaq 0x4c2f8(%rip), %rbx     # 0x8d26f
movzbl (%r13,%rbp), %eax
cmpl $0x26, %eax
je 0x40f94
movq %r15, %rsi
cmpl $0x3e, %eax
je 0x40f9b
cmpl $0x3c, %eax
jne 0x40fa5
movq %rbx, %rsi
jmp 0x40f9b
leaq 0x4c2de(%rip), %rsi     # 0x8d279
movq %r14, %rdi
callq 0xaac0
jmp 0x40fb0
movsbl %al, %esi
movq %r14, %rdi
callq 0xa4d0
incq %rbp
cmpq %rbp, %r12
jne 0x40f77
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 0x40fea
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 0x40ffb
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x41019
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x6e176(%rip)     # 0xb0ac0
jne 0x42998
movq %rdi, %r14
movq 0x10(%rdi), %rax
addq $0x8, %r14
testq %rax, %rax
je 0x429a8
movq (%r14), %rcx
cmpb $0x20, (%rcx)
je 0x429a8
cmpb $0x20, -0x1(%rcx,%rax)
je 0x429a8
movb (%rcx), %dl
addb $-0x20, %dl
cmpb $0x5e, %dl
ja 0x429a8
movl $0x1, %esi
cmpq %rsi, %rax
je 0x42998
movq %rsi, %rdx
movb (%rcx,%rsi), %dil
addb $-0x20, %dil
incq %rsi
cmpb $0x5f, %dil
jb 0x4297a
cmpq %rdx, %rax
jne 0x429a8
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4aa83(%rip), %rsi     # 0x8d448
leaq 0x4aaa5(%rip), %rdx     # 0x8d471
leaq 0x20(%rsp), %rdi
callq 0x2fdd8
leaq 0x4aa95(%rip), %rsi     # 0x8d472
leaq 0x20(%rsp), %rdi
callq 0xaac0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x42a0a
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x42a16
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38d2b
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
callq 0x2d562
movb $0x1, %bpl
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x6d57d(%rip), %rsi     # 0xaffe8
movq 0x6d4ee(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42aa0
movq 0x70(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x42aa0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42ac3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x42ac3
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x42ae1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x42ae1
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x42b00
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x42b00
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x42b0d
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c652
cmpq $0x0, 0x10(%rsp)
je 0x43083
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 0x394d9
movq %rbx, %rdi
movq %r13, %rsi
callq 0x30032
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x43064
movb $0x0, 0x18(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x4307b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpq $0x0, 0x10(%rsp)
jne 0x4303a
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x430b8
movq (%r15), %rcx
movl (%rsp), %edx
cmpb %dl, -0x1(%rcx,%rax)
jne 0x430b8
leaq 0x6da39(%rip), %rsi     # 0xb0ad8
movq %rbx, %rdi
callq 0x30dca
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x430b8
movb $0x0, 0x18(%rbx)
cmpb $0x0, 0x4(%rsp)
je 0x430e1
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x430e1
movq %r14, %rdi
callq 0x374e6
movq %r14, %rdi
callq 0x387de
addq $0x20, %r14
jmp 0x430c6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x430fd
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 0x43115
movq %rax, %r15
jmp 0x43134
jmp 0x43115
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x43134
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0x32c12
movq %r15, %rdi
callq 0xaa10
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x43118
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x43118
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43670
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x43672
movq %rax, %rbx
movq %r14, %rdi
callq 0x43672
movq 0x8(%rax), %rcx
cmpq %rcx, 0x8(%rbx)
jbe 0x4365d
movq %rbx, (%rax)
jmp 0x43669
movq %rax, (%rbx)
jne 0x43669
incq %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64fee
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 0x439de
incq 0x6d142(%rip)           # 0xb0b18
movq %rbx, %rdi
callq 0x43a04
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rbx), %rdi
cmpq %r15, %rdi
je 0x439fb
movq (%r15), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43b7b
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movb $0xd, (%rsi)
movq 0x6c5b8(%rip), %r14     # 0xaffe0
movl $0x1, %edx
movq %r14, %rdi
callq 0xa640
leaq 0x49b10(%rip), %rsi     # 0x8d54c
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 0x2f8a0
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xa3e0
cmpq $0x0, (%rbx)
je 0x43a9c
movq 0x6c564(%rip), %rdi     # 0xaffe0
leaq 0x49ace(%rip), %rsi     # 0x8d551
movl $0x3, %edx
callq 0xa640
movq (%rbx), %rsi
movq 0x6c549(%rip), %rdi     # 0xaffe0
callq 0xa3e0
cmpq $0x0, 0x28(%rbx)
je 0x43acc
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movq 0x6c52e(%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 0x6c505(%rip), %rdi     # 0xaffe0
movl $0x1, %edx
callq 0xa640
movq 0x6d014(%rip), %r14     # 0xb0b00
testq %r14, %r14
je 0x43b33
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x496f9(%rip), %rsi     # 0x8d1fa
leaq 0x496f8(%rip), %rdx     # 0x8d200
leaq 0x8(%rsp), %rdi
callq 0x2fdd8
addq $0x20, %rbx
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa9e0
cmpq $-0x1, %rax
sete %bl
jmp 0x43b35
xorl %ebx, %ebx
testq %r14, %r14
je 0x43b55
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43b55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bl, %bl
je 0x43b71
movq 0x6c480(%rip), %rdi     # 0xaffe0
leaq 0x499ee(%rip), %rsi     # 0x8d555
movl $0xe, %edx
callq 0xa640
leaq 0x28(%rsp), %rdi
callq 0x2f97a
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x43b85
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2f97a
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43be9
movq %rbx, %rdi
callq 0x43a04
cmpq $0x0, 0x18(%rbx)
je 0x43be2
movq 0x6c426(%rip), %rdi     # 0xaffe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0xa570
movsbl %al, %esi
movq 0x6c40b(%rip), %rdi     # 0xaffe0
callq 0xa040
movq %rax, %rdi
callq 0xa3f0
decq 0x6cf2f(%rip)           # 0xb0b18
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x43c02
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xa5a0
popq %rbx
retq
movq %rax, %rdi
callq 0x2c6e2
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
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 0x45d20
movq %r14, %rdi
callq 0x45058
movl 0x264(%r14), %ebp
cmpl $-0x1, %ebp
je 0x45d20
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa4d0
cmpl $-0x1, %ebp
jne 0x45cf2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x45d44
movq (%r15), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48068
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%r14), %eax
cmpq $0x5, %rax
ja 0x4816b
leaq 0x44577(%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 0x480bc
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 0x4805d
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
jmp 0x4805d
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 0x4805d
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 0x45714(%rip), %rsi     # 0x8d893
movq %rax, %rdi
callq 0xa7f0
movq 0x67e32(%rip), %rsi     # 0xaffc0
movq 0x67df3(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
jmp 0x481c1
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_O1/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 0x4821e
jg 0x4821c
cmpl $0x5, %eax
ja 0x4821c
movq %rsi, %r15
movq %rdi, %r14
movl %eax, %eax
leaq 0x4441b(%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 0x4821e
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 0x4821c
jmp 0x4821e
movq 0x38(%r14), %rax
cmpq 0x38(%r15), %rax
setl %bl
jmp 0x4821e
jmp 0x48245
movq %rax, %rdi
callq 0x2c6e2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ff2e
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 0x4e73a
leaq 0x48(%rsp), %rbp
leaq 0x38(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e0e2
movq %r12, %rdi
movq %r14, %rsi
callq 0xa6e0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4e6fe
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r12, %rdi
callq 0x374e6
movq %r12, %rdi
callq 0x387de
movq %rbx, %rdi
movq %r12, %rsi
callq 0x30032
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x4e72a
movb $0x0, 0x18(%rbx)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rax), %rcx
jb 0x4e6d1
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x4e751
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 0x4e784
jmp 0x4e76a
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x4e784
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0x32c12
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3813f
testb %al, %al
je 0x4f0b8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c652
jmp 0x4f19b
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3d900(%rip), %rsi     # 0x8c9c8
leaq 0x3d8fa(%rip), %rdx     # 0x8c9c9
leaq 0x8(%rsp), %rdi
callq 0x2fdd8
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x4f154
movq (%r14), %r13
xorl %ebp, %ebp
leaq 0x3dabf(%rip), %r15     # 0x8cbad
leaq 0x8(%rsp), %r14
movb (%r13,%rbp), %al
movzbl %al, %ecx
cmpl $0xc, %ecx
jle 0x4f11b
cmpl $0xd, %ecx
je 0x4f12e
movq %r15, %rsi
cmpl $0x5c, %ecx
je 0x4f135
cmpl $0x22, %ecx
jne 0x4f147
leaq 0x3ebe1(%rip), %rsi     # 0x8dcfa
jmp 0x4f135
cmpl $0x9, %ecx
je 0x4f12e
cmpl $0xa, %ecx
jne 0x4f147
leaq 0x3da84(%rip), %rsi     # 0x8cbb0
jmp 0x4f135
leaq 0x3ebc8(%rip), %rsi     # 0x8dcfd
movq %r14, %rdi
callq 0xaac0
incq %rbp
cmpq %rbp, %r12
jne 0x4f0f3
jmp 0x4f154
movsbl %al, %esi
movq %r14, %rdi
callq 0xa4d0
jmp 0x4f13d
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c652
leaq 0x3d851(%rip), %rsi     # 0x8c9c8
movq %rbx, %rdi
callq 0xaac0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4f19b
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 0x4f1ca
movq (%r15), %rsi
incq %rsi
callq 0xa5a0
jmp 0x4f1ca
jmp 0x4f1c7
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4f1e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f5f3
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
testq %rax, %rax
je 0x4f611
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c652
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e71b(%rip), %rsi     # 0x8dd22
movq %rax, %rdi
callq 0xa7f0
jmp 0x4f62d
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e707(%rip), %rsi     # 0x8dd2c
movq %rax, %rdi
callq 0xa7f0
movq 0x6098c(%rip), %rsi     # 0xaffc0
movq 0x6094d(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
jmp 0x4f645
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f68e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
testq %rax, %rax
je 0x4f67e
movq 0x8(%rax), %rcx
jmp 0x4f67e
testq %rax, %rax
je 0x4f6ac
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e680(%rip), %rsi     # 0x8dd22
movq %rax, %rdi
callq 0xa7f0
jmp 0x4f6c8
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e67d(%rip), %rsi     # 0x8dd3d
movq %rax, %rdi
callq 0xa7f0
movq 0x608f1(%rip), %rsi     # 0xaffc0
movq 0x608b2(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
jmp 0x4f6e0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f710
movsd 0x3ce8a(%rip), %xmm0    # 0x8c598
jmp 0x4f72a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
testq %rax, %rax
je 0x4f725
movsd 0x8(%rax), %xmm0
jmp 0x4f725
testq %rax, %rax
je 0x4f732
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e605(%rip), %rsi     # 0x8dd4b
movq %rax, %rdi
callq 0xa7f0
movq 0x6086b(%rip), %rsi     # 0xaffc0
movq 0x6082c(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f7af
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
testq %rax, %rax
je 0x4f79d
movb 0x8(%rax), %cl
jmp 0x4f79d
testq %rax, %rax
je 0x4f7cd
andb $0x1, %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e55f(%rip), %rsi     # 0x8dd22
movq %rax, %rdi
callq 0xa7f0
jmp 0x4f7e9
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e57b(%rip), %rsi     # 0x8dd5c
movq %rax, %rdi
callq 0xa7f0
movq 0x607d0(%rip), %rsi     # 0xaffc0
movq 0x60791(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
jmp 0x4f801
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
je 0x4f82d
xorl %eax, %eax
jmp 0x4f862
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x78(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x4f859
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x74940
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x4f85b
movq 0x40(%rax), %rax
jmp 0x4f85d
jmp 0x4f85d
xorl %eax, %eax
testq %rbx, %rbx
je 0x4f86a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e4f0(%rip), %rsi     # 0x8dd6e
movq %rax, %rdi
callq 0xa7f0
movq 0x60733(%rip), %rsi     # 0xaffc0
movq 0x606f4(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop