LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<Alignment_sp::AmrMutation>::checkIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) const
void checkIndex (const string &operation,
  	                 size_t index) const
  	  {
  	  #ifndef NDEBUG
  	    if (index >= P::size ())
  	      throw runtime_error ("Vector " + operation + " operation: index = " + to_string (index) + ", but size = " + to_string (P::size ()));
  	  #endif
  	  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r15
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movl $0x128, %ecx            # imm = 0x128
cqto
idivq %rcx
cmpq %r15, %rax
jbe 0x46912
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r12
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0xc310
movq %rax, %rbx
leaq 0x1a60b(%rip), %rsi     # 0x60f35
leaq 0x40(%rsp), %rdi
movq %r12, %rdx
callq 0x2a1c8
leaq 0x1a5ff(%rip), %rdx     # 0x60f3d
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xe24f
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xe83d
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xe26e
leaq 0x1a5da(%rip), %rdx     # 0x60f52
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xe24f
movq 0x8(%r14), %rax
subq (%r14), %rax
movl $0x128, %ecx            # imm = 0x128
cqto
idivq %rcx
movq %rsp, %rdi
movq %rax, %rsi
callq 0xe83d
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movq %rsp, %rdx
callq 0xe26e
movb $0x1, %bpl
leaq 0xc0(%rsp), %rsi
movq %rbx, %rdi
callq 0xc990
xorl %ebp, %ebp
movq 0x42613(%rip), %rsi     # 0x88ff0
movq 0x42584(%rip), %rdx     # 0x88f68
movq %rbx, %rdi
callq 0xca40
movq %rax, %r14
leaq 0xc0(%rsp), %rdi
callq 0xcbe8
jmp 0x46a04
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xcbe8
jmp 0x46a14
movq %rax, %r14
movb $0x1, %bpl
leaq 0xa0(%rsp), %rdi
callq 0xcbe8
jmp 0x46a29
movq %rax, %r14
movb $0x1, %bpl
leaq 0x80(%rsp), %rdi
callq 0xcbe8
jmp 0x46a3e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xcbe8
jmp 0x46a50
movq %rax, %r14
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0xcbe8
jmp 0x46a62
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0xcbe8
testb %bpl, %bpl
jne 0x46a76
jmp 0x46a7e
movq %rax, %r14
movq %rbx, %rdi
callq 0xc470
movq %r14, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::printCase(std::ostream&, bool) const
void Seq::printCase (ostream &os,
              	     bool makeUpper) const
{
  os << ">" << name;

  CONST_ITER (string, it, seq)
  {
    if ((size_t) (it - seq. begin ()) % fastaLineLen == 0)
    	os << endl;

    char c = *it;
    if (makeUpper)
     	c = toUpper (c);
    os << c;
  }
  os << endl;
  
  ASSERT (os. good ());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18cd4(%rip), %rsi     # 0x60e36
movq %rbx, %rdi
callq 0xc5a0
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0xc540
movq 0x28(%r14), %r15
pushq $0x50
popq %r12
movq %r15, %rcx
movq %r15, %r13
movq 0x30(%r14), %rax
addq %rcx, %rax
cmpq %rax, %r13
je 0x481d7
movq %r15, %rax
subq %rcx, %rax
xorl %edx, %edx
divq %r12
imulq $0x50, %rax, %rax
addq %rcx, %rax
cmpq %r15, %rax
jne 0x481af
movq %rbx, %rdi
callq 0xc300
movb (%r13), %al
testb %bpl, %bpl
je 0x481c0
movsbl %al, %edi
callq 0x2a32e
movsbl %al, %esi
movq %rbx, %rdi
callq 0xc690
incq %r13
movq 0x28(%r14), %rcx
incq %r15
jmp 0x48184
movq %rbx, %rdi
callq 0xc300
callq 0xc070
andl $0x0, (%rax)
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
jne 0x48207
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xc6d0
testl %eax, %eax
jne 0x482db
leaq 0x1adf7(%rip), %rsi     # 0x63012
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbbe
leaq 0x48(%rsp), %rdi
movl $0xdd, %esi
callq 0xe2d5
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xe26e
leaq 0x15f7a(%rip), %rdx     # 0x5e1d1
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xe24f
leaq 0x1aeef(%rip), %rsi     # 0x63162
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xdbbe
leaq 0x16643(%rip), %rdx     # 0x5e8cc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe24f
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xe26e
leaq 0x169e5(%rip), %rdx     # 0x5ec9e
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xe24f
leaq 0xe8(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xcbe8
jmp 0x482f8
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xcbe8
jmp 0x4830a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xcbe8
jmp 0x48319
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xcbe8
jmp 0x48328
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xcbe8
jmp 0x4833a
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xcbe8
jmp 0x4834c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xcbe8
jmp 0x4835b
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::getTaxonStart(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
FOR_REV (size_t, i, s. size ())
  {
    if (s [i] == ']')
      brackets++;
    else if (s [i] == '[')
    {
      if (brackets == 1)
        return i;
      else if (brackets == 0)
    	  return string::npos;  // Non-balanced brackets: too many '['
      else
        brackets--;
    }
  //cout << s. substr (0, i + 1) << ' ' << i << ' ' << brackets << endl;  
    if (brackets == 0)
    	return string::npos;  // No brackets
  }

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
decq %rax
xorl %esi, %esi
pushq $-0x1
popq %rdx
cmpq $-0x1, %rax
je 0x483ac
movzbl (%rcx,%rax), %edi
cmpl $0x5b, %edi
je 0x48396
cmpl $0x5d, %edi
jne 0x483a4
incq %rsi
jmp 0x483a4
testq %rsi, %rsi
je 0x483ac
cmpq $0x1, %rsi
je 0x483af
decq %rsi
decq %rax
testq %rsi, %rsi
jne 0x4837d
movq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::getDescription[abi:cxx11](bool) const
string Seq::getDescription (bool trimTaxon) const
{
	const size_t idSize = getIdSize ();
	if (idSize == name. size ())
		return noString;
	ASSERT (name [idSize] == ' ');
	string desc (name. substr (idSize + 1));
	if (trimTaxon)
	{
		const size_t taxonStart = getTaxonStart ();
		if (taxonStart != string::npos)
			desc. erase (taxonStart - (idSize + 1));
  }
	trim (desc);
	return desc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0xf262
cmpq 0x10(%r15), %rax
jne 0x4870c
leaq 0x413de(%rip), %rsi     # 0x89ae0
movq %r14, %rdi
callq 0xc7e0
jmp 0x48764
movq %rax, %rbx
addq $0x8, %r15
callq 0xc070
andl $0x0, (%rax)
movq (%r15), %rax
cmpb $0x20, (%rax,%rbx)
jne 0x48775
incq %rbx
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xc5f0
testb %bpl, %bpl
je 0x4875c
movq %r15, %rdi
callq 0x4836e
cmpq $-0x1, %rax
je 0x4875c
subq %rbx, %rax
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xc120
movq %r14, %rdi
callq 0x2a2c6
movq %r14, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xc6d0
testl %eax, %eax
jne 0x48849
leaq 0x1a889(%rip), %rsi     # 0x63012
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbbe
leaq 0x48(%rsp), %rdi
movl $0x122, %esi            # imm = 0x122
callq 0xe2d5
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xe26e
leaq 0x15a0c(%rip), %rdx     # 0x5e1d1
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xe24f
leaq 0x1aa01(%rip), %rsi     # 0x631e2
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xdbbe
leaq 0x160d5(%rip), %rdx     # 0x5e8cc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe24f
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xe26e
leaq 0x1a9ea(%rip), %rdx     # 0x63211
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xe24f
leaq 0xe8(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xcbe8
jmp 0x48866
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xcbe8
jmp 0x48878
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xcbe8
jmp 0x48887
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xcbe8
jmp 0x48896
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xcbe8
jmp 0x488a8
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xcbe8
jmp 0x488ba
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xcbe8
jmp 0x488c9
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x488dd
movq %rax, %rbx
jmp 0x488e2
jmp 0x488d7
movq %rax, %rbx
movq %r14, %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::getXs() const
size_t Seq::getXs () const
{
	size_t len = 0;
	for (const char c : seq)
	  if (isAmbiguous (c))
	  	len++;
 	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpq %r13, %r12
je 0x48922
movsbl (%r15,%r13), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movzbl %al, %eax
addq %rax, %r14
incq %r13
jmp 0x48904
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::getContiguousXs() const
size_t Seq::getContiguousXs () const
{
	size_t maxLen = 0;
	size_t len = 0;
	for (const char c : seq)
	  if (isAmbiguous (c))
	  	len++;
	  else
	  {
	  	maximize (maxLen, len);
	  	len = 0;
	  }
 	maximize (maxLen, len);
 	return maxLen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %r12
xorl %ebp, %ebp
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpq %rbp, %r12
je 0x48983
movsbl (%r15,%rbp), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
leaq 0x1(%r14), %rcx
cmpq %r14, %r13
cmovaq %r13, %r14
testb %al, %al
cmoveq %r14, %r13
movl $0x0, %eax
cmoveq %rax, %rcx
incq %rbp
movq %rcx, %r14
jmp 0x4894e
cmpq %r14, %r13
cmovaq %r13, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::getCharCount() const
map<char,size_t> Seq::getCharCount () const
{ 
  map<char,size_t> m;
  for (const char c : seq)
    m [c] ++;
  return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq 0x28(%rsi), %r15
movq 0x30(%rsi), %r12
xorl %r13d, %r13d
leaq 0xf(%rsp), %r14
cmpq %r13, %r12
je 0x489f6
movb (%r15,%r13), %al
movb %al, 0xf(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b1b2
incq (%rax)
incq %r13
jmp 0x489d6
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5bd28
movq %r14, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Multifasta::qcNewSeq() const
void Multifasta::qcNewSeq () const
{
	if (   ! in. eof 
	    && ! (   ! in. line. empty () 
	          && in. line [0] == '>'
	         )
	   )
	  throw runtime_error ("Error in Multifasta, " + in. lineStr ());   
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpb $0x0, 0x220(%rdi)
jne 0x48a44
movq %rdi, %r14
cmpq $0x0, 0x278(%rdi)
je 0x48a4d
movq 0x270(%r14), %rax
cmpb $0x3e, (%rax)
jne 0x48a4d
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x8, %r14
pushq $0x10
popq %rdi
callq 0xc310
movq %rax, %rbx
movq %rsp, %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x5b200
leaq 0x1a7b5(%rip), %rsi     # 0x63226
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe819
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xc990
xorl %ebp, %ebp
movq 0x40559(%rip), %rsi     # 0x88ff0
movq 0x404ca(%rip), %rdx     # 0x88f68
movq %rbx, %rdi
callq 0xca40
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xcbe8
jmp 0x48abb
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xcbe8
testb %bpl, %bpl
jne 0x48acd
jmp 0x48ad5
movq %rax, %r14
movq %rbx, %rdi
callq 0xc470
movq %r14, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::nuc2num(char)
size_t nuc2num (char wildNucleotide)
{
  const char c = toLower (wildNucleotide);
  switch (c)
  {
    case 'a': return 0; break;
    case 'c': return 1; break;
    case 'g': return 2; break;
    case 't': return 3; break;
  }  
  if (isAmbigNucl (c))
    return 4;
  throw runtime_error (strQuote (string (1, wildNucleotide)) + " is not a nucleotide");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %edi, %ebp
callq 0x2a336
cmpb $0x61, %al
je 0x48b0e
movzbl %al, %ecx
cmpl $0x74, %ecx
je 0x48b06
cmpl $0x67, %ecx
je 0x48b0a
cmpl $0x63, %ecx
jne 0x48b12
pushq $0x1
jmp 0x48b20
pushq $0x3
jmp 0x48b20
pushq $0x2
jmp 0x48b20
xorl %eax, %eax
jmp 0x48b21
movsbl %al, %edi
callq 0x5b25b
testb %al, %al
je 0x48b2a
pushq $0x4
popq %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc310
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movsbl %bpl, %edx
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0xc680
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
pushq $0x22
popq %rdx
callq 0x12085
leaq 0x1a6d8(%rip), %rdx     # 0x6323c
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xe24f
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xc990
xorl %ebp, %ebp
movq 0x40464(%rip), %rsi     # 0x88ff0
movq 0x403d5(%rip), %rdx     # 0x88f68
movq %rbx, %rdi
callq 0xca40
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xcbe8
jmp 0x48bb0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xcbe8
jmp 0x48bc2
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xcbe8
testb %bpl, %bpl
jne 0x48bd4
jmp 0x48bdc
movq %rax, %r14
movq %rbx, %rdi
callq 0xc470
movq %r14, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::nucleotides2wild(bool const*)
char nucleotides2wild (const bool acgtb [5])
{
  const bool& a = acgtb [0];
  const bool& c = acgtb [1];
  const bool& g = acgtb [2];
  const bool& t = acgtb [3];

  char res = '\0';
  if (a)
    if (c)
      if (g)
        if (t)
          res = 'n';
        else
          res = 'v';
      else
        if (t)
          res = 'h';
        else
          res = 'm';
    else
      if (g)
        if (t)
          res = 'd';
        else
          res = 'r';
      else
        if (t)
          res = 'w';
        else
          res = 'a';
  else
    if (c)
      if (g)
        if (t)
          res = 'b';
        else
          res = 's';
      else
        if (t)
          res = 'y';
        else
          res = 'c';
    else
      if (g)
        if (t)
          res = 'k';
        else
          res = 'g';
      else
        if (t)
          res = 't';
        else
          res = '-';


  if (acgtb [4])
    return toUpper (res);
  else
    if (res == '-')
      return ' ';
    else
      return res;
}

// Assembly:
movb 0x1(%rdi), %dl
movb 0x2(%rdi), %cl
movb 0x3(%rdi), %al
cmpb $0x1, (%rdi)
jne 0x48f5c
testb %dl, %dl
je 0x48f6d
testb %cl, %cl
je 0x48f85
xorb $0x1, %al
shlb $0x3, %al
addb $0x6e, %al
jmp 0x48fa8
testb %dl, %dl
je 0x48f7a
testb %cl, %cl
je 0x48f94
testb %al, %al
pushq $0x62
popq %rcx
pushq $0x73
jmp 0x48fa4
testb %cl, %cl
je 0x48f9d
testb %al, %al
pushq $0x64
popq %rcx
pushq $0x72
jmp 0x48fa4
testb %cl, %cl
je 0x48fb9
shlb $0x2, %al
addb $0x67, %al
jmp 0x48fa8
xorl %ecx, %ecx
testb %al, %al
sete %cl
leal (%rcx,%rcx,4), %eax
orl $0x68, %eax
jmp 0x48fa8
testb %al, %al
pushq $0x79
popq %rcx
pushq $0x63
jmp 0x48fa4
testb %al, %al
pushq $0x77
popq %rcx
pushq $0x61
popq %rax
cmovnel %ecx, %eax
movl %eax, %ecx
cmpb $0x1, 0x4(%rdi)
jne 0x48fb8
movsbl %cl, %edi
jmp 0x2a32e
retq
testb %al, %al
pushq $0x74
popq %rdx
pushq $0x2d
popq %rcx
cmovnel %edx, %ecx
pushq $0x20
popq %rax
cmovnel %edx, %eax
jmp 0x48faa
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::reverseDna(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string& reverseDna (string &seq)
{
  const size_t len = seq. size ();
  if (! len)
  	return seq;

  FFOR (size_t, i, len / 2)
  {
  	const size_t j = len - 1 - i;
  	if (seq [i] != '-')
  		seq [i] = complementaryNucleotide (seq [i]);
  	if (seq [j] != '-')
  		seq [j] = complementaryNucleotide (seq [j]);
    swap (seq [i], seq [j]);
  }

  if (len % 2)
  {
  	const size_t i = len / 2;
  	if (seq [i] != '-')
  		seq [i] = complementaryNucleotide (seq [i]);
  }
 
  return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x496be
movq %r15, %r14
shrq %r14
leaq -0x1(%r15), %r12
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x4969e
movq (%rbx), %rax
movb (%rax,%r13), %cl
cmpb $0x2d, %cl
je 0x49669
movsbl %cl, %edi
callq 0x48fcc
movq (%rbx), %rcx
movb %al, (%rcx,%r13)
movq (%rbx), %rax
movb (%rax,%r12), %dl
movb $0x2d, %cl
cmpb $0x2d, %dl
je 0x4968a
movsbl %dl, %edi
callq 0x48fcc
movq (%rbx), %rcx
movb %al, (%rcx,%r12)
movq (%rbx), %rax
movb (%rax,%r12), %cl
movb (%rax,%r13), %dl
movb %cl, (%rax,%r13)
movb %dl, (%rax,%r12)
incq %r13
decq %r12
jmp 0x49646
testb $0x1, %r15b
je 0x496be
movq (%rbx), %rax
movb (%rax,%r14), %al
cmpb $0x2d, %al
je 0x496be
movsbl %al, %edi
callq 0x48fcc
movq (%rbx), %rcx
movb %al, (%rcx,%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Dna::makeComplementary() const
Dna* Dna::makeComplementary () const
{
  Dna* dna = new Dna (getId () + ".rev", seq. size (), sparse);
  FFOR (size_t, i, seq. size ())
    dna->seq [i] = complementaryNucleotide (seq [seq. size () - 1 - i]);

#if 0
  if (Qual)
  {
    dna->CreateQual ();
    For (i, SeqLen)
      dna->Qual [i] = Qual [SeqLen - 1 - i];
  }
#endif

  return dna;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0xc5b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe516
leaq 0x18cc8(%rip), %rdx     # 0x63461
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xe24f
movq 0x30(%r14), %rdx
movzbl 0x48(%r14), %ecx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5b272
leaq 0x20(%rsp), %rdi
callq 0xcbe8
movq %rsp, %rdi
callq 0xcbe8
movq 0x30(%r14), %r15
pushq $-0x1
popq %r12
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x4a800
movq 0x28(%r14), %rax
addq 0x30(%r14), %rax
movsbl (%r12,%rax), %edi
callq 0x48fcc
movq 0x28(%rbx), %rcx
movb %al, (%rcx,%r13)
incq %r13
decq %r12
jmp 0x4a7d9
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xcbe8
jmp 0x4a823
movq %rax, %r14
movq %rsp, %rdi
callq 0xcbe8
jmp 0x4a830
movq %rax, %r14
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0xc5c0
movq %r14, %rdi
callq 0xcaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Dna::reverse()
void Dna::reverse ()
{
  unique_ptr<Dna> dnaRev (makeComplementary ());
  ASSERT (seq. size () == dnaRev->seq. size ());
  seq = dnaRev->seq;

#if 0
  if (Qual)
    ForString (i, seq)
      Qual [i] = dnaRev->Qual [i];
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %r14
callq 0x4a76c
movq %rax, %rbx
callq 0xc070
andl $0x0, (%rax)
movq 0x30(%r14), %rax
cmpq 0x30(%rbx), %rax
jne 0x4a891
movq %rbx, %rsi
addq $0x28, %rsi
addq $0x28, %r14
movq %r14, %rdi
callq 0xc360
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
jmpq *0x8(%rax)
callq 0xc6d0
testl %eax, %eax
jne 0x4a965
leaq 0x1876d(%rip), %rsi     # 0x63012
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbbe
leaq 0x48(%rsp), %rdi
movl $0x7c1, %esi            # imm = 0x7C1
callq 0xe2d5
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xe26e
leaq 0x138f0(%rip), %rdx     # 0x5e1d1
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xe24f
leaq 0x18b69(%rip), %rsi     # 0x63466
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xdbbe
leaq 0x13fb9(%rip), %rdx     # 0x5e8cc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe24f
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xe26e
leaq 0x18b3f(%rip), %rdx     # 0x63482
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xe24f
leaq 0xe8(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
callq 0xcbe8
jmp 0x4a982
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
callq 0xcbe8
jmp 0x4a994
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xcbe8
jmp 0x4a9a3
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xcbe8
jmp 0x4a9b2
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0xcbe8
jmp 0x4a9c4
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0xcbe8
jmp 0x4a9d6
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xcbe8
jmp 0x4a9e5
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0xcbe8
jmp 0x4a9f6
jmp 0x4a9f3
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xcaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::SubstMat::saveText(std::ostream&) const
void SubstMat::saveText (ostream& os) const 
{
  FOR (size_t, i, sim_size)
    if (goodIndex (i))
      os << ' ' << char (i);
  os << endl;
  
  FOR (size_t, i, sim_size)
    if (goodIndex (i))
    {
      os << char (i);
      FOR (size_t, j, sim_size)
        if (goodIndex (j))
          os << ' ' << sim [i] [j];
      os << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
xorl %r15d, %r15d
pushq $0x20
popq %rbp
movq %r14, %r12
cmpq $0x80, %r15
je 0x4dba5
movsd (%r12), %xmm0
ucomisd %xmm0, %xmm0
jp 0x4db99
movq %rbx, %rdi
movl %ebp, %esi
callq 0xc690
movsbl %r15b, %esi
movq %rax, %rdi
callq 0xc690
incq %r15
addq $0x408, %r12            # imm = 0x408
jmp 0x4db6e
movq %rbx, %rdi
callq 0xc300
xorl %r15d, %r15d
pushq $0x20
popq %rbp
movq %r14, %r12
movq %r14, (%rsp)
cmpq $0x80, %r15
je 0x4dc3f
movq %r15, %rax
shlq $0xa, %rax
addq %r14, %rax
movsd (%rax,%r15,8), %xmm0
ucomisd %xmm0, %xmm0
jp 0x4dc30
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0xc690
movq %r14, %r13
xorl %r14d, %r14d
cmpq $0x80, %r14
je 0x4dc24
movsd (%r13), %xmm0
ucomisd %xmm0, %xmm0
jp 0x4dc18
movq %rbx, %rdi
movl %ebp, %esi
callq 0xc690
movsd (%r12,%r14,8), %xmm0
movq %rax, %rdi
callq 0xc970
incq %r14
addq $0x408, %r13            # imm = 0x408
jmp 0x4dbeb
movq %rbx, %rdi
callq 0xc300
movq (%rsp), %r14
incq %r15
addq $0x400, %r12            # imm = 0x400
jmp 0x4dbba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::SubstMat::printAnomalies() const
void SubstMat::printAnomalies () const
{
  FOR (size_t, i, sim_size)
  {
    if (! goodIndex (i))
      continue;
    FOR (size_t, j, sim_size)
    {
      if (! goodIndex (j))
        continue;
      if (sim [i] [i] < sim [i] [j])
        cout << "sim(" << char (i) << ',' << char (i) << ") < sim(" << char(i) << ',' << char(j) << ")" << endl;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
addq $0x8, %r14
xorl %ecx, %ecx
pushq $0x2c
popq %rbp
movq %r14, 0x8(%rsp)
cmpq $0x80, %rcx
je 0x4dd72
movq %rcx, %rax
shlq $0xa, %rax
addq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm0, %xmm0
jp 0x4dd5e
movq 0x10(%rsp), %rcx
leaq (%rax,%rcx,8), %r15
movsbl %cl, %ebx
movq 0x8(%rsp), %r12
xorl %r13d, %r13d
cmpq $0x80, %r13
je 0x4dd5e
movsd (%r12), %xmm0
ucomisd %xmm0, %xmm0
jp 0x4dd4f
movsd (%r14,%r13,8), %xmm0
ucomisd (%r15), %xmm0
jbe 0x4dd4f
movq 0x3b2b1(%rip), %rdi     # 0x88f90
leaq 0x15c1c(%rip), %rsi     # 0x63902
callq 0xc5a0
movq %rax, %rdi
movl %ebx, %esi
callq 0xc690
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq %rax, %rdi
movl %ebx, %esi
callq 0xc690
movq %rax, %rdi
leaq 0x15beb(%rip), %rsi     # 0x638fe
callq 0xc5a0
movq %rax, %rdi
movl %ebx, %esi
callq 0xc690
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movsbl %r13b, %esi
movq %rax, %rdi
callq 0xc690
movq %rax, %rdi
leaq 0x14377(%rip), %rsi     # 0x620b9
callq 0xc5a0
movq %rax, %rdi
callq 0xc300
incq %r13
addq $0x408, %r12            # imm = 0x408
jmp 0x4dcae
movq 0x10(%rsp), %rcx
incq %rcx
addq $0x400, %r14            # imm = 0x400
jmp 0x4dc6d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::aa2num(char)
size_t aa2num (char wildAminoacid)
{
  const char c = toUpper (wildAminoacid);

  size_t i = 0;
  for (const char* a = peptideAlphabet; *a; a++)
    if (c == *a)
      return i;
    else
    	i++;
  if (wildAminoacid == *terminator)
    return 20;
  if (isAmbigAa (c))
    return 21;

  NEVER_CALL;
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movl %edi, %ebx
callq 0x2a32e
movl %eax, %ecx
xorl %eax, %eax
movq 0x3a56a(%rip), %rdx     # 0x89a60
movb (%rdx,%rax), %sil
testb %sil, %sil
je 0x4f509
cmpb %sil, %cl
je 0x4f527
incq %rax
jmp 0x4f4f6
movq 0x3a700(%rip), %rax     # 0x89c10
cmpb %bl, (%rax)
jne 0x4f518
pushq $0x14
jmp 0x4f526
movsbl %cl, %edi
callq 0x5b377
testb %al, %al
je 0x4f530
pushq $0x15
popq %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xc6d0
testl %eax, %eax
jne 0x4f604
leaq 0x13ace(%rip), %rsi     # 0x63012
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xdbbe
leaq 0x50(%rsp), %rdi
movl $0xd7c, %esi            # imm = 0xD7C
callq 0xe2d5
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xe26e
leaq 0xec51(%rip), %rdx      # 0x5e1d1
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xe24f
leaq 0x1457c(%rip), %rsi     # 0x63b18
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xdbbe
leaq 0xf31a(%rip), %rdx      # 0x5e8cc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe24f
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe26e
leaq 0xf469(%rip), %rdx      # 0x5ea4b
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xe24f
leaq 0xf0(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xcbe8
jmp 0x4f621
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xcbe8
jmp 0x4f633
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xcbe8
jmp 0x4f642
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcbe8
jmp 0x4f651
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xcbe8
jmp 0x4f663
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xcbe8
jmp 0x4f675
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xcbe8
jmp 0x4f684
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::moreGeneralAminoacid(char, char)
bool moreGeneralAminoacid (char wildAminoacid1,
                           char wildAminoacid2)
{
  if (wildAminoacid1 == wildAminoacid2)
    return true;


  switch (wildAminoacid1)
  {
    case 'x': return true;
    case 'b': return charInSet (wildAminoacid2, "dn");
    case 'z': return charInSet (wildAminoacid2, "eq");
    case 'j': return charInSet (wildAminoacid2, "il");
    case 'u': return wildAminoacid2 == '*'; 
    case 'o': return wildAminoacid2 == '*'; 
    case '*': return charInSet (wildAminoacid2, "uo");
  }

  return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movb $0x1, %bpl
cmpb %bl, %dil
je 0x4f725
movsbl %dil, %eax
cmpl $0x2a, %eax
je 0x4f6e1
cmpl $0x7a, %eax
je 0x4f6f7
cmpl $0x6a, %eax
je 0x4f6ee
cmpl $0x6f, %eax
je 0x4f6d8
cmpl $0x75, %eax
je 0x4f6d8
cmpl $0x78, %eax
je 0x4f725
cmpl $0x62, %eax
jne 0x4f6ea
leaq 0x1445e(%rip), %rsi     # 0x63b34
jmp 0x4f6fe
cmpb $0x2a, %bl
sete %bpl
jmp 0x4f725
leaq 0x14452(%rip), %rsi     # 0x63b3a
jmp 0x4f6fe
xorl %ebp, %ebp
jmp 0x4f725
leaq 0x15106(%rip), %rsi     # 0x647fb
jmp 0x4f6fe
leaq 0x14439(%rip), %rsi     # 0x63b37
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0xdbbe
movsbl %bl, %edi
movq %r14, %rsi
callq 0x2a35c
movl %eax, %ebp
movq %r14, %rdi
callq 0xcbe8
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Peptide::qc() const
void Peptide::qc () const
{
  if (! qc_on)
    return;
  Seq::qc ();

	QC_IMPLY (hasInsideStop (), pseudo);
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq 0x3a197(%rip), %rax     # 0x89ac8
cmpb $0x1, (%rax)
jne 0x4f958
movq %rdi, %rbx
callq 0x5b3b2
movq %rbx, %rdi
callq 0x5b3d2
testb %al, %al
je 0x4f958
callq 0xc070
andl $0x0, (%rax)
cmpb $0x0, 0x49(%rbx)
je 0x4f961
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xc6d0
testl %eax, %eax
jne 0x4fa35
leaq 0x1369d(%rip), %rsi     # 0x63012
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xdbbe
leaq 0x50(%rsp), %rdi
movl $0xdac, %esi            # imm = 0xDAC
callq 0xe2d5
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xe26e
leaq 0xe820(%rip), %rdx      # 0x5e1d1
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xe24f
leaq 0x141a5(%rip), %rsi     # 0x63b72
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xdbbe
leaq 0xeee9(%rip), %rdx      # 0x5e8cc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe24f
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe26e
leaq 0x14188(%rip), %rdx     # 0x63b9b
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xe24f
leaq 0xf0(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xcbe8
jmp 0x4fa52
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xcbe8
jmp 0x4fa64
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xcbe8
jmp 0x4fa73
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcbe8
jmp 0x4fa82
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xcbe8
jmp 0x4fa94
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xcbe8
jmp 0x4faa6
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xcbe8
jmp 0x4fab5
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Peptide::isDescriptionPartial() const
bool Peptide::isDescriptionPartial () const
{
	string desc (getDescription (false));
	strLower (desc);
	// PAR
	return    contains (desc, "fragmented")  // "fragment" may mean a complex unit
	       || contains (desc, "fragmentary")
	       || contains (desc, "partial")
	       || contains (desc, "truncat");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x486d8
movq %rbx, %rdi
callq 0x11c18
leaq 0x140af(%rip), %rsi     # 0x63ba2
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbbe
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x29fee
movb $0x1, %bl
testb %al, %al
jne 0x4fbbd
leaq 0x1408b(%rip), %rsi     # 0x63bad
leaq 0x48(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xdbbe
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x29fee
movb $0x1, %bl
testb %al, %al
jne 0x4fbb3
leaq 0x1406c(%rip), %rsi     # 0x63bb9
leaq 0x28(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xdbbe
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x29fee
movb $0x1, %bl
testb %al, %al
jne 0x4fba9
leaq 0x14049(%rip), %rsi     # 0x63bc1
leaq 0x88(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xdbbe
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %r14
movq %r14, %rsi
callq 0x29fee
movl %eax, %ebx
movq %r14, %rdi
callq 0xcbe8
leaq 0x28(%rsp), %rdi
callq 0xcbe8
leaq 0x48(%rsp), %rdi
callq 0xcbe8
leaq 0x68(%rsp), %rdi
callq 0xcbe8
leaq 0x8(%rsp), %rdi
callq 0xcbe8
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xcbe8
jmp 0x4fbf0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xcbe8
jmp 0x4fbff
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xcbe8
jmp 0x4fc10
jmp 0x4fc0d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Cds::getOverlap_(Seq_sp::Cds const&) const
size_t Cds::getOverlap_ (const Cds &other) const
{ 
  ASSERT (left () <= other. left ());
	ASSERT (other. left () <= right ());
	if (other. right () <= right ())
		return other. size ();
	return right () - other. left ();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc070
andl $0x0, (%rax)
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rcx
cmpq %rdi, %rcx
movq %rdi, %r8
cmovbq %rcx, %r8
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rsi, %rax
movq %rsi, %rdx
cmovbq %rax, %rdx
cmpq %rdx, %r8
ja 0x5170d
cmpq %rcx, %rdi
cmovaq %rdi, %rcx
cmpq %rcx, %rdx
ja 0x517e1
cmpq %rax, %rsi
cmovaq %rsi, %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
subq %rdx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
callq 0xc6d0
testl %eax, %eax
jne 0x518b5
leaq 0x118f1(%rip), %rsi     # 0x63012
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbbe
leaq 0x48(%rsp), %rdi
movl $0xf51, %esi            # imm = 0xF51
callq 0xe2d5
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xe26e
leaq 0xca74(%rip), %rdx      # 0x5e1d1
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xe24f
leaq 0x126fc(%rip), %rsi     # 0x63e75
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xdbbe
leaq 0xd13d(%rip), %rdx      # 0x5e8cc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe24f
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xe26e
leaq 0x126e9(%rip), %rdx     # 0x63ea8
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xe24f
leaq 0xe8(%rsp), %rdi
callq 0x101d0
callq 0xc6d0
testl %eax, %eax
jne 0x518b5
leaq 0x1181d(%rip), %rsi     # 0x63012
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbbe
leaq 0x48(%rsp), %rdi
movl $0xf52, %esi            # imm = 0xF52
callq 0xe2d5
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xe26e
leaq 0xc9a0(%rip), %rdx      # 0x5e1d1
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xe24f
leaq 0x12628(%rip), %rsi     # 0x63e75
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xdbbe
leaq 0xd069(%rip), %rdx      # 0x5e8cc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe24f
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xe26e
leaq 0x1262f(%rip), %rdx     # 0x63ec2
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xe24f
leaq 0xe8(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
jmp 0x518c1
jmp 0x518d3
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xcbe8
jmp 0x518d6
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xcbe8
jmp 0x518ea
jmp 0x518e7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xcbe8
jmp 0x518fb
jmp 0x518f8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xcbe8
jmp 0x5190c
jmp 0x51909
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xcbe8
jmp 0x51920
jmp 0x5191d
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xcbe8
jmp 0x51934
jmp 0x51931
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xcbe8
jmp 0x51945
jmp 0x51942
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xcbe8
jmp 0x51956
jmp 0x51953
movq %rax, %rbx
movq %rbx, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Cds::coexists(Seq_sp::Cds const&) const
bool Cds::coexists (const Cds &next) const
{ 
  ASSERT (left () <= next. left ());
  if (! strand () && next. strand ())
    return right () + promoter_min <= next. left ();
  const size_t overlap_min = min ( size_min - 3/*PAR*/
				    	                   , (size_t) ((double) min (size (), next. size ()) * 0.2/*PAR*/)
                                 );
  return getOverlap (next) <= overlap_min;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc070
andl $0x0, (%rax)
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rax
cmpq %rdx, %rax
movq %rdx, %rdi
cmovbq %rax, %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rcx
cmpq %rsi, %rcx
movq %rsi, %r8
cmovbq %rcx, %r8
cmpq %r8, %rdi
ja 0x51a4e
cmpq %rax, %rdx
setb %r9b
cmpq %rcx, %rsi
setae %r10b
orb %r9b, %r10b
jne 0x519c1
addq $0x3c, %rdx
cmpq %rsi, %rdx
jmp 0x51a3e
cmpq %rax, %rdx
cmovaq %rdx, %rax
subq %rdi, %rax
cmpq %rcx, %rsi
cmovaq %rsi, %rcx
subq %r8, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, %xmm0
punpckldq 0x105d7(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x105df(%rip), %xmm0    # 0x61fd0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x1156b(%rip), %xmm1    # 0x62f70
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1157f(%rip), %xmm1    # 0x62f98
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
cmpq $0x3c, %rdx
pushq $0x3c
popq %r15
cmovbq %rdx, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5b48a
cmpq %r15, %rax
setbe %al
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
callq 0xc6d0
testl %eax, %eax
jne 0x51b22
leaq 0x115b0(%rip), %rsi     # 0x63012
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xdbbe
leaq 0x50(%rsp), %rdi
movl $0xf5c, %esi            # imm = 0xF5C
callq 0xe2d5
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xe26e
leaq 0xc733(%rip), %rdx      # 0x5e1d1
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xe24f
leaq 0x12423(%rip), %rsi     # 0x63edd
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xdbbe
leaq 0xcdfc(%rip), %rdx      # 0x5e8cc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe24f
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe26e
leaq 0x1240b(%rip), %rdx     # 0x63f0b
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xe24f
leaq 0xf0(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xcbe8
jmp 0x51b3f
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xcbe8
jmp 0x51b51
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xcbe8
jmp 0x51b60
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcbe8
jmp 0x51b6f
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xcbe8
jmp 0x51b81
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xcbe8
jmp 0x51b93
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xcbe8
jmp 0x51ba2
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Mutation::setAmbig()
void Mutation::setAmbig ()
{
  for (const char c : allele)
    if (isAmbig (c, prot))
    {
      ambig = true;
      return;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %r14
movq 0x60(%rdi), %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x55df8
movsbl (%r14,%r12), %edi
movzbl 0x8(%rbx), %esi
callq 0x5b579
incq %r12
testb %al, %al
je 0x55dda
movb $0x1, 0x79(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Mutation::operator<(Seq_sp::Mutation const&) const
bool Mutation::operator< (const Mutation& other) const
{ 
  LESS_PART (*this, other, prot);
  LESS_PART (*this, other, geneName);
  LESS_PART (*this, other, pos);
  LESS_PART (*this, other, ref);
  LESS_PART (*this, other, allele);
  LESS_PART (*this, other, frameshift);
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb 0x8(%rdi), %al
movb 0x8(%rsi), %cl
movb $0x1, %bl
cmpb %cl, %al
jb 0x56842
jbe 0x56825
xorl %ebx, %ebx
jmp 0x56842
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %r12
leaq 0x10(%rsi), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xeb74
testb %al, %al
je 0x5684e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r13, %rdi
movq %r12, %rsi
callq 0xeb74
testb %al, %al
jne 0x56821
movq 0x30(%r15), %rax
movq 0x30(%r14), %rcx
cmpq %rcx, %rax
jb 0x56842
ja 0x56821
leaq 0x38(%r15), %r12
leaq 0x38(%r14), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xeb74
testb %al, %al
jne 0x56842
movq %r13, %rdi
movq %r12, %rsi
callq 0xeb74
testb %al, %al
jne 0x56821
leaq 0x58(%r15), %r12
leaq 0x58(%r14), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xeb74
testb %al, %al
jne 0x56842
movq %r13, %rdi
movq %r12, %rsi
callq 0xeb74
testb %al, %al
jne 0x56821
movb 0x78(%r15), %al
cmpb 0x78(%r14), %al
setb %bl
jmp 0x56842
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::KmerIndex::IdRecord::getStart() const
size_t KmerIndex::IdRecord::getStart () const
{ 
  size_t i = 0;
  for (; i < textSize; i++)
    if (text [i] == no_char)
      break;
  return i;
}

// Assembly:
xorl %eax, %eax
cmpq $0x18, %rax
je 0x5724c
cmpb $0x0, 0x18(%rdi,%rax)
je 0x5724c
incq %rax
jmp 0x5723a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::KmerIndex::IdRecord::save() const
void KmerIndex::IdRecord::save () const
{         
  f. seekp ((streamoff) addr);
  writeBin (f, prev);
  FOR (size_t, i, textSize)
    f. put (text [i]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
addq $0x10, %rdi
xorl %edx, %edx
callq 0xc6e0
movq (%rbx), %rdi
addq $0x10, %rdi
leaq 0x10(%rbx), %rsi
callq 0x5b592
pushq $0x18
popq %r14
cmpq $0x30, %r14
je 0x57297
movq (%rbx), %rdi
addq $0x10, %rdi
movsbl (%rbx,%r14), %esi
callq 0xc040
incq %r14
jmp 0x5727b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::KmerIndex::IdRecord::get[abi:cxx11]() const
string KmerIndex::IdRecord::get () const
{
  string s; s. reserve (textSize);
  FOR_REV (size_t, i, start)
    s += text [i];
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0x18
popq %rsi
callq 0xc910
movq 0x30(%r14), %rax
movq %rax, %r15
subq $0x1, %r15
jb 0x57a73
movsbl 0x17(%r14,%rax), %esi
movq %rbx, %rdi
callq 0xc510
movq %r15, %rax
jmp 0x57a5a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x57a7e
movq %rax, %r14
movq %rbx, %rdi
callq 0xcbe8
movq %r14, %rdi
callq 0xcaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::KmerIndex::KmerIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
KmerIndex::KmerIndex (const string &name_arg)
: Named (name_arg)
, f (name, ios_base::in | ios_base::out | ios_base::binary)
, canRead (true)
, kmer_size (readKmerSize (f))
, code_max (powInt (2, 2 * kmer_size))
{
  checkFile (name);

  readBin (f, items);

  f. seekg (0, ios_base::end);
  addr_new = (Addr) f. tellg ();

  QC_ASSERT (f. good ());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
callq 0x2bbca
movq %rbx, %rdi
callq 0x5b59a
leaq 0x308d5(%rip), %rax     # 0x88b68
movq %rax, (%rbx)
leaq 0x28(%rbx), %r14
leaq 0x8(%rbx), %r15
pushq $0x1c
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xc9f0
movb $0x1, 0x238(%rbx)
movq %r14, %rdi
callq 0x584c8
movq %rax, 0x240(%rbx)
addq %rax, %rax
pushq $0x2
popq %rdi
movq %rax, %rsi
callq 0x10a84
movq %rax, 0x248(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x250(%rbx)
movq %r15, %rdi
callq 0x5b5eb
leaq 0x250(%rbx), %rsi
movq %r14, %rdi
callq 0x5b58a
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0xc7d0
movq %r14, %rdi
callq 0xca60
movq %rax, 0x258(%rbx)
callq 0xc070
andl $0x0, (%rax)
movq 0x28(%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rbx,%rax)
jne 0x58338
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
callq 0xc6d0
testl %eax, %eax
jne 0x5840c
leaq 0xacc6(%rip), %rsi      # 0x63012
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xdbbe
leaq 0x50(%rsp), %rdi
movl $0x12d4, %esi           # imm = 0x12D4
callq 0xe2d5
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xe26e
leaq 0x5e49(%rip), %rdx      # 0x5e1d1
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xe24f
leaq 0xc3bf(%rip), %rsi      # 0x64763
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xdbbe
leaq 0x6512(%rip), %rdx      # 0x5e8cc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe24f
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe26e
leaq 0x7ad5(%rip), %rdx      # 0x5febf
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xe24f
leaq 0xf0(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %r15
leaq 0xf0(%rsp), %rdi
callq 0xcbe8
jmp 0x58429
movq %rax, %r15
leaq 0xd0(%rsp), %rdi
callq 0xcbe8
jmp 0x5843b
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0xcbe8
jmp 0x5844a
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0xcbe8
jmp 0x58459
movq %rax, %r15
leaq 0xb0(%rsp), %rdi
callq 0xcbe8
jmp 0x5846b
movq %rax, %r15
leaq 0x90(%rsp), %rdi
callq 0xcbe8
jmp 0x5847d
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0xcbe8
jmp 0x5848c
movq %rax, %r15
leaq 0x70(%rsp), %rdi
callq 0xcbe8
jmp 0x584a9
jmp 0x584a6
jmp 0x584a6
movq %rax, %r15
jmp 0x584b1
movq %rax, %r15
jmp 0x584b8
movq %rax, %r15
movq %r14, %rdi
callq 0xc110
movb $0x0, 0x31770(%rip)     # 0x89c28
movq %rbx, %rdi
callq 0xe0f6
movq %r15, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/seq.cpp
// Function: Seq_sp::KmerIndex::getKmers()
size_t KmerIndex::getKmers ()
{
  size_t kmers = 0;
  f. seekg ((streamoff) code2addr (0));
  Progress prog (code_max, progressSize);  
  Addr addr = nil;
  FOR (size_t, i, code_max)
  {
    prog ();
    readBin (f, addr);
    if (addr != nil)
      kmers++;
  }
  return kmers;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
xorl %r15d, %r15d
pushq $0x10
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc750
movq 0x248(%rbx), %rsi
leaq 0x8(%rsp), %rdi
movl $0xf4240, %edx          # imm = 0xF4240
callq 0x17f5c
movq %rsp, %r13
orq $-0x1, (%r13)
leaq 0x30e40(%rip), %rbp     # 0x89ae0
xorl %r12d, %r12d
cmpq 0x248(%rbx), %r15
jae 0x58cd6
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x16794
movq %r14, %rdi
movq %r13, %rsi
callq 0x5b58a
xorl %eax, %eax
cmpq $-0x1, (%rsp)
setne %al
addq %rax, %r12
incq %r15
jmp 0x58ca3
leaq 0x8(%rsp), %rdi
callq 0x18104
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18104
movq %rbx, %rdi
callq 0xcaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./seq.hpp
// Function: Seq_sp::Cds::getOverlap(Seq_sp::Cds const&) const
size_t getOverlap (const Cds &other) const
    // Symmetric
    { if (other. left () >= right ())
    		return 0;
    	if (left () >= other. right ())
    		return 0;
    	if (left () <= other. left ())
    		return getOverlap_ (other);
    	return other. getOverlap_ (*this);
    }

// Assembly:
movq %rdi, %rax
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %r8
cmpq %rdx, %r8
movq %rdx, %rcx
cmovbq %r8, %rcx
movq 0x8(%rdi), %rdi
movq 0x10(%rax), %r9
cmpq %r9, %rdi
movq %r9, %r10
cmovaq %rdi, %r10
cmpq %r10, %rcx
jae 0x5b4d9
cmpq %rdi, %r9
cmovbq %r9, %rdi
cmpq %r8, %rdx
cmovaq %rdx, %r8
cmpq %r8, %rdi
jae 0x5b4d9
cmpq %rcx, %rdi
jbe 0x5b4dc
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x516a0
xorl %eax, %eax
retq
movq %rax, %rdi
jmp 0x516a0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./seq.hpp
// Function: Seq_sp::PeptideOrf::saveText(std::ostream&) const
void saveText (ostream &os) const override
	  { os         << translationStart 
	  	   << '\t' << (int) strand 
	  	   << '\t' << start 
	  	   << '\t' << stop 
	  	   << '\t' << startM
	  	   << '\t' << stopTerminator;
	  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0xc410
pushq $0x9
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movsbl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0xca50
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movzbl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0xc9d0
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movzbl 0x30(%rbx), %esi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc9d0