LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::containsWord(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&)
size_t containsWord (const string& hay,
                     const string& needle)
{
  size_t pos = string::npos;
  for (;;)
  {
    pos = hay. find (needle, pos == string::npos ? 0 : pos + 1);
    if (pos == string::npos)
      break;
    const size_t pos1 = pos + needle. size ();
    if (   (pos  == 0            || ! isLetter (hay [pos - 1]))
        && (pos1 == hay. size () || ! isLetter (hay [pos1]))
       )
      break;
  }
  return pos;  
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $-0x1, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $-0x1, 0x30(%rsp)
jne 0x4203c
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x4204a
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0xce60
movq %rax, 0x30(%rsp)
cmpq $-0x1, 0x30(%rsp)
jne 0x42070
jmp 0x420fc
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xc530
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x420bb
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
subq $0x1, %rsi
callq 0xc7d0
movsbl (%rax), %edi
callq 0x73730
testb $0x1, %al
jne 0x420f7
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
callq 0xc530
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
je 0x420f5
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xc7d0
movsbl (%rax), %edi
callq 0x73730
testb $0x1, %al
jne 0x420f7
jmp 0x420fc
jmp 0x42017
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::to_c(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string to_c (const string &s)
{
  string r;
  for (const char c : s)
    if (c == '\n')
      r += "\\n";
    else
    {
      if (charInSet (c, "\"\'\\"))
        r += '\\';
      r += c;
    }   
  return r;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movb $0x0, 0x87(%rsp)
callq 0xca10
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0xcd90
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x428b4
jmp 0x429c8
leaq 0x70(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0x67(%rsp)
movsbl 0x67(%rsp), %eax
cmpl $0xa, %eax
jne 0x428f9
movq 0x18(%rsp), %rdi
leaq 0x8b3b9(%rip), %rsi     # 0xcdc93
callq 0xc6e0
jmp 0x428e1
jmp 0x429b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x429f1
movb 0x67(%rsp), %al
movb %al, 0xf(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xcd00
movq 0x10(%rsp), %rdx
leaq 0x8b37a(%rip), %rsi     # 0xcdc96
leaq 0x30(%rsp), %rdi
callq 0x29fd0
jmp 0x42928
movb 0xf(%rsp), %al
movsbl %al, %edi
leaq 0x30(%rsp), %rsi
callq 0x739a0
movb %al, 0xe(%rsp)
jmp 0x4293f
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x2f(%rsp), %rdi
callq 0xc7a0
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x4295d
jmp 0x429a4
movq 0x18(%rsp), %rdi
movl $0x5c, %esi
callq 0xc4c0
jmp 0x4296e
jmp 0x429a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x42998
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x2f(%rsp), %rdi
callq 0xc7a0
jmp 0x429f1
movq 0x18(%rsp), %rdi
movsbl 0x67(%rsp), %esi
callq 0xc4c0
jmp 0x429b5
jmp 0x429b7
jmp 0x429b9
leaq 0x70(%rsp), %rdi
callq 0x737b0
jmp 0x4289c
movb $0x1, 0x87(%rsp)
testb $0x1, 0x87(%rsp)
jne 0x429e4
movq 0x18(%rsp), %rdi
callq 0xce98
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xce98
movq 0x58(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xca10
movq 0xa0(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0xc080
jmp 0x42a43
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xcd00
movq 0x18(%rsp), %rdx
leaq 0x8cec2(%rip), %rsi     # 0xcf92d
leaq 0x50(%rsp), %rdi
callq 0x29fd0
jmp 0x42a77
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x8ce9c(%rip), %rsi     # 0xcf92e
leaq 0x28(%rsp), %rdi
callq 0x29fd0
jmp 0x42a9e
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x409d0
jmp 0x42ab4
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x27(%rsp), %rdi
callq 0xc7a0
leaq 0x50(%rsp), %rdi
callq 0xce98
leaq 0x4f(%rsp), %rdi
callq 0xc7a0
movq 0xa0(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x2f5a0
testb $0x1, %al
jne 0x42a2c
leaq 0x80(%rsp), %rdi
callq 0xce98
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x42b74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x42b6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x42b56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x27(%rsp), %rdi
callq 0xc7a0
leaq 0x50(%rsp), %rdi
callq 0xce98
leaq 0x4f(%rsp), %rdi
callq 0xc7a0
leaq 0x80(%rsp), %rdi
callq 0xce98
movq 0x78(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0xcc10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1b(%rsp)
jne 0x42bd0
movq 0x60(%rsp), %rdi
callq 0xc560
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
testb $0x1, %al
jne 0x42bda
jmp 0x42c16
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0xc530
movq 0x10(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
movq $-0x1, %rdx
callq 0xc150
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x42ba2
movq $0x0, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x42c8e
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x20, %esi
callq 0x40090
movq 0x8(%rsp), %rsi
movq 0x60(%rsp), %rdi
callq 0xc960
jmp 0x42c5a
leaq 0x28(%rsp), %rdi
callq 0xce98
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x42c29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xce98
jmp 0x42c93
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1d8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movl $0x8, %edx
callq 0xcc40
leaq 0x30(%rsp), %rdi
callq 0xca10
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x1d0(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x42d9c
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x50(%rsp,%rax), %rdi
callq 0xcd60
movb %al, 0x7(%rsp)
jmp 0x42d29
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x42d33
jmp 0x42d74
movq 0x8(%rsp), %rdi
leaq 0xc3f59(%rip), %rsi     # 0x106c98
callq 0xc320
jmp 0x42d46
movl $0x1, 0x18(%rsp)
jmp 0x42db3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x50(%rsp), %rdi
callq 0xc390
jmp 0x42dd4
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc950
jmp 0x42d85
jmp 0x42d87
jmp 0x42d89
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x42cf6
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc460
movl $0x1, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x50(%rsp), %rdi
callq 0xc390
movq 0x10(%rsp), %rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nop
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::str2sql(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string str2sql (const string &s)
{
	string r = "'";
  for (const char c : s)
	{
	  if (c == '\'')
	  	r += "'";
	  r += c;
	}
	r += "'";
	
	return r;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xcd00
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x8a056(%rip), %rsi     # 0xcce76
callq 0x29fd0
jmp 0x42e27
leaq 0x56(%rsp), %rdi
callq 0xc7a0
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0xcd90
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x42e71
jmp 0x42ef6
leaq 0x30(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0x27(%rsp)
movsbl 0x27(%rsp), %eax
cmpl $0x27, %eax
jne 0x42ed4
movq 0x10(%rsp), %rdi
leaq 0x89fdf(%rip), %rsi     # 0xcce76
callq 0xc6e0
jmp 0x42e9e
jmp 0x42ed4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0xc7a0
jmp 0x42f29
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0xce98
jmp 0x42f29
movq 0x10(%rsp), %rdi
movsbl 0x27(%rsp), %esi
callq 0xc4c0
jmp 0x42ee5
jmp 0x42ee7
leaq 0x30(%rsp), %rdi
callq 0x737b0
jmp 0x42e59
movq 0x10(%rsp), %rdi
leaq 0x89f74(%rip), %rsi     # 0xcce76
callq 0xc6e0
jmp 0x42f09
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x42f1f
movq 0x10(%rsp), %rdi
callq 0xce98
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb %al, 0x47(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl 0x47(%rsp), %esi
callq 0xc990
movq %rax, 0x38(%rsp)
cmpq $-0x1, 0x38(%rsp)
jne 0x42fb7
movq 0x10(%rsp), %rdi
movb $0x0, 0x37(%rsp)
movq 0x48(%rsp), %rsi
callq 0xc320
movq 0x48(%rsp), %rdi
callq 0xc9a0
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x42fb5
movq 0x10(%rsp), %rdi
callq 0xce98
jmp 0x43026
movq 0x10(%rsp), %rdi
movb $0x0, 0x36(%rsp)
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, 0x8(%rsp)
callq 0xc740
movq 0x8(%rsp), %rsi
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rdx
incq %rdx
callq 0xc150
jmp 0x42ff2
movb $0x1, 0x36(%rsp)
testb $0x1, 0x36(%rsp)
jne 0x43024
jmp 0x4301a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xce98
jmp 0x43030
movq 0x10(%rsp), %rdi
callq 0xce98
jmp 0x43026
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb %al, 0x47(%rsp)
movq 0x48(%rsp), %rdi
movq $-0x1, %rdx
movsbl 0x47(%rsp), %esi
callq 0xce30
movq %rax, 0x38(%rsp)
cmpq $-0x1, 0x38(%rsp)
jne 0x430ba
movq 0x10(%rsp), %rdi
movb $0x0, 0x37(%rsp)
movq 0x48(%rsp), %rsi
callq 0xc320
movq 0x48(%rsp), %rdi
callq 0xc9a0
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x430b8
movq 0x10(%rsp), %rdi
callq 0xce98
jmp 0x4312c
movq 0x10(%rsp), %rdi
movb $0x0, 0x36(%rsp)
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
incq %rdx
movq $-0x1, %rcx
movq %rcx, 0x8(%rsp)
callq 0xc740
movq 0x8(%rsp), %rdx
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xc150
jmp 0x430f8
movb $0x1, 0x36(%rsp)
testb $0x1, 0x36(%rsp)
jne 0x4312a
jmp 0x43120
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xce98
jmp 0x43136
movq 0x10(%rsp), %rdi
callq 0xce98
jmp 0x4312c
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
// File: 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:
subq $0x78, %rsp
movq %rdi, (%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb %al, 0x67(%rsp)
movb $0x0, 0x66(%rsp)
callq 0x73c60
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0xc320
jmp 0x43d4b
jmp 0x43d4d
leaq 0x40(%rsp), %rdi
callq 0xcc10
xorb $-0x1, %al
testb $0x1, %al
jne 0x43d5f
jmp 0x43dcb
movsbl 0x67(%rsp), %edx
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x42f40
jmp 0x43d75
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x73c70
jmp 0x43d85
leaq 0x10(%rsp), %rdi
callq 0xce98
jmp 0x43d4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x43e02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x43de3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xce98
jmp 0x43de3
movb $0x1, 0x66(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce98
testb $0x1, 0x66(%rsp)
jne 0x43df8
jmp 0x43def
leaq 0x40(%rsp), %rdi
callq 0xce98
jmp 0x43e02
movq (%rsp), %rdi
callq 0x32410
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq (%rsp), %rdi
callq 0x32410
movq 0x38(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0xca10
movb $0x1, 0x4e(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x32380
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x32210
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x73ca0
testb $0x1, %al
jne 0x43e8c
jmp 0x43ef1
leaq 0x38(%rsp), %rdi
callq 0x32260
movq %rax, 0x28(%rsp)
testb $0x1, 0x4e(%rsp)
jne 0x43ecf
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xc960
jmp 0x43eb3
jmp 0x43ecf
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xce98
jmp 0x43f11
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xc960
jmp 0x43ee0
movb $0x0, 0x4e(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x73cc0
jmp 0x43e77
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x43f07
movq 0x8(%rsp), %rdi
callq 0xce98
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: 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:
subq $0x308, %rsp            # imm = 0x308
movq %rdi, 0x300(%rsp)
movq %rsi, 0x2f8(%rsp)
movq 0x300(%rsp), %rdx
xorl %ecx, %ecx
movl %ecx, %esi
leaq 0x278(%rsp), %rdi
callq 0x5ee50
movq 0x2f8(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x30040
jmp 0x464a4
leaq 0x48(%rsp), %rdi
callq 0xca10
leaq 0x278(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x465e0
movb %al, 0x7(%rsp)
jmp 0x464c6
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x464d3
jmp 0x46589
movq 0x300(%rsp), %rsi
leaq 0x87f1c(%rip), %rdx     # 0xce3fe
leaq 0x8(%rsp), %rdi
callq 0x2d9a0
jmp 0x464ee
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x2e220
jmp 0x46504
xorl %eax, %eax
movl %eax, %esi
leaq 0x28(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x45440
jmp 0x46519
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x8(%rsp), %rdi
callq 0xce98
jmp 0x464ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x465c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x465b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x4657d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x8(%rsp), %rdi
callq 0xce98
jmp 0x465b2
leaq 0x48(%rsp), %rdi
callq 0xce98
leaq 0x78(%rsp), %rdi
callq 0x301a0
leaq 0x278(%rsp), %rdi
callq 0x5f020
addq $0x308, %rsp            # imm = 0x308
retq
leaq 0x48(%rsp), %rdi
callq 0xce98
leaq 0x78(%rsp), %rdi
callq 0x301a0
leaq 0x278(%rsp), %rdi
callq 0x5f020
movq 0x70(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xc9a0
movq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rsi
callq 0x49400
testb $0x1, %al
jne 0x49bfd
jmp 0x49c1c
movsbl 0x7(%rsp), %eax
cmpl $0xa, %eax
jne 0x49c09
jmp 0x49c1c
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rdi
movsbl %al, %esi
callq 0xc4c0
jmp 0x49be8
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4a280
movq 0x8(%rsp), %rax
movq $0x41a7, 0x28(%rsp)     # imm = 0x41A7
movq $0x1f31d, 0x20(%rsp)    # imm = 0x1F31D
movq $0xb14, 0x18(%rsp)      # imm = 0xB14
movq (%rax), %rax
movl $0x1f31d, %ecx          # imm = 0x1F31D
cqto
idivq %rcx
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
imulq $0x1f31d, 0x10(%rsp), %rdx # imm = 0x1F31D
subq %rdx, %rcx
imulq $0x41a7, %rcx, %rcx     # imm = 0x41A7
imulq $0xb14, 0x10(%rsp), %rdx # imm = 0xB14
subq %rdx, %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jge 0x4a26f
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0xca10
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x35930
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x358f0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x35820
testb $0x1, %al
jne 0x4b0c0
jmp 0x4b125
leaq 0x38(%rsp), %rdi
callq 0x35960
movq (%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0xcc10
testb $0x1, %al
jne 0x4b107
movq (%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xc960
jmp 0x4b0ec
jmp 0x4b107
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xce98
jmp 0x4b144
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xc960
jmp 0x4b117
jmp 0x4b119
leaq 0x38(%rsp), %rdi
callq 0x38e20
jmp 0x4b0ab
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x4b13a
movq (%rsp), %rdi
callq 0xce98
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x36be0
movq %rax, %rsi
incq %rsi
movb 0xbb2bb(%rip), %al      # 0x106cc8
notb %al
movzbl %al, %eax
andl $0x1, %eax
movl %eax, %edx
leaq 0x60(%rsp), %rdi
callq 0x4e7e0
jmp 0x4ba23
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x8292c(%rip), %rsi     # 0xce36a
leaq 0x40(%rsp), %rdi
callq 0x29fd0
jmp 0x4ba4a
leaq 0x3f(%rsp), %rdi
callq 0xc7a0
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4bb30
jmp 0x4ba65
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x37130
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x36ea0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x744c0
testb $0x1, %al
jne 0x4baa2
jmp 0x4badc
leaq 0x28(%rsp), %rdi
callq 0x37610
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xcc70
jmp 0x4babd
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4bb30
jmp 0x4bace
jmp 0x4bad0
leaq 0x28(%rsp), %rdi
callq 0x74500
jmp 0x4ba8d
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x60(%rsp), %rdi
callq 0x4eb60
movq 0x10(%rsp), %rdi
callq 0x74520
movq 0x10(%rsp), %rdi
movq $0x0, 0xbb1b6(%rip) # 0x106cc0
movb $0x0, 0xbb1b7(%rip)     # 0x106cc8
callq 0x74450
movq 0x10(%rsp), %rdi
callq 0x744b0
addq $0xa8, %rsp
retq
movq %rax, %rdi
callq 0x2ad70
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x18(%rdi)
movq 0x10(%rsp), %rsi
addq $0x20, %rdi
callq 0xc080
movq 0x8(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x4bb93
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rax
xorl %edx, %edx
divq 0x10(%rcx)
cmpq $0x0, %rdx
jne 0x4bb93
movq 0x8(%rsp), %rdi
callq 0x4e8f0
movb $0x1, 0x27(%rsp)
jmp 0x4bb98
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xca10
movq 0x68(%rsp), %rdi
callq 0xc530
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xcb50
jmp 0x4bbf0
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xcd90
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x4bc30
jmp 0x4bce6
leaq 0x28(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0x1f(%rsp)
movsbl 0x1f(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x26, %eax
je 0x4bcad
jmp 0x4bc50
movl 0x4(%rsp), %eax
subl $0x3c, %eax
je 0x4bc83
jmp 0x4bc5b
movl 0x4(%rsp), %eax
subl $0x3e, %eax
je 0x4bc98
jmp 0x4bcc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xce98
jmp 0x4bd06
leaq 0x826fd(%rip), %rsi     # 0xce387
leaq 0x48(%rsp), %rdi
callq 0xc6e0
jmp 0x4bc96
jmp 0x4bcd5
leaq 0x826ed(%rip), %rsi     # 0xce38c
leaq 0x48(%rsp), %rdi
callq 0xc6e0
jmp 0x4bcab
jmp 0x4bcd5
leaq 0x826dd(%rip), %rsi     # 0xce391
leaq 0x48(%rsp), %rdi
callq 0xc6e0
jmp 0x4bcc0
jmp 0x4bcd5
movsbl 0x1f(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0xc4c0
jmp 0x4bcd3
jmp 0x4bcd5
jmp 0x4bcd7
leaq 0x28(%rsp), %rdi
callq 0x737b0
jmp 0x4bc18
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x74540
jmp 0x4bcf7
leaq 0x48(%rsp), %rdi
callq 0xce98
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xccf0
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Xml::BinFile::printRaw(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Xml::BinFile::printRaw (const string &s)
{
	QC_ASSERT (! contains (s, '\0'));
	if (! isText)
		os << '\0' << '\0';  // Tags closing
	os << s;
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xc090
movl $0x0, (%rax)
movq 0x138(%rsp), %rdi
xorl %esi, %esi
callq 0x2dbd0
testb $0x1, %al
jne 0x4c4b7
jmp 0x4c718
callq 0xc8c0
cmpl $0x0, %eax
jne 0x4c70e
leaq 0x97(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x81536(%rip), %rsi     # 0xcda19
leaq 0x98(%rsp), %rdi
callq 0x29fd0
jmp 0x4c4f2
leaq 0x60(%rsp), %rdi
movl $0x742, %esi            # imm = 0x742
callq 0x2ded0
jmp 0x4c503
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x2dde0
jmp 0x4c51f
leaq 0x7f67b(%rip), %rdx     # 0xcbba1
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x2a2f0
jmp 0x4c53d
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xcd00
movq (%rsp), %rdx
leaq 0x81ead(%rip), %rsi     # 0xce403
leaq 0x20(%rsp), %rdi
callq 0x29fd0
jmp 0x4c562
leaq 0x814ad(%rip), %rdx     # 0xcda16
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2a2f0
jmp 0x4c57a
leaq 0xf8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2dde0
jmp 0x4c596
leaq 0x81ea5(%rip), %rdx     # 0xce442
leaq 0x118(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x2a2f0
jmp 0x4c5b4
leaq 0x118(%rsp), %rdi
callq 0x3e9b0
jmp 0x4c5c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4c6ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4c6f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4c6e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4c6db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4c6c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4c6ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4c6b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4c6a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x118(%rsp), %rdi
callq 0xce98
leaq 0xf8(%rsp), %rdi
callq 0xce98
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
leaq 0x1f(%rsp), %rdi
callq 0xc7a0
leaq 0xd8(%rsp), %rdi
callq 0xce98
leaq 0xb8(%rsp), %rdi
callq 0xce98
leaq 0x60(%rsp), %rdi
callq 0xce98
leaq 0x98(%rsp), %rdi
callq 0xce98
leaq 0x97(%rsp), %rdi
callq 0xc7a0
jmp 0x4c75b
movl $0x1, %edi
callq 0xc8d0
movq 0x10(%rsp), %rax
testb $0x1, 0x8(%rax)
jne 0x4c73d
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
callq 0xc870
movq %rax, %rdi
xorl %esi, %esi
callq 0xc870
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x138(%rsp), %rsi
callq 0xc660
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x88(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: 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 Root::saveFile (const string &fName) const
{ 
  if (fName. empty ())
		return;
  OFStream f (fName);  // Declared after Root
  saveText (f);
}

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq 0x230(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x228(%rsp), %rdi
callq 0xcc10
testb $0x1, %al
jne 0x4d717
jmp 0x4d719
jmp 0x4d74f
movq 0x228(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x30040
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x4d745
leaq 0x28(%rsp), %rdi
callq 0x301a0
addq $0x238, %rsp            # imm = 0x238
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x301a0
movq 0x20(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0xb94dd(%rip)     # 0x106c80
jne 0x4d7aa
jmp 0x4d927
movq 0x18(%rsp), %rdi
callq 0x2ab80
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x41300
testb $0x1, %al
jne 0x4d927
movb $0x1, 0x27(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xcd00
movq 0x10(%rsp), %rdx
leaq 0x80d67(%rip), %rsi     # 0xce560
leaq 0x60(%rsp), %rdi
callq 0x29fd0
jmp 0x4d805
leaq 0x80d7e(%rip), %rdx     # 0xce58a
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2a2f0
jmp 0x4d820
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
movl $0x22, %edx
callq 0x424f0
jmp 0x4d83a
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x2dde0
jmp 0x4d856
movq 0x8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xcbb0
jmp 0x4d86a
movq 0x8(%rsp), %rdi
movb $0x0, 0x27(%rsp)
movq 0xb8775(%rip), %rsi     # 0x105ff0
movq 0xb86ee(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x4d939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4d908
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4d8fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4d8f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4d8e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0xce98
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x80(%rsp), %rdi
callq 0xce98
leaq 0x60(%rsp), %rdi
callq 0xce98
leaq 0x5f(%rsp), %rdi
callq 0xc7a0
testb $0x1, 0x27(%rsp)
jne 0x4d91b
jmp 0x4d925
movq 0x8(%rsp), %rdi
callq 0xc580
jmp 0x4d92f
addq $0xc8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movb %cl, 0x87(%rsp)
andb $0x1, %al
movb %al, 0x86(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35160
movq 0x88(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xc320
jmp 0x4dd31
jmp 0x4dd33
leaq 0x60(%rsp), %rdi
callq 0xcc10
xorb $-0x1, %al
testb $0x1, %al
jne 0x4dd45
jmp 0x4ddbe
movsbl 0x87(%rsp), %edx
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x42f40
jmp 0x4dd5e
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2ef10
jmp 0x4dd6f
leaq 0x30(%rsp), %rdi
callq 0xce98
jmp 0x4dd33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x4de8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x4de84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xce98
jmp 0x4de84
movq 0x88(%rsp), %rdi
callq 0xcc10
testb $0x1, %al
jne 0x4de00
movq 0x88(%rsp), %rdi
callq 0xc360
movsbl (%rax), %eax
movsbl 0x87(%rsp), %ecx
cmpl %ecx, %eax
jne 0x4de00
movq 0x8(%rsp), %rdi
leaq 0xb8ea1(%rip), %rsi     # 0x106c98
callq 0x2f170
jmp 0x4ddfe
jmp 0x4de00
testb $0x1, 0x86(%rsp)
je 0x4de72
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2eff0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2f020
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2f050
testb $0x1, %al
jne 0x4de47
jmp 0x4de70
leaq 0x20(%rsp), %rdi
callq 0x2f090
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x73800
jmp 0x4de62
jmp 0x4de64
leaq 0x20(%rsp), %rdi
callq 0x2f0f0
jmp 0x4de32
jmp 0x4de72
leaq 0x60(%rsp), %rdi
callq 0xce98
addq $0x98, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0xce98
movq 0x8(%rsp), %rdi
callq 0x350f0
movq 0x58(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::StringVector::to_xml(Common_sp::Xml::File&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void StringVector::to_xml (Xml::File &f,
                           const string &tag)
{
  if (empty ())
  	return;

  sort ();

  const Xml::Tag xml (f, tag);
  for (const string& s : *this)
  {
	  const Xml::Tag xml_item (f, "item");
    f. print (s);
  }
    
  clear ();
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2f920
testb $0x1, %al
jne 0x4e287
jmp 0x4e28c
jmp 0x4e41b
movq 0x10(%rsp), %rdi
callq 0x32720
movq 0xd8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
movl $0x1, %ecx
callq 0x4d2b0
movq 0x10(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x2eff0
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rdi
callq 0x2f020
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x2f050
testb $0x1, %al
jne 0x4e30d
jmp 0x4e404
leaq 0x90(%rsp), %rdi
callq 0x2f090
movq %rax, 0x80(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x802cb(%rip), %rsi     # 0xce614
leaq 0x30(%rsp), %rdi
callq 0x29fd0
jmp 0x4e355
movq (%rsp), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x1, %ecx
callq 0x4d2b0
jmp 0x4e36f
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x2f(%rsp), %rdi
callq 0xc7a0
movq 0xd8(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x73350
jmp 0x4e39a
leaq 0x50(%rsp), %rdi
callq 0x4d680
leaq 0x90(%rsp), %rdi
callq 0x2f0f0
jmp 0x4e2ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x4e3de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x2f(%rsp), %rdi
callq 0xc7a0
jmp 0x4e423
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4d680
jmp 0x4e423
movq 0x10(%rsp), %rdi
callq 0x32820
leaq 0xa0(%rsp), %rdi
callq 0x4d680
addq $0xe8, %rsp
retq
leaq 0xa0(%rsp), %rdi
callq 0x4d680
movq 0x20(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x18(%rsp), %rax
jne 0x4e460
jmp 0x4e4d4
movq (%rsp), %rdi
callq 0x4e4e0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4e4e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4e4a0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x4e4d4
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x4e4d2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x4e4d4
addq $0x28, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::DisjointCluster::getDisjointCluster()
DisjointCluster* DisjointCluster::getDisjointCluster ()
{ 
  ASSERT (parentDC);
	if (this == parentDC)
	  return this;
	parentDC = parentDC->getDisjointCluster ();
	return parentDC;
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x138(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xc090
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl $0x0, (%rcx)
cmpq $0x0, (%rax)
jne 0x4e77a
callq 0xc8c0
cmpl $0x0, %eax
jne 0x4e770
leaq 0x97(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x7f4d4(%rip), %rsi     # 0xcda19
leaq 0x98(%rsp), %rdi
callq 0x29fd0
jmp 0x4e554
leaq 0x60(%rsp), %rdi
movl $0x831, %esi            # imm = 0x831
callq 0x2ded0
jmp 0x4e565
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x2dde0
jmp 0x4e581
leaq 0x7d619(%rip), %rdx     # 0xcbba1
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x2a2f0
jmp 0x4e59f
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xcd00
movq (%rsp), %rdx
leaq 0x80061(%rip), %rsi     # 0xce619
leaq 0x20(%rsp), %rdi
callq 0x29fd0
jmp 0x4e5c4
leaq 0x7f44b(%rip), %rdx     # 0xcda16
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2a2f0
jmp 0x4e5dc
leaq 0xf8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2dde0
jmp 0x4e5f8
leaq 0x8005c(%rip), %rdx     # 0xce65b
leaq 0x118(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x2a2f0
jmp 0x4e616
leaq 0x118(%rsp), %rdi
callq 0x3e9b0
jmp 0x4e625
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4e761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4e754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4e74a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4e73d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4e726
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4e71c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4e712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4e705
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x118(%rsp), %rdi
callq 0xce98
leaq 0xf8(%rsp), %rdi
callq 0xce98
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
leaq 0x1f(%rsp), %rdi
callq 0xc7a0
leaq 0xd8(%rsp), %rdi
callq 0xce98
leaq 0xb8(%rsp), %rdi
callq 0xce98
leaq 0x60(%rsp), %rdi
callq 0xce98
leaq 0x98(%rsp), %rdi
callq 0xce98
leaq 0x97(%rsp), %rdi
callq 0xc7a0
jmp 0x4e7c6
movl $0x1, %edi
callq 0xc8d0
movq 0x10(%rsp), %rax
cmpq (%rax), %rax
jne 0x4e793
movq 0x10(%rsp), %rax
movq %rax, 0x140(%rsp)
jmp 0x4e7b6
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x4e4e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq (%rax), %rax
movq %rax, 0x140(%rsp)
movq 0x140(%rsp), %rax
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x88(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x18(%rsp)
callq 0x74790
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x23(%rsp)
jne 0x4e822
jmp 0x4e857
xorl %eax, %eax
cmpq $0x0, 0x30(%rsp)
movb %al, 0x23(%rsp)
je 0x4e857
movb $0x1, %al
cmpq $0x0, 0x38(%rsp)
movb %al, 0xf(%rsp)
je 0x4e84f
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
setbe %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movb %al, 0x23(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movb 0x23(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x20, %rdi
movq %rdi, (%rsp)
callq 0xca10
movq 0x10(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x4e8a5
movq 0xb843e(%rip), %rax     # 0x106cd8
addq $0x1, %rax
movq %rax, 0xb8433(%rip)     # 0x106cd8
movq 0x10(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x4e8d7
movq 0x10(%rsp), %rdi
callq 0x4e8f0
jmp 0x4e8bc
jmp 0x4e8d7
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xce98
jmp 0x4e8dc
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x18(%rax)
jne 0x4e918
jmp 0x4eb3d
movq 0xb76c9(%rip), %rdi     # 0x105fe8
movq %rdi, 0x38(%rsp)
movl $0xd, %esi
callq 0xc870
movq 0x38(%rsp), %rdi
leaq 0x7fd2a(%rip), %rsi     # 0xce664
callq 0xc6f0
movq 0x38(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movl $0x20, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x30fc0
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x18(%rax), %rsi
callq 0xc160
jmp 0x4e973
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax)
je 0x4e9c1
movq 0xb7663(%rip), %rdi     # 0x105fe8
leaq 0x7fcdd(%rip), %rsi     # 0xce669
callq 0xc6f0
movq %rax, 0x30(%rsp)
jmp 0x4e998
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rsi
callq 0xc160
jmp 0x4e9ac
jmp 0x4e9c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x4eb45
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xcc10
testb $0x1, %al
jne 0x4ea02
movq 0xb760e(%rip), %rdi     # 0x105fe8
movl $0x20, %esi
callq 0xc870
movq %rax, 0x28(%rsp)
jmp 0x4e9eb
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0x20, %rsi
callq 0xc660
jmp 0x4ea00
jmp 0x4ea02
movq 0xb75df(%rip), %rdi     # 0x105fe8
movl $0x20, %esi
callq 0xc870
jmp 0x4ea15
movb $0x0, 0x4e(%rsp)
movb $0x0, 0x4d(%rsp)
callq 0x74330
movb %al, 0x27(%rsp)
jmp 0x4ea2a
movb 0x27(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x26(%rsp)
jne 0x4ea99
jmp 0x4ea3b
movq 0x40(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xcd00
movq 0x18(%rsp), %rdx
movb $0x1, 0x4e(%rsp)
leaq 0x7f8a9(%rip), %rsi     # 0xce312
leaq 0x50(%rsp), %rdi
callq 0x29fd0
jmp 0x4ea75
movq 0x10(%rsp), %rdi
movb $0x1, 0x4d(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x2f5d0
movb %al, 0xf(%rsp)
jmp 0x4ea8f
movb 0xf(%rsp), %al
xorb $-0x1, %al
movb %al, 0x26(%rsp)
movb 0x26(%rsp), %al
movb %al, 0xe(%rsp)
testb $0x1, 0x4d(%rsp)
jne 0x4eaaa
jmp 0x4eab4
leaq 0x50(%rsp), %rdi
callq 0xce98
testb $0x1, 0x4e(%rsp)
jne 0x4eabd
jmp 0x4eac7
leaq 0x4f(%rsp), %rdi
callq 0xc7a0
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x4ead1
jmp 0x4eb30
movq 0xb7510(%rip), %rdi     # 0x105fe8
leaq 0x7fb8e(%rip), %rsi     # 0xce66d
callq 0xc6f0
jmp 0x4eae6
jmp 0x4eb30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x4eb1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
testb $0x1, 0x4d(%rsp)
jne 0x4eb0f
jmp 0x4eb19
leaq 0x50(%rsp), %rdi
callq 0xce98
jmp 0x4eb1b
testb $0x1, 0x4e(%rsp)
jne 0x4eb24
jmp 0x4eb2e
leaq 0x4f(%rsp), %rdi
callq 0xc7a0
jmp 0x4eb45
leaq 0x80(%rsp), %rdi
callq 0x310f0
addq $0x98, %rsp
retq
leaq 0x80(%rsp), %rdi
callq 0x310f0
movq 0x78(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::~Progress()
Progress::~Progress () 
{ 
	if (! active)
		return;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x8(%rax)
jne 0x4eb82
movl $0x1, 0xc(%rsp)
jmp 0x4ebc9
movq (%rsp), %rdi
callq 0x4e8f0
jmp 0x4eb8d
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4ebaf
movq 0xb7449(%rip), %rdi     # 0x105fe8
movq 0xb739a(%rip), %rsi     # 0x105f40
callq 0xc760
jmp 0x4ebad
jmp 0x4ebaf
movq 0xb8122(%rip), %rax     # 0x106cd8
addq $-0x1, %rax
movq %rax, 0xb8117(%rip)     # 0x106cd8
movl $0x0, 0xc(%rsp)
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0xce98
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x2ad70
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xca10
movq 0x18(%rsp), %rax
movb 0x218(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x50ed2
jmp 0x50f3a
movq 0x18(%rsp), %rdi
callq 0x50020
movb %al, 0x7(%rsp)
jmp 0x50ee2
movq 0x18(%rsp), %rdi
movb 0x7(%rsp), %al
movb %al, 0x36(%rsp)
addq $0x260, %rdi            # imm = 0x260
callq 0x747d0
movb %al, 0x6(%rsp)
jmp 0x50f01
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x50f0b
jmp 0x50f27
jmp 0x50f3a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xce98
jmp 0x50f5a
movq 0x8(%rsp), %rdi
movsbl 0x36(%rsp), %esi
callq 0xc4c0
jmp 0x50f38
jmp 0x50ebf
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x50f50
movq 0x8(%rsp), %rdi
callq 0xce98
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)