LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::section(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline void section (const string &title,
                     bool useAlsoCout)
  { const Color::Type color = Color::cyan;
    const bool bright = false;
    if (useAlsoCout)
    {
      { const OColor oc1 (cout, color, bright, true);
        const OColor oc2 (cerr, color, bright, true);
        couterr << title /*<< " ..."*/;
      }
      couterr << endl;
    }
    else
    {
      { const OColor oc (cerr, color, bright, true);
        cerr << title /*<< " ..."*/;
      }
      cerr << endl;
    }
  }

// Assembly:
subq $0x78, %rsp
movb %sil, %al
movq %rdi, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movl $0x24, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
testb $0x1, 0x6f(%rsp)
je 0x36698
movq 0xcf9af(%rip), %rsi     # 0x105f90
leaq 0x50(%rsp), %rdi
movl $0x24, %edx
movl %edx, 0x14(%rsp)
xorl %ecx, %ecx
movl %ecx, 0x18(%rsp)
movl $0x1, %r8d
movl %r8d, 0x1c(%rsp)
callq 0x30fc0
movl 0x14(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movq 0xcf9cf(%rip), %rsi     # 0x105fe8
leaq 0x40(%rsp), %rdi
callq 0x30fc0
jmp 0x36625
movq 0x70(%rsp), %rsi
leaq 0xd0651(%rip), %rdi     # 0x106c82
callq 0x36720
jmp 0x36638
leaq 0x40(%rsp), %rdi
callq 0x310f0
leaq 0x50(%rsp), %rdi
callq 0x310f0
leaq 0xd062f(%rip), %rdi     # 0x106c82
movq 0xcf8e6(%rip), %rsi     # 0x105f40
callq 0x36770
jmp 0x36705
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x3668c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x310f0
leaq 0x50(%rsp), %rdi
callq 0x310f0
jmp 0x3670a
movq 0xcf949(%rip), %rsi     # 0x105fe8
movq %rsi, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x30fc0
movq 0x8(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xc660
jmp 0x366cc
leaq 0x20(%rsp), %rdi
callq 0x310f0
movq 0xcf90b(%rip), %rdi     # 0x105fe8
movq 0xcf85c(%rip), %rsi     # 0x105f40
callq 0xc760
jmp 0x36705
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x310f0
jmp 0x3670a
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
nop
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::COutErr const& Common_sp::COutErr::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const COutErr& operator<< (const T &val) const
      { cout << val;
        if (! both)
          cerr << val;
        return *this;
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rsi
movq 0xcf84d(%rip), %rdi     # 0x105f90
callq 0xc660
movq (%rsp), %rax
testb $0x1, (%rax)
jne 0x36762
movq 0x8(%rsp), %rsi
movq 0xcf88b(%rip), %rdi     # 0x105fe8
callq 0xc660
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::COutErr::operator<<(std::ostream& (*)(std::ostream&)) const
const COutErr& operator<< (ostream& (*pfun) (ostream&)) const
    { pfun (cout);
      if (! both)
        pfun (cerr);
      return *this;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0xcf802(%rip), %rdi     # 0x105f90
callq *0x8(%rsp)
movq (%rsp), %rax
testb $0x1, (%rax)
jne 0x367a6
movq 0xcf846(%rip), %rdi     # 0x105fe8
callq *0x8(%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Threads::operator<<(std::thread&&)
Threads& operator<< (thread &&t)
	  { if (! getAvailable ())
	  	  throwf ("Too many threads created");
	  	try { threads. push_back (std::move (t)); }
	  	  catch (const exception &e) 
	  	    { throw runtime_error (string ("Cannot start thread\n") + e. what ()); }
	  	return *this;
	  }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x36860
cmpq $0x0, %rax
jne 0x36978
leaq 0x87(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xcd00
movq 0x10(%rsp), %rdx
leaq 0x96854(%rip), %rsi     # 0xcd171
leaq 0x88(%rsp), %rdi
callq 0x29fd0
jmp 0x3692c
leaq 0x88(%rsp), %rdi
callq 0x3e9b0
jmp 0x3693b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x36966
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xce98
leaq 0x87(%rsp), %rdi
callq 0xc7a0
jmp 0x36ac0
movq 0x18(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x36c00
jmp 0x3698c
jmp 0x36ab3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x36ac0
movq 0x78(%rsp), %rdi
callq 0xc2f0
movq %rax, 0x68(%rsp)
movb $0x1, 0x26(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x9679d(%rip), %rsi     # 0xcd18a
leaq 0x28(%rsp), %rdi
callq 0x29fd0
jmp 0x369f9
movq 0x68(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rdx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2a2f0
jmp 0x36a1b
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xcbb0
jmp 0x36a2b
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0xcf5b5(%rip), %rsi     # 0x105ff0
movq 0xcf52e(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x36ad2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x36a8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x36a84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xce98
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x27(%rsp), %rdi
callq 0xc7a0
testb $0x1, 0x26(%rsp)
jne 0x36aa1
jmp 0x36aaa
movq (%rsp), %rdi
callq 0xc580
callq 0xcbe0
jmp 0x36ab1
jmp 0x36ac0
movq 0x18(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0xccf0
movq %rax, %rdi
callq 0x2ad70
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator<(Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) const
bool operator< (const Vector<T> &other) const
      // Lexicographic comparison
      { const size_t n = std::min (P::size (), other. size ());
        for (size_t i = 0; i < n; i++)
      	{ if ((*this) [i] < other [i]) return true;
      		if (other [i] < (*this) [i]) return false;
        }
        return P::size () < other. size ();
      }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2f390
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2f390
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2fb00
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x3ba50
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f4e0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f4e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2c7d0
testb $0x1, %al
jne 0x3b9f7
jmp 0x3b9fe
movb $0x1, 0x57(%rsp)
jmp 0x3ba7b
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f4e0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x2f4e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2c7d0
testb $0x1, %al
jne 0x3ba34
jmp 0x3ba3b
movb $0x0, 0x57(%rsp)
jmp 0x3ba7b
jmp 0x3ba3d
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x3b9b1
movq 0x18(%rsp), %rdi
callq 0x2f390
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x2f390
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::get_threads_max_max()
size_t get_threads_max_max () 
{
#ifdef __APPLE__
//stderr << "Compiled for MacOS" << "\n";
  int count = 0;
  /*const*/ size_t count_len = sizeof(count);
  sysctlbyname ("hw.logicalcpu", &count, &count_len, nullptr, 0);
//fprintf(stderr,"you have %i cpu cores", count);
  ASSERT (count >= 0);
  return (size_t) count;
#else
  LineInput f ("/proc/cpuinfo");
  size_t n = 0;
  while (f. nextLine ())
    if (isLeft (f. line, "processor"))
      n++;
  return n;
#endif
}

// Assembly:
subq $0x348, %rsp            # imm = 0x348
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xcd00
movq 0x30(%rsp), %rdx
leaq 0x907ae(%rip), %rsi     # 0xcd9a0
leaq 0x80(%rsp), %rdi
callq 0x29fd0
jmp 0x3d201
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
xorl %edx, %edx
callq 0x2f200
jmp 0x3d21a
leaq 0x80(%rsp), %rdi
callq 0xce98
leaq 0x7f(%rsp), %rdi
callq 0xc7a0
movq $0x0, 0x60(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x3d390
movb %al, 0x2f(%rsp)
jmp 0x3d24d
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x3d25a
jmp 0x3d354
leaq 0x308(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xcd00
movq 0x20(%rsp), %rdx
leaq 0x9072c(%rip), %rsi     # 0xcd9ae
leaq 0x40(%rsp), %rdi
callq 0x29fd0
jmp 0x3d28e
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2f2f0
movb %al, 0x17(%rsp)
jmp 0x3d2a3
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x3f(%rsp), %rdi
callq 0xc7a0
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3d2c4
jmp 0x3d34f
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x3d34f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x3d2ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xce98
leaq 0x7f(%rsp), %rdi
callq 0xc7a0
jmp 0x3d385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x3d378
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x3d343
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x3f(%rsp), %rdi
callq 0xc7a0
jmp 0x3d378
jmp 0x3d23a
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x2f490
movq 0x8(%rsp), %rax
addq $0x348, %rsp            # imm = 0x348
retq
leaq 0xa0(%rsp), %rdi
callq 0x2f490
movq 0x70(%rsp), %rdi
callq 0xccf0
nop
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::(anonymous namespace)::sigpipe_handler(int)
[[noreturn]] void sigpipe_handler (int /*sig_num*/) 
{
  signal (SIGPIPE, SIG_DFL);
  if (sigpipe)
    exit (0);
  exit (1);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl $0xd, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xc890
testb $0x1, 0xc91a7(%rip)     # 0x106c81
je 0x3dae3
xorl %edi, %edi
callq 0xc8d0
movl $0x1, %edi
callq 0xc8d0
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::beep()
void beep ()
{ 
  if (getEnv ("SHLVL") != "1")
    return;
	constexpr char c = '\x07';
	if (! isRedirected (cerr))
	  cerr << c;
	else if (! isRedirected (cout))
	  cout << c;
}

// Assembly:
subq $0x68, %rsp
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x8f203(%rip), %rsi     # 0xcda72
leaq 0x28(%rsp), %rdi
callq 0x29fd0
jmp 0x3e87b
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x73260
jmp 0x3e88c
leaq 0x900f4(%rip), %rsi     # 0xce987
leaq 0x48(%rsp), %rdi
callq 0x73380
movb %al, 0x7(%rsp)
jmp 0x3e8a3
leaq 0x48(%rsp), %rdi
callq 0xce98
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x27(%rsp), %rdi
callq 0xc7a0
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x3e8cb
jmp 0x3e91e
jmp 0x3e969
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x3e912
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x3e908
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xce98
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x27(%rsp), %rdi
callq 0xc7a0
jmp 0x3e96e
movb $0x7, 0x13(%rsp)
movq 0xc76be(%rip), %rdi     # 0x105fe8
callq 0x3ee30
testb $0x1, %al
jne 0x3e946
movq 0xc76ae(%rip), %rdi     # 0x105fe8
movl $0x7, %esi
callq 0xc870
jmp 0x3e969
movq 0xc7643(%rip), %rdi     # 0x105f90
callq 0x3ee30
testb $0x1, %al
jne 0x3e967
movq 0xc7633(%rip), %rdi     # 0x105f90
movl $0x7, %esi
callq 0xc870
jmp 0x3e969
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::isRedirected(std::ostream const&)
bool isRedirected (const ostream &os)
{ 
#ifdef _MSC_VER
  return false;
#else
	if (& os == & cout)
	  return ! isatty (fileno (stdout));
	if (& os == & cerr)
	  return ! isatty (fileno (stderr));
	if (& os == & clog)
	  return ! isatty (fileno (stderr));
	return false;
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0xc7150(%rip), %rax     # 0x105f90
cmpq %rax, 0x8(%rsp)
jne 0x3ee6d
movq 0xc70d2(%rip), %rax     # 0x105f20
movq (%rax), %rdi
callq 0xc780
movl %eax, %edi
callq 0xccd0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x3eeda
movq 0xc7174(%rip), %rax     # 0x105fe8
cmpq %rax, 0x8(%rsp)
jne 0x3eea1
movq 0xc711e(%rip), %rax     # 0x105fa0
movq (%rax), %rdi
callq 0xc780
movl %eax, %edi
callq 0xccd0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x3eeda
movq 0xc7088(%rip), %rax     # 0x105f30
cmpq %rax, 0x8(%rsp)
jne 0x3eed5
movq 0xc70ea(%rip), %rax     # 0x105fa0
movq (%rax), %rdi
callq 0xc780
movl %eax, %edi
callq 0xccd0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x3eeda
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Chronometer::start()
void Chronometer::start ()
{ 
  if (! on ())
    return;
  if (started ())
    throw runtime_error (FUNC "Chronometer \""  + name + "\" is not stopped");
  startTime = clock (); 
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x733b0
testb $0x1, %al
jne 0x3f1fa
jmp 0x3f36c
movq 0x10(%rsp), %rdi
callq 0x733e0
testb $0x1, %al
jne 0x3f20d
jmp 0x3f35b
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x8e83d(%rip), %rsi     # 0xcda78
leaq 0x30(%rsp), %rdi
callq 0x29fd0
jmp 0x3f247
leaq 0x8e84f(%rip), %rdx     # 0xcda9d
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2a2f0
jmp 0x3f25f
movq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2e220
jmp 0x3f275
leaq 0x8e831(%rip), %rdx     # 0xcdaad
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2a2f0
jmp 0x3f290
movq (%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xcbb0
jmp 0x3f2a3
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0xc6d3d(%rip), %rsi     # 0x105ff0
movq 0xc6cb6(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x3f37e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3f33d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3f333
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3f329
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3f31f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xce98
leaq 0x70(%rsp), %rdi
callq 0xce98
leaq 0x50(%rsp), %rdi
callq 0xce98
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x2f(%rsp), %rdi
callq 0xc7a0
testb $0x1, 0x1b(%rsp)
jne 0x3f350
jmp 0x3f359
movq (%rsp), %rdi
callq 0xc580
jmp 0x3f374
callq 0xc4f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nop
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Chronometer::stop()
void Chronometer::stop () 
{ 
  if (! on ())
    return;
  if (! started ())
    throw runtime_error (FUNC "Chronometer \"" + name + "\" is not started");
  time += clock () - startTime; 
  startTime = noclock;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x733b0
testb $0x1, %al
jne 0x3f3aa
jmp 0x3f52b
movq 0x10(%rsp), %rdi
callq 0x733e0
testb $0x1, %al
jne 0x3f50a
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x8e6d4(%rip), %rsi     # 0xcdabe
leaq 0x30(%rsp), %rdi
callq 0x29fd0
jmp 0x3f3f6
leaq 0x8e6a0(%rip), %rdx     # 0xcda9d
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2a2f0
jmp 0x3f40e
movq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2e220
jmp 0x3f424
leaq 0x8e6b7(%rip), %rdx     # 0xcdae2
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2a2f0
jmp 0x3f43f
movq (%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xcbb0
jmp 0x3f452
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0xc6b8e(%rip), %rsi     # 0x105ff0
movq 0xc6b07(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x3f53d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3f4ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3f4e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3f4d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3f4ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xce98
leaq 0x70(%rsp), %rdi
callq 0xce98
leaq 0x50(%rsp), %rdi
callq 0xce98
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x2f(%rsp), %rdi
callq 0xc7a0
testb $0x1, 0x1b(%rsp)
jne 0x3f4ff
jmp 0x3f508
movq (%rsp), %rdi
callq 0xc580
jmp 0x3f533
callq 0xc4f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq 0x28(%rax), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq $-0x1, 0x28(%rax)
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Chronometer::print(std::ostream&) const
void Chronometer::print (ostream &os) const
{ 
  if (! on ())
    return;       
  os << "CHRON: " << name << ": ";
  const ONumber onm (os, 2, false);
  os << (double) time / CLOCKS_PER_SEC << " sec." << endl;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x733b0
testb $0x1, %al
jne 0x3f566
jmp 0x3f606
movq 0x48(%rsp), %rdi
leaq 0x8e581(%rip), %rsi     # 0xcdaf3
callq 0xc6f0
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0xc660
movq %rax, %rdi
leaq 0x8e45a(%rip), %rsi     # 0xcd9e8
callq 0xc6f0
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x73400
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rdi
cvtsi2sdq 0x20(%rax), %xmm0
movsd 0x8dfbf(%rip), %xmm1    # 0xcd580
divsd %xmm1, %xmm0
callq 0xcdd0
movq %rax, 0x10(%rsp)
jmp 0x3f5d1
movq 0x10(%rsp), %rdi
leaq 0x8e51e(%rip), %rsi     # 0xcdafb
callq 0xc6f0
movq %rax, 0x8(%rsp)
jmp 0x3f5e9
movq 0x8(%rsp), %rdi
movq 0xc694b(%rip), %rsi     # 0x105f40
callq 0xc760
jmp 0x3f5fc
leaq 0x30(%rsp), %rdi
callq 0x734b0
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x734b0
movq 0x28(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Chronometer_OnePass::~Chronometer_OnePass()
Chronometer_OnePass::~Chronometer_OnePass ()
{ 
  if (! active)
    return;
  if (uncaught_exceptions ())
    return;
    
  const time_t stop = time (nullptr);
  
  {
    const OColor oc (os, color, false, true);  
    os << "CHRON: " << name << ": ";
    const ONumber on (os, 0, false);
    os << difftime (stop, start) << " sec.";
  }
  os << endl;  

  if (addNewLine)
    os << endl;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
testb $0x1, 0x29(%rax)
jne 0x3f6f6
movl $0x1, 0x6c(%rsp)
jmp 0x3f83b
callq 0xc8c0
cmpl $0x0, %eax
je 0x3f70d
movl $0x1, 0x6c(%rsp)
jmp 0x3f83b
xorl %eax, %eax
movl %eax, 0x2c(%rsp)
movl %eax, %edi
callq 0xc6c0
movl 0x2c(%rsp), %ecx
movq %rax, %rdx
movq 0x30(%rsp), %rax
movq %rdx, 0x60(%rsp)
movq 0x20(%rax), %rsi
leaq 0x50(%rsp), %rdi
movl $0x23, %edx
movl $0x1, %r8d
callq 0x30fc0
jmp 0x3f746
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x8e39d(%rip), %rsi     # 0xcdaf3
callq 0xc6f0
movq %rax, 0x20(%rsp)
jmp 0x3f762
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0xc660
movq %rax, 0x18(%rsp)
jmp 0x3f778
movq 0x18(%rsp), %rdi
leaq 0x8e264(%rip), %rsi     # 0xcd9e8
callq 0xc6f0
jmp 0x3f78b
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
leaq 0x38(%rsp), %rdi
callq 0x73400
jmp 0x3f7a4
movq 0x30(%rsp), %rax
movq 0x60(%rsp), %rdi
movq 0x20(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x30(%rax), %rsi
callq 0xc3d0
movq 0x8(%rsp), %rdi
callq 0xcdd0
movq %rax, 0x10(%rsp)
jmp 0x3f7d1
movq 0x10(%rsp), %rdi
leaq 0x8e31e(%rip), %rsi     # 0xcdafb
callq 0xc6f0
jmp 0x3f7e4
leaq 0x38(%rsp), %rdi
callq 0x734b0
leaq 0x50(%rsp), %rdi
callq 0x310f0
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0xc6738(%rip), %rsi     # 0x105f40
callq 0xc760
jmp 0x3f80f
movq 0x30(%rsp), %rax
testb $0x1, 0x28(%rax)
je 0x3f833
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0xc6716(%rip), %rsi     # 0x105f40
callq 0xc760
jmp 0x3f831
jmp 0x3f833
movl $0x0, 0x6c(%rsp)
movq 0x30(%rsp), %rdi
callq 0xce98
addq $0x78, %rsp
retq
movq %rax, %rdi
callq 0x2ad70
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::byte2first(unsigned char)
size_t byte2first (uchar b)
{ 
  if (! b)
    return sizeof (uchar);
	const uint u = b;
	size_t i = 0;
	uint mask = 1;
	while (! contains (u, mask))
	{
		i++;
		mask <<= 1;
	}
	return i;
}

// Assembly:
subq $0x28, %rsp
movb %dil, %al
movb %al, 0x1f(%rsp)
cmpb $0x0, 0x1f(%rsp)
jne 0x3f87d
movq $0x1, 0x20(%rsp)
jmp 0x3f8d0
movzbl 0x1f(%rsp), %eax
movl %eax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0x18(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x73500
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f8ac
jmp 0x3f8c6
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
jmp 0x3f897
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::utf8_len(char)
size_t utf8_len (char first)
{
	const uint u = numeric_limits<uint>::max () - (uchar) first;
	size_t len = 0;
	uint mask = 0x80;
	while (! contains (u, mask))
	{
		len++;
	  mask >>= 1;
	}
	return len;
}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
movb %al, 0x17(%rsp)
callq 0x73520
movzbl 0x17(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x80, 0x4(%rsp)
movl 0x10(%rsp), %edi
movl 0x4(%rsp), %esi
callq 0x73500
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f921
jmp 0x3f93b
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
shrl %eax
movl %eax, 0x4(%rsp)
jmp 0x3f90c
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::powInt(unsigned long, unsigned long)
size_t powInt (size_t a,
               size_t b)
{
	if (a)
		if (a == 1)
			return 1;
		else
			return powInt_ (a, b);
	else
		if (b)
			return 0;
		else
			throw runtime_error (FUNC "powInt: 0^0");
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x3f99e
cmpq $0x1, 0x78(%rsp)
jne 0x3f982
movq $0x1, 0x80(%rsp)
jmp 0x3fa9b
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x3fac0
movq %rax, 0x80(%rsp)
jmp 0x3fa9b
cmpq $0x0, 0x70(%rsp)
je 0x3f9b7
movq $0x0, 0x80(%rsp)
jmp 0x3fa9b
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xcd00
movq 0x10(%rsp), %rdx
leaq 0x8e11b(%rip), %rsi     # 0xcdb01
leaq 0x30(%rsp), %rdi
callq 0x29fd0
jmp 0x3f9f2
leaq 0x8e131(%rip), %rdx     # 0xcdb2a
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2a2f0
jmp 0x3fa0a
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xcbb0
jmp 0x3fa1b
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0xc65c4(%rip), %rsi     # 0x105ff0
movq 0xc653d(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x3fab5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3fa7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3fa72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xce98
leaq 0x30(%rsp), %rdi
callq 0xce98
leaq 0x2f(%rsp), %rdi
callq 0xc7a0
testb $0x1, 0x1b(%rsp)
jne 0x3fa8f
jmp 0x3fa99
movq 0x8(%rsp), %rdi
callq 0xc580
jmp 0x3faab
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::(anonymous namespace)::powInt_(unsigned long, unsigned long)
size_t powInt_ (size_t a,
                size_t b)
// Input: a: !0, != 1
{
	if (! b)
		return 1;
	if (b == 1)
		return a;
	const size_t half = b / 2;
	const size_t res = powInt_ (a, half);
	return res * res * (divisible (b, 2) ? 1 : a);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3fae4
movq $0x1, 0x30(%rsp)
jmp 0x3fb64
cmpq $0x1, 0x20(%rsp)
jne 0x3faf8
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3fb64
movq 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3fac0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
imulq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x78440
testb $0x1, %al
jne 0x3fb3e
jmp 0x3fb49
movl $0x1, %eax
movq %rax, (%rsp)
jmp 0x3fb52
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
imulq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::nonPrintable2str[abi:cxx11](char)
string nonPrintable2str (char c)
{
	string s;
	switch (c)
	{
		case  7: s = "BEL"; break;
		case  8: s = "BS"; break;
		case  9: s = "TAB"; break;
		case 10: s = "LF"; break;
		case 12: s = "FF"; break;
		case 13: s = "CR"; break;
		case 27: s = "ESC"; break;
		case 32: s = "SPACE"; break;
		default: s = "x" + uchar2hex ((uchar) c);
	}	  	
	return "<" + s + ">";
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, (%rsp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0xb0(%rsp)
movb %al, 0xaf(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xca10
movsbl 0xaf(%rsp), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x19, %eax
ja 0x401da
movq 0x10(%rsp), %rax
leaq 0x8d4a7(%rip), %rcx     # 0xcd590
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8da41(%rip), %rsi     # 0xcdb3a
leaq 0x88(%rsp), %rdi
callq 0xca00
jmp 0x40108
jmp 0x4022c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x402ba
leaq 0x8da14(%rip), %rsi     # 0xcdb3e
leaq 0x88(%rsp), %rdi
callq 0xca00
jmp 0x40139
jmp 0x4022c
leaq 0x8d9fc(%rip), %rsi     # 0xcdb41
leaq 0x88(%rsp), %rdi
callq 0xca00
jmp 0x40154
jmp 0x4022c
leaq 0x8d9e5(%rip), %rsi     # 0xcdb45
leaq 0x88(%rsp), %rdi
callq 0xca00
jmp 0x4016f
jmp 0x4022c
leaq 0x8d9cd(%rip), %rsi     # 0xcdb48
leaq 0x88(%rsp), %rdi
callq 0xca00
jmp 0x4018a
jmp 0x4022c
leaq 0x8d9b5(%rip), %rsi     # 0xcdb4b
leaq 0x88(%rsp), %rdi
callq 0xca00
jmp 0x401a5
jmp 0x4022c
leaq 0x8d99d(%rip), %rsi     # 0xcdb4e
leaq 0x88(%rsp), %rdi
callq 0xca00
jmp 0x401c0
jmp 0x4022c
leaq 0x8d989(%rip), %rsi     # 0xcdb52
leaq 0x88(%rsp), %rdi
callq 0xca00
jmp 0x401d8
jmp 0x4022c
movzbl 0xaf(%rsp), %esi
leaq 0x38(%rsp), %rdi
callq 0x735c0
jmp 0x401ee
leaq 0x8e7f5(%rip), %rsi     # 0xce9ea
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x2a340
jmp 0x40206
leaq 0x88(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xc8f0
leaq 0x58(%rsp), %rdi
callq 0xce98
leaq 0x38(%rsp), %rdi
callq 0xce98
leaq 0x8d925(%rip), %rsi     # 0xcdb58
leaq 0x18(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x2a1c0
jmp 0x40247
movq (%rsp), %rdi
leaq 0x8fd5f(%rip), %rdx     # 0xcffb1
leaq 0x18(%rsp), %rsi
callq 0x2a2f0
jmp 0x4025e
leaq 0x18(%rsp), %rdi
callq 0xce98
leaq 0x88(%rsp), %rdi
callq 0xce98
movq 0x8(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xce98
jmp 0x402ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xce98
leaq 0x88(%rsp), %rdi
callq 0xce98
movq 0x80(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::to_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string to_url (const string &s)
{
  string url;
  for (const char c : s)
    if (   isLetter (c)
        || isDigit (c)
        || c == '_'
       )
      url += c;
    else
      url += "%" + uchar2hex ((uchar) c);
      
  return url;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movb $0x0, 0x97(%rsp)
callq 0xca10
movq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0xcd90
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x40363
jmp 0x40475
leaq 0x80(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0x77(%rsp)
movsbl 0x77(%rsp), %edi
callq 0x73730
movb %al, 0xf(%rsp)
jmp 0x40386
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x403b4
jmp 0x40390
movsbl 0x77(%rsp), %edi
callq 0x73780
movb %al, 0xe(%rsp)
jmp 0x403a0
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x403b4
jmp 0x403aa
movsbl 0x77(%rsp), %eax
cmpl $0x5f, %eax
jne 0x403dd
movq 0x10(%rsp), %rdi
movsbl 0x77(%rsp), %esi
callq 0xc4c0
jmp 0x403c5
jmp 0x40461
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x4049e
movzbl 0x77(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x735c0
jmp 0x403ee
leaq 0x8d765(%rip), %rsi     # 0xcdb5a
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2a340
jmp 0x40406
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xc960
jmp 0x40417
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
jmp 0x40461
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x40455
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
jmp 0x4049e
jmp 0x40463
leaq 0x80(%rsp), %rdi
callq 0x737b0
jmp 0x40348
movb $0x1, 0x97(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x40491
movq 0x10(%rsp), %rdi
callq 0xce98
movq 0x18(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xce98
movq 0x68(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::trimPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool trimPrefix (string &s,
                 const string &prefix)
{
  if (! isLeft (s, prefix))
    return false;
  s. erase (0, prefix. size ());
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f2f0
testb $0x1, %al
jne 0x40598
movb $0x0, 0x27(%rsp)
jmp 0x405c2
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xc530
movq 0x8(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc150
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::trimSuffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool trimSuffix (string &s,
                 const string &suffix)
{
  if (! isRight (s, suffix))
    return false;
  s. erase (s. size () - suffix. size ());
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x404c0
testb $0x1, %al
jne 0x405f8
movb $0x0, 0x27(%rsp)
jmp 0x40637
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc530
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xc530
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
subq %rax, %rsi
movq $-0x1, %rdx
callq 0xc150
movb $0x1, 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::trimSuffixNonAlphaNum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trimSuffixNonAlphaNum (string &s)
{
  for (;;)
  {
    trimTrailing (s);
    if (s. empty ())
      break;
    const size_t pos = s. size () - 1;
    if (   isAlpha (s [pos])
        || isDigit (s [pos])
       )
      break;
    s. erase (pos);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x406f0
movq 0x10(%rsp), %rdi
callq 0xcc10
testb $0x1, %al
jne 0x40673
jmp 0x40675
jmp 0x406dd
movq 0x10(%rsp), %rdi
callq 0xc530
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xce50
movsbl (%rax), %edi
callq 0x737d0
testb $0x1, %al
jne 0x406c0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xce50
movsbl (%rax), %edi
callq 0x73780
testb $0x1, %al
jne 0x406c0
jmp 0x406c2
jmp 0x406dd
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq $-0x1, %rdx
callq 0xc150
jmp 0x40659
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::trimTrailing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trimTrailing (string &s)
{
	size_t i = s. size ();
	while (i)
		if (isSpace (s [i - 1]))
			i--;
		else
			break;
  s. erase (i);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xc530
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x40745
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
subq $0x1, %rsi
callq 0xce50
movsbl (%rax), %edi
callq 0x73840
testb $0x1, %al
jne 0x40731
jmp 0x40741
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x40743
jmp 0x40745
jmp 0x40708
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq $-0x1, %rdx
callq 0xc150
addq $0x18, %rsp
retq
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::trimTailAt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool trimTailAt (string &s,
                 const string &tailStart)
{
  const size_t pos = s. find (tailStart);
  const bool trimmed = pos != string::npos;
  if (trimmed)
    s. erase (pos);
  return trimmed;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xce60
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x10(%rsp)
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x407b2
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq $-0x1, %rdx
callq 0xc150
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::commaize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void commaize (string &s)
{
  trim (s);
  replace (s, '\t', ' ');
  replace (s, ',', ' ');
  replaceStr (s, "  ", " ");
  replace (s, ' ', ',');
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x73800
movq 0x80(%rsp), %rdi
movl $0x9, %esi
movl $0x20, %edx
movl %edx, 0xc(%rsp)
callq 0x40930
movl 0xc(%rsp), %edx
movq 0x80(%rsp), %rdi
movl $0x2c, %esi
callq 0x40930
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xcd00
movq 0x18(%rsp), %rdx
leaq 0x8f0f8(%rip), %rsi     # 0xcf92d
leaq 0x60(%rsp), %rdi
callq 0x29fd0
jmp 0x40841
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xcd00
movq (%rsp), %rdx
leaq 0x8f0d4(%rip), %rsi     # 0xcf92e
leaq 0x28(%rsp), %rdi
callq 0x29fd0
jmp 0x40866
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x409d0
jmp 0x4087c
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x27(%rsp), %rdi
callq 0xc7a0
leaq 0x60(%rsp), %rdi
callq 0xce98
leaq 0x5f(%rsp), %rdi
callq 0xc7a0
movq 0x80(%rsp), %rdi
movl $0x20, %esi
movl $0x2c, %edx
callq 0x40930
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4090f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x408fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xce98
leaq 0x27(%rsp), %rdi
callq 0xc7a0
leaq 0x60(%rsp), %rdi
callq 0xce98
leaq 0x5f(%rsp), %rdi
callq 0xc7a0
movq 0x50(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::goodName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool goodName (const string &name)
{
  if (name. empty ())
    return false;
  if (name. front () == ' ')
    return false;
  if (name. back () == ' ')
    return false;

  for (const char c : name)  
    if (! printable (c))
      return false;
      
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xcc10
testb $0x1, %al
jne 0x41319
jmp 0x41323
movb $0x0, 0x37(%rsp)
jmp 0x413cd
movq 0x28(%rsp), %rdi
callq 0xc910
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4133f
movb $0x0, 0x37(%rsp)
jmp 0x413cd
movq 0x28(%rsp), %rdi
callq 0xc360
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x41358
movb $0x0, 0x37(%rsp)
jmp 0x413cd
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xcd90
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x41395
jmp 0x413c8
leaq 0x18(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %edi
callq 0x73820
testb $0x1, %al
jne 0x413ba
movb $0x0, 0x37(%rsp)
jmp 0x413cd
jmp 0x413bc
leaq 0x18(%rsp), %rdi
callq 0x737b0
jmp 0x41380
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::isIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool isIdentifier (const string& name,
                   bool dashInName)
{
  if (name. empty ())
    return false;
  if (isDigit (name [0]))
    return false;
  if (dashInName && name [0] == '-')
    return false;
  for (const char c : name)
    if (! isLetter (c) && (! dashInName || c != '-'))
      return false;
  return true;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rdi
callq 0xcc10
testb $0x1, %al
jne 0x41402
jmp 0x4140c
movb $0x0, 0x37(%rsp)
jmp 0x414df
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc7d0
movsbl (%rax), %edi
callq 0x73780
testb $0x1, %al
jne 0x41428
jmp 0x41432
movb $0x0, 0x37(%rsp)
jmp 0x414df
testb $0x1, 0x27(%rsp)
je 0x41459
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc7d0
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x41459
movb $0x0, 0x37(%rsp)
jmp 0x414df
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xcd90
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x41496
jmp 0x414da
leaq 0x10(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0x7(%rsp)
movsbl 0x7(%rsp), %edi
callq 0x73730
testb $0x1, %al
jne 0x414cc
testb $0x1, 0x27(%rsp)
je 0x414c5
movsbl 0x7(%rsp), %eax
cmpl $0x2d, %eax
je 0x414cc
movb $0x0, 0x37(%rsp)
jmp 0x414df
jmp 0x414ce
leaq 0x10(%rsp), %rdi
callq 0x737b0
jmp 0x41481
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::isNatural(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool isNatural (const string& name,
                bool leadingZeroAllowed)
{
  if (name. empty ())
    return false;
  for (const char c : name)
    if (! isDigit (c))
      return false;
  if (name. size () == 1)
    return true;
  if (! leadingZeroAllowed && name [0] == '0')
    return false;
  return true;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rdi
callq 0xcc10
testb $0x1, %al
jne 0x41512
jmp 0x4151c
movb $0x0, 0x37(%rsp)
jmp 0x415cc
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xcd90
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x41559
jmp 0x4158c
leaq 0x10(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0x7(%rsp)
movsbl 0x7(%rsp), %edi
callq 0x73780
testb $0x1, %al
jne 0x4157e
movb $0x0, 0x37(%rsp)
jmp 0x415cc
jmp 0x41580
leaq 0x10(%rsp), %rdi
callq 0x737b0
jmp 0x41544
movq 0x28(%rsp), %rdi
callq 0xc530
cmpq $0x1, %rax
jne 0x415a3
movb $0x1, 0x37(%rsp)
jmp 0x415cc
testb $0x1, 0x27(%rsp)
jne 0x415c7
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc7d0
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x415c7
movb $0x0, 0x37(%rsp)
jmp 0x415cc
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::strBlank(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool strBlank (const string &s)
{
  for (const char c : s)
    if (! isSpace (c))
      return false;
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xcd90
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x41626
jmp 0x41659
leaq 0x18(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %edi
callq 0x73840
testb $0x1, %al
jne 0x4164b
movb $0x0, 0x37(%rsp)
jmp 0x4165e
jmp 0x4164d
leaq 0x18(%rsp), %rdi
callq 0x737b0
jmp 0x41611
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::isUpper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isUpper (const string &s)
{
  for (const char c : s)
    if (! isUpper (c))
    	return false;
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xcd90
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x41b86
jmp 0x41bb9
leaq 0x18(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %edi
callq 0x73940
testb $0x1, %al
jne 0x41bab
movb $0x0, 0x37(%rsp)
jmp 0x41bbe
jmp 0x41bad
leaq 0x18(%rsp), %rdi
callq 0x737b0
jmp 0x41b71
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::isLower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isLower (const string &s)
{
  for (const char c : s)
    if (! isLower (c))
    	return false;
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xcd90
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x41c16
jmp 0x41c49
leaq 0x18(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %edi
callq 0x73970
testb $0x1, %al
jne 0x41c3b
movb $0x0, 0x37(%rsp)
jmp 0x41c4e
jmp 0x41c3d
leaq 0x18(%rsp), %rdi
callq 0x737b0
jmp 0x41c01
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::stringNotInSet(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&, Common_sp::ebool)
size_t stringNotInSet (const string &s,
                   	   const string &charSet,
                   	   ebool uppercase)
{
  FFOR (size_t, i, s. size ())
  {
    char c = s [i];
    switch (uppercase)
    {
      case efalse: c = toLower (c); break;
      case etrue:  c = toUpper (c); break;
      case enull: break;
    }
    if (! charInSet (c, charSet))
      return i;
  }
  return no_index;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc530
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x41d28
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc7d0
movb (%rax), %al
movb %al, 0x7(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
testl %eax, %eax
je 0x41cd0
jmp 0x41cbc
movl (%rsp), %eax
subl $0x1, %eax
je 0x41ce0
jmp 0x41cc6
movl (%rsp), %eax
subl $0x2, %eax
je 0x41cf0
jmp 0x41cf2
movsbl 0x7(%rsp), %edi
callq 0x73920
movb %al, 0x7(%rsp)
jmp 0x41cf2
movsbl 0x7(%rsp), %edi
callq 0x738e0
movb %al, 0x7(%rsp)
jmp 0x41cf2
jmp 0x41cf2
movb 0x7(%rsp), %al
movq 0x20(%rsp), %rsi
movsbl %al, %edi
callq 0x739a0
testb $0x1, %al
jne 0x41d13
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x41d31
jmp 0x41d15
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x41c8a
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::strCountSet(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 strCountSet (const string &s,
 		                const string &charSet)
{
  size_t n = 0;
  for (const char c : s)
	  if (charInSet (c, charSet))		
	    n++;
  return n;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xcd90
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x41d94
jmp 0x41dd7
leaq 0x10(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movq 0x28(%rsp), %rsi
movsbl %al, %edi
callq 0x739a0
testb $0x1, %al
jne 0x41dbb
jmp 0x41dc9
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x41dcb
leaq 0x10(%rsp), %rdi
callq 0x737b0
jmp 0x41d7f
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::trimTrailing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
void trimTrailing (string &s,
                   char c)
{
	size_t i = s. size ();
	while (i)
		if (s [i - 1] == c)
			i--;
		else
			break;
  s. erase (i);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
callq 0xc530
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x41fe5
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
subq $0x1, %rsi
callq 0xce50
movsbl (%rax), %eax
movsbl 0xf(%rsp), %ecx
cmpl %ecx, %eax
jne 0x41fe1
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x41fe3
jmp 0x41fe5
jmp 0x41fae
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq $-0x1, %rdx
callq 0xc150
addq $0x18, %rsp
retq
nop