LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::AmrMutation::operator<(Alignment_sp::AmrMutation const&) const
bool AmrMutation::operator< (const AmrMutation &other) const
{ 
  LESS_PART (*this, other, gene);
  LESS_PART (*this, other, pos_real);
  LESS_PART (*this, other, geneMutation_std);
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x70, %rdi
movq 0x10(%rsp), %rsi
addq $0x70, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0x91260
jmp 0x9126a
movb $0x1, 0x27(%rsp)
jmp 0x91314
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x70, %rdi
addq $0x70, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0x91287
jmp 0x91291
movb $0x0, 0x27(%rsp)
jmp 0x91314
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x912ac
movb $0x1, 0x27(%rsp)
jmp 0x91314
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
jae 0x912c7
movb $0x0, 0x27(%rsp)
jmp 0x91314
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0x912e4
jmp 0x912eb
movb $0x1, 0x27(%rsp)
jmp 0x91314
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0x91308
jmp 0x9130f
movb $0x0, 0x27(%rsp)
jmp 0x91314
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::SeqChange::getMutationStr[abi:cxx11]() const
string SeqChange::getMutationStr () const
{ 
  const string allele_ (allele. empty () 
                          ? "DEL" 
                          : allele == "*"
                              ? "STOP"
                              : allele
                       );
  return reference + to_string ((int) start_ref + 1 /* - al->ref_offset*/) + allele_; 
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
addq $0x48, %rdi
callq 0xdc60
movb $0x0, 0x96(%rsp)
movb $0x0, 0x82(%rsp)
testb $0x1, %al
jne 0x942a0
jmp 0x942d7
leaq 0x97(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xdd50
movq 0x20(%rsp), %rdx
movb $0x1, 0x96(%rsp)
leaq 0x5255b(%rip), %rsi     # 0xe6821
leaq 0x98(%rsp), %rdi
callq 0xfae0
jmp 0x942d5
jmp 0x9434f
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
leaq 0x4f675(%rip), %rsi     # 0xe395c
callq 0x4d5d0
movb %al, 0x1f(%rsp)
jmp 0x942f2
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x942fc
jmp 0x94333
leaq 0x83(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdd50
movq 0x10(%rsp), %rdx
movb $0x1, 0x82(%rsp)
leaq 0x52f21(%rip), %rsi     # 0xe7243
leaq 0x98(%rsp), %rdi
callq 0xfae0
jmp 0x94331
jmp 0x9434d
movq 0x38(%rsp), %rsi
addq $0x48, %rsi
leaq 0x98(%rsp), %rdi
callq 0xd330
jmp 0x9434b
jmp 0x9434d
jmp 0x9434f
testb $0x1, 0x82(%rsp)
jne 0x9435b
jmp 0x94368
leaq 0x83(%rsp), %rdi
callq 0xd7a0
testb $0x1, 0x96(%rsp)
jne 0x94374
jmp 0x94381
leaq 0x97(%rsp), %rdi
callq 0xd7a0
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, 0x8(%rsp)
movl 0x68(%rax), %esi
incl %esi
leaq 0x40(%rsp), %rdi
callq 0x11600
jmp 0x943a3
movq 0x8(%rsp), %rsi
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x50f40
jmp 0x943b9
movq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x12210
jmp 0x943d2
leaq 0x60(%rsp), %rdi
callq 0xdf08
leaq 0x40(%rsp), %rdi
callq 0xdf08
leaq 0x98(%rsp), %rdi
callq 0xdf08
movq 0x30(%rsp), %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x94445
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
testb $0x1, 0x82(%rsp)
jne 0x94436
jmp 0x94443
leaq 0x83(%rsp), %rdi
callq 0xd7a0
jmp 0x94445
testb $0x1, 0x96(%rsp)
jne 0x94451
jmp 0x9445e
leaq 0x97(%rsp), %rdi
callq 0xd7a0
jmp 0x944c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x944b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x944aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xdf08
leaq 0x40(%rsp), %rdi
callq 0xdf08
leaq 0x98(%rsp), %rdi
callq 0xdf08
movq 0x88(%rsp), %rdi
callq 0xdd40
nop
// File: ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::SeqChange::better(Alignment_sp::SeqChange const&) const
bool SeqChange::better (const SeqChange &other) const
{ 
  LESS_PART (other, *this, hasMutation ());
  LESS_PART (*this, other, neighborhoodMismatch);  
  LESS_PART (other, *this, al->pIdentity ());  
  return false;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0xa3d80
movq 0x20(%rsp), %rdi
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2c(%rsp)
callq 0xa3d80
movb %al, %cl
movl 0x2c(%rsp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x9457f
movb $0x1, 0x47(%rsp)
jmp 0x94676
movq 0x20(%rsp), %rdi
callq 0xa3d80
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
callq 0xa3d80
movb %al, %cl
movl 0x1c(%rsp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x945b6
movb $0x0, 0x47(%rsp)
jmp 0x94676
movq 0x20(%rsp), %rax
movsd 0x80(%rax), %xmm1
movq 0x30(%rsp), %rax
movsd 0x80(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x945e0
movb $0x1, 0x47(%rsp)
jmp 0x94676
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movsd 0x80(%rcx), %xmm1
movsd 0x80(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x94607
movb $0x0, 0x47(%rsp)
jmp 0x94676
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xa3df0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rax), %rdi
callq 0xa3df0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9463c
movb $0x1, 0x47(%rsp)
jmp 0x94676
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xa3df0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xa3df0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x94671
movb $0x0, 0x47(%rsp)
jmp 0x94676
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::(anonymous namespace)::reverseDna(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void reverseDna (string &seq)
{
  const size_t len = seq. size ();
  if (! len)
  	return;

  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]);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0xd520
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x9b605
jmp 0x9b774
movq $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rax
shrq %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x9b70f
movq 0x38(%rsp), %rax
subq $0x1, %rax
subq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x9b685
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %edi
callq 0xa39c0
movb %al, 0x17(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xdec0
movb 0x17(%rsp), %cl
movb %cl, (%rax)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x9b6cc
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %edi
callq 0xa39c0
movb %al, 0x16(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdec0
movb 0x16(%rsp), %cl
movb %cl, (%rax)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xdec0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdec0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4cd80
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x9b61b
movq 0x38(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x9b774
movq 0x38(%rsp), %rax
shrq %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x9b772
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %edi
callq 0xa39c0
movb %al, 0x7(%rsp)
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdec0
movb 0x7(%rsp), %cl
movb %cl, (%rax)
jmp 0x9b774
addq $0x48, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<Alignment_sp::AmrMutation>::indexOf(Alignment_sp::AmrMutation const&) const
size_t indexOf (const T &value) const
      { size_t n = 0;
        for (const T& t : *this)
          if (value == t)
            return n;
          else
            n++;
        return no_index;
      }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq $0x0, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11c10
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11c40
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x11c70
testb $0x1, %al
jne 0xa4494
jmp 0xa44e0
leaq 0x18(%rsp), %rdi
callq 0x11cb0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xa6580
testb $0x1, %al
jne 0xa44b8
jmp 0xa44c4
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xa44e9
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xa44d4
leaq 0x18(%rsp), %rdi
callq 0x12410
jmp 0xa447f
movq $-0x1, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ncbi[P]amr/./alignment.hpp
// Function: Alignment_sp::Alignment::saveText(std::ostream&) const
void saveText (ostream &os) const override
    { os         << targetProt
         << '\t' << targetName 
         << '\t' << targetStart
         << '\t' << targetEnd 
         << '\t' << targetLen
         << '\t' << targetStrand
         << '\t' << refName
         << '\t' << refStart
         << '\t' << refEnd
         << '\t' << refLen
         << '\t' << nident
         << '\t' << targetSeq
         << '\t' << refSeq
         << endl;
      if (! refMutation. empty ())
        os << refMutation << endl;
	    os << "# Mutations: " << seqChanges. size () << endl;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xdd60
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0xd680
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rsi
callq 0xd180
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rsi
callq 0xd180
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rsi
callq 0xd180
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movb 0x68(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xdd60
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x78, %rsi
callq 0xd680
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0xb8(%rax), %rsi
callq 0xd180
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rsi
callq 0xd180
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rsi
callq 0xd180
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x200(%rax), %rsi
callq 0xd180
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0xd680
movq %rax, %rdi
movl $0x9, %esi
callq 0xd870
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x98, %rsi
callq 0xd680
movq %rax, %rdi
movq 0x7ae91(%rip), %rsi     # 0x11ff50
callq 0xd760
movq 0x10(%rsp), %rdi
addq $0xd0, %rdi
callq 0xa3be0
testb $0x1, %al
jne 0xa50fe
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0xd0, %rsi
callq 0x4ece0
movq %rax, %rdi
movq 0x7ae57(%rip), %rsi     # 0x11ff50
callq 0xd760
movq 0x18(%rsp), %rdi
leaq 0x42e05(%rip), %rsi     # 0xe7f0f
callq 0xd6f0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x218, %rdi            # imm = 0x218
callq 0xa4ae0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd180
movq %rax, %rdi
movq 0x7ae14(%rip), %rsi     # 0x11ff50
callq 0xd760
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Alignment_sp::AmrMutation const* Common_sp::checkPtr<Alignment_sp::AmrMutation const>(Alignment_sp::AmrMutation const*)
inline T* checkPtr (T* t)
    { if (t)
        return t;
      throwf ("Dereferencing nullptr");
      return nullptr;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xa5c4b
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xdd50
movq (%rsp), %rdx
leaq 0x42295(%rip), %rsi     # 0xe7ef9
leaq 0x20(%rsp), %rdi
callq 0xfae0
jmp 0xa5c70
leaq 0x20(%rsp), %rdi
callq 0x173d0
jmp 0xa5c7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0xa5ca4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xdf08
leaq 0x1f(%rsp), %rdi
callq 0xd7a0
movq 0x10(%rsp), %rdi
callq 0xdd40
nopl (%rax,%rax)
// File: ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::getTaxonStart(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_t Seq::getTaxonStart (const string &s) 
{
  size_t brackets = 0;
  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
  }
 	return string::npos;  // Non-balanced brackets: too many ']'
 
#if 0
  if (s [s. size () - 1] != ']')
  	return string::npos;
  const size_t pos = s. rfind ('[');
  if (pos == string::npos)
  	return string::npos;
  ASSERT (pos < s. size () - 1);
  return pos;
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd520
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rsp)
cmpq $0x0, %rax
jbe 0xaa9cd
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xd7d0
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0xaa963
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xaa9b5
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xd7d0
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0xaa9b3
cmpq $0x1, 0x10(%rsp)
jne 0xaa98e
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xaa9d6
cmpq $0x0, 0x10(%rsp)
jne 0xaa9a1
movq $-0x1, 0x20(%rsp)
jmp 0xaa9d6
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xaa9b1
jmp 0xaa9b3
jmp 0xaa9b5
cmpq $0x0, 0x10(%rsp)
jne 0xaa9c8
movq $-0x1, 0x20(%rsp)
jmp 0xaa9d6
jmp 0xaa921
movq $-0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x28(%rsp)
addq $0x28, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd6d0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xddf0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4c7b0
testb $0x1, %al
jne 0xab4f7
jmp 0xab53a
leaq 0x18(%rsp), %rdi
callq 0x4c7f0
movq (%rsp), %rdi
movb (%rax), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %cl
movq (%rdi), %rax
movsbl %cl, %esi
callq *0x68(%rax)
testb $0x1, %al
jne 0xab51e
jmp 0xab52c
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xab52e
leaq 0x18(%rsp), %rdi
callq 0x4c880
jmp 0xab4e2
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
addq $0x28, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd6d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xddf0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4c7b0
testb $0x1, %al
jne 0xab5b1
jmp 0xab60f
leaq 0x20(%rsp), %rdi
callq 0x4c7f0
movq 0x8(%rsp), %rdi
movb (%rax), %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %cl
movq (%rdi), %rax
movsbl %cl, %esi
callq *0x68(%rax)
testb $0x1, %al
jne 0xab5d9
jmp 0xab5e9
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0xab601
movq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xd7d40
movq $0x0, 0x30(%rsp)
jmp 0xab603
leaq 0x20(%rsp), %rdi
callq 0x4c880
jmp 0xab59c
movq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xd7d40
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x57(%rsp)
callq 0xd7d80
movq 0x18(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xd6d0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xddf0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4c7b0
testb $0x1, %al
jne 0xab6a0
jmp 0xab6f9
leaq 0x40(%rsp), %rdi
callq 0x4c7f0
movq 0x8(%rsp), %rdi
movb (%rax), %al
movb %al, 0x37(%rsp)
leaq 0x37(%rsp), %rsi
callq 0xd7d90
movq %rax, (%rsp)
jmp 0xab6c5
movq (%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
leaq 0x40(%rsp), %rdi
callq 0x4c880
jmp 0xab68b
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xd7e80
jmp 0xab719
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xab70f
movq 0x8(%rsp), %rdi
callq 0xd7e80
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xdd40
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x220(%rax)
jne 0xab857
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0xdc60
testb $0x1, %al
jne 0xab78e
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x268, %rdi            # imm = 0x268
xorl %eax, %eax
movl %eax, %esi
callq 0xd7d0
movsbl (%rax), %eax
cmpl $0x3e, %eax
je 0xab857
movb $0x1, 0x13(%rsp)
movl $0x10, %edi
callq 0xd3b0
movq 0x8(%rsp), %rsi
movq %rax, (%rsp)
addq $0x8, %rsi
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
callq 0xd7e90
jmp 0xab7bb
leaq 0x3ce98(%rip), %rsi     # 0xe865a
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x12260
jmp 0xab7d3
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xdbf0
jmp 0xab7e3
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0x747fd(%rip), %rsi     # 0x11fff0
movq 0x74776(%rip), %rdx     # 0x11ff70
callq 0xdcd0
jmp 0xab866
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xab843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xab839
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdf08
leaq 0x20(%rsp), %rdi
callq 0xdf08
testb $0x1, 0x13(%rsp)
jne 0xab84c
jmp 0xab855
movq (%rsp), %rdi
callq 0xd570
jmp 0xab85c
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xdd40
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movb %dil, %al
movb %al, 0x9f(%rsp)
movsbl 0x9f(%rsp), %edi
callq 0x4cb20
movb %al, 0x9e(%rsp)
movsbl 0x9e(%rsp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
subl $0x13, %eax
ja 0xab905
movq 0x18(%rsp), %rax
leaq 0x3c668(%rip), %rcx     # 0xe7f20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, 0xa0(%rsp)
jmp 0xaba4a
movq $0x1, 0xa0(%rsp)
jmp 0xaba4a
movq $0x2, 0xa0(%rsp)
jmp 0xaba4a
movq $0x3, 0xa0(%rsp)
jmp 0xaba4a
movsbl 0x9e(%rsp), %edi
callq 0xd7f30
testb $0x1, %al
jne 0xab918
jmp 0xab929
movq $0x4, 0xa0(%rsp)
jmp 0xaba4a
movb $0x1, 0x23(%rsp)
movl $0x10, %edi
callq 0xd3b0
movq %rax, (%rsp)
movsbl 0x9f(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdd50
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x12980
jmp 0xab971
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl $0x22, %edx
callq 0x1af10
jmp 0xab987
leaq 0x3cce2(%rip), %rdx     # 0xe8670
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x114c0
jmp 0xab99f
movq (%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xdbf0
jmp 0xab9af
movq (%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x74631(%rip), %rsi     # 0x11fff0
movq 0x745aa(%rip), %rdx     # 0x11ff70
callq 0xdcd0
jmp 0xaba64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xaba2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xaba22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xaba18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xdf08
leaq 0x58(%rsp), %rdi
callq 0xdf08
leaq 0x38(%rsp), %rdi
callq 0xdf08
leaq 0x37(%rsp), %rdi
callq 0xd7a0
testb $0x1, 0x23(%rsp)
jne 0xaba3f
jmp 0xaba48
movq (%rsp), %rdi
callq 0xd570
jmp 0xaba5a
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xdd40
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, (%rax)
je 0xac3c7
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
je 0xac386
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0xac36c
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xac365
movb $0x6e, 0x7(%rsp)
jmp 0xac36a
movb $0x76, 0x7(%rsp)
jmp 0xac384
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xac37d
movb $0x68, 0x7(%rsp)
jmp 0xac382
movb $0x6d, 0x7(%rsp)
jmp 0xac384
jmp 0xac3c2
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0xac3a8
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xac3a1
movb $0x64, 0x7(%rsp)
jmp 0xac3a6
movb $0x72, 0x7(%rsp)
jmp 0xac3c0
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xac3b9
movb $0x77, 0x7(%rsp)
jmp 0xac3be
movb $0x61, 0x7(%rsp)
jmp 0xac3c0
jmp 0xac3c2
jmp 0xac44b
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
je 0xac40d
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0xac3f3
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xac3ec
movb $0x62, 0x7(%rsp)
jmp 0xac3f1
movb $0x73, 0x7(%rsp)
jmp 0xac40b
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xac404
movb $0x79, 0x7(%rsp)
jmp 0xac409
movb $0x63, 0x7(%rsp)
jmp 0xac40b
jmp 0xac449
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0xac42f
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xac428
movb $0x6b, 0x7(%rsp)
jmp 0xac42d
movb $0x67, 0x7(%rsp)
jmp 0xac447
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xac440
movb $0x74, 0x7(%rsp)
jmp 0xac445
movb $0x2d, 0x7(%rsp)
jmp 0xac447
jmp 0xac449
jmp 0xac44b
movq 0x28(%rsp), %rax
testb $0x1, 0x4(%rax)
je 0xac466
movsbl 0x7(%rsp), %edi
callq 0x4cae0
movb %al, 0x37(%rsp)
jmp 0xac47f
movsbl 0x7(%rsp), %eax
cmpl $0x2d, %eax
jne 0xac477
movb $0x20, 0x37(%rsp)
jmp 0xac47f
movb 0x7(%rsp), %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xd520
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0xad2bf
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xad438
movq $0x0, 0x38(%rsp)
movq 0x40(%rsp), %rax
shrq %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0xad3c9
movq 0x40(%rsp), %rax
subq $0x1, %rax
subq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xad33f
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %edi
callq 0xac490
movb %al, 0x1f(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xdec0
movb 0x1f(%rsp), %cl
movb %cl, (%rax)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xad386
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %edi
callq 0xac490
movb %al, 0x1e(%rsp)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdec0
movb 0x1e(%rsp), %cl
movb %cl, (%rax)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xdec0
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdec0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4cd80
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0xad2d5
movq 0x40(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xad42e
movq 0x40(%rsp), %rax
shrq %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xad42c
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdec0
movsbl (%rax), %edi
callq 0xac490
movb %al, 0xf(%rsp)
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdec0
movb 0xf(%rsp), %cl
movb %cl, (%rax)
jmp 0xad42e
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x50, %edi
callq 0xd700
movq 0x18(%rsp), %rsi
movq %rax, 0x20(%rsp)
movb $0x1, 0x3b(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11bc0
jmp 0xaf831
leaq 0x3905d(%rip), %rdx     # 0xe8895
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x114c0
jmp 0xaf849
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0xd520
movq 0x20(%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rax
movzbl 0x48(%rax), %ecx
andl $0x1, %ecx
leaq 0x68(%rsp), %rsi
callq 0xd8040
jmp 0xaf877
movb $0x0, 0x3b(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xdf08
leaq 0x48(%rsp), %rdi
callq 0xdf08
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdi
movq %rax, 0x88(%rsp)
movq $0x0, 0x30(%rsp)
addq $0x28, %rdi
callq 0xd520
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0xaf98d
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
callq 0xd520
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
subq 0x30(%rsp), %rsi
callq 0xd7d0
movsbl (%rax), %edi
callq 0xac490
movb %al, 0x17(%rsp)
movq 0x88(%rsp), %rdi
addq $0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0xdec0
movb 0x17(%rsp), %cl
movb %cl, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0xaf8b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xaf973
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xaf969
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xdf08
leaq 0x48(%rsp), %rdi
callq 0xdf08
testb $0x1, 0x3b(%rsp)
jne 0xaf97c
jmp 0xaf98b
movq 0x20(%rsp), %rdi
movl $0x50, %esi
callq 0xd710
jmp 0xaf99d
movq 0x88(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xdd40
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x80, 0x20(%rsp)
jae 0xb6922
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xd8410
testb $0x1, %al
jne 0xb68f1
jmp 0xb6910
movq 0x28(%rsp), %rdi
movl $0x20, %esi
callq 0xd870
movq %rax, %rdi
movq 0x20(%rsp), %rax
movsbl %al, %esi
callq 0xd870
jmp 0xb6912
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xb68d1
movq 0x28(%rsp), %rdi
movq 0x69622(%rip), %rsi     # 0x11ff50
callq 0xd760
movq $0x0, 0x18(%rsp)
cmpq $0x80, 0x18(%rsp)
jae 0xb6a0c
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd8410
testb $0x1, %al
jne 0xb6963
jmp 0xb69f7
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movsbl %al, %esi
callq 0xd870
movq $0x0, 0x10(%rsp)
cmpq $0x80, 0x10(%rsp)
jae 0xb69e6
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd8410
testb $0x1, %al
jne 0xb699e
jmp 0xb69d4
movq 0x28(%rsp), %rdi
movl $0x20, %esi
callq 0xd870
movq %rax, %rdi
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq 0x18(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0xde30
jmp 0xb69d6
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xb697e
movq 0x28(%rsp), %rdi
movq 0x6955e(%rip), %rsi     # 0x11ff50
callq 0xd760
jmp 0xb69f9
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xb693c
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x80, 0x18(%rsp)
jae 0xb6b9d
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd8410
testb $0x1, %al
jne 0xb6a63
jmp 0xb6b8a
movq $0x0, 0x10(%rsp)
cmpq $0x80, 0x10(%rsp)
jae 0xb6b88
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd8410
testb $0x1, %al
jne 0xb6a93
jmp 0xb6b75
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq 0x18(%rsp), %rdx
shlq $0xa, %rdx
addq %rdx, %rcx
movq 0x18(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm1
addq $0x8, %rax
movq 0x18(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb6b73
movq 0x694b0(%rip), %rdi     # 0x11ff90
leaq 0x3224f(%rip), %rsi     # 0xe8d36
callq 0xd6f0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movsbl %al, %esi
callq 0xd870
movq %rax, %rdi
movl $0x2c, %esi
callq 0xd870
movq %rax, %rdi
movq 0x18(%rsp), %rax
movsbl %al, %esi
callq 0xd870
movq %rax, %rdi
leaq 0x3220f(%rip), %rsi     # 0xe8d32
callq 0xd6f0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movsbl %al, %esi
callq 0xd870
movq %rax, %rdi
movl $0x2c, %esi
callq 0xd870
movq %rax, %rdi
movq 0x10(%rsp), %rax
movsbl %al, %esi
callq 0xd870
movq %rax, %rdi
leaq 0x306e2(%rip), %rsi     # 0xe7241
callq 0xd6f0
movq %rax, %rdi
movq 0x693e2(%rip), %rsi     # 0x11ff50
callq 0xd760
jmp 0xb6b75
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xb6a6c
jmp 0xb6b8a
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xb6a3c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x140(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x64e45(%rip), %rax     # 0x120c58
testb $0x1, (%rax)
jne 0xbbe1d
jmp 0xbc0bc
movq 0x18(%rsp), %rdi
callq 0xd8550
movq 0x18(%rsp), %rdi
callq 0xd8590
testb $0x1, %al
jne 0xbbe3a
jmp 0xbc0bc
callq 0xd0a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movl $0x0, (%rcx)
testb $0x1, 0x49(%rax)
jne 0xbc0ba
callq 0xd8c0
cmpl $0x0, %eax
jne 0xbc0b0
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdd50
movq 0x10(%rsp), %rdx
leaq 0x2c5c3(%rip), %rsi     # 0xe8446
leaq 0xa0(%rsp), %rdi
callq 0xfae0
jmp 0xbbe92
leaq 0x68(%rsp), %rdi
movl $0xdac, %esi            # imm = 0xDAC
callq 0x11600
jmp 0xbbea3
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x11510
jmp 0xbbebf
leaq 0x2730b(%rip), %rdx     # 0xe31d1
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x114c0
jmp 0xbbedd
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xdd50
movq 0x8(%rsp), %rdx
leaq 0x2d0dd(%rip), %rsi     # 0xe8fd5
leaq 0x28(%rsp), %rdi
callq 0xfae0
jmp 0xbbf04
leaq 0x27a99(%rip), %rdx     # 0xe39a4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x114c0
jmp 0xbbf1c
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x11510
jmp 0xbbf38
leaq 0x2d0bf(%rip), %rdx     # 0xe8ffe
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x114c0
jmp 0xbbf56
leaq 0x120(%rsp), %rdi
callq 0x173d0
jmp 0xbbf65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbc0a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbc094
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbc08a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbc07d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbc066
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbc05c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbc052
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbc045
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x120(%rsp), %rdi
callq 0xdf08
leaq 0x100(%rsp), %rdi
callq 0xdf08
leaq 0x48(%rsp), %rdi
callq 0xdf08
leaq 0x28(%rsp), %rdi
callq 0xdf08
leaq 0x27(%rsp), %rdi
callq 0xd7a0
leaq 0xe0(%rsp), %rdi
callq 0xdf08
leaq 0xc0(%rsp), %rdi
callq 0xdf08
leaq 0x68(%rsp), %rdi
callq 0xdf08
leaq 0xa0(%rsp), %rdi
callq 0xdf08
leaq 0x9f(%rsp), %rdi
callq 0xd7a0
jmp 0xbc0c4
movl $0x1, %edi
callq 0xd8e0
jmp 0xbc0bc
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x90(%rsp), %rdi
callq 0xdd40
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/seq.cpp
// Function: Seq_sp::Peptide::ambig2X()
size_t Peptide::ambig2X ()
{
  size_t n = 0;
  for (char& c : seq)
    if (charInSet (c, "BZJUO"))
    {
      c = 'X';
      n++;
    }
  
  return n;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq $0x0, 0x68(%rsp)
addq $0x28, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0xd660
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0xd450
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x4ca90
testb $0x1, %al
jne 0xbecf6
jmp 0xbedc9
leaq 0x58(%rsp), %rdi
callq 0x4cad0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movb (%rax), %al
movb %al, 0x7(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xdd50
movq 0x8(%rsp), %rdx
leaq 0x296f8(%rip), %rsi     # 0xe8423
leaq 0x28(%rsp), %rdi
callq 0xfae0
jmp 0xbed37
movb 0x7(%rsp), %al
movsbl %al, %edi
leaq 0x28(%rsp), %rsi
callq 0x4cba0
movb %al, 0x6(%rsp)
jmp 0xbed4e
leaq 0x28(%rsp), %rdi
callq 0xdf08
leaq 0x27(%rsp), %rdi
callq 0xd7a0
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0xbed6c
jmp 0xbedb8
movq 0x48(%rsp), %rax
movb $0x58, (%rax)
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0xbedb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xbedac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdf08
leaq 0x27(%rsp), %rdi
callq 0xd7a0
jmp 0xbedd3
jmp 0xbedba
leaq 0x58(%rsp), %rdi
callq 0x4cb00
jmp 0xbecde
movq 0x68(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xdd40
nopl (%rax)
// File: ncbi[P]amr/seq.cpp
// Function: Seq_sp::Cds::operator<(Seq_sp::Cds const&) const
bool Cds::operator< (const Cds &other) const
{
  LESS_PART (*this, other, left ());
  LESS_PART (other, *this, right ());
  LESS_PART (other, *this, positives);
  return refProt < refProt;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xd88d0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd88d0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0xc1043
movb $0x1, 0x47(%rsp)
jmp 0xc112d
movq 0x30(%rsp), %rdi
callq 0xd88d0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xd88d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0xc1073
movb $0x0, 0x47(%rsp)
jmp 0xc112d
movq 0x30(%rsp), %rdi
callq 0xd88f0
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0xd88f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xc10a3
movb $0x1, 0x47(%rsp)
jmp 0xc112d
movq 0x20(%rsp), %rdi
callq 0xd88f0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd88f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xc10d0
movb $0x0, 0x47(%rsp)
jmp 0xc112d
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movsd 0x38(%rcx), %xmm1
movsd 0x38(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc10f1
movb $0x1, 0x47(%rsp)
jmp 0xc112d
movq 0x20(%rsp), %rax
movsd 0x38(%rax), %xmm1
movq 0x30(%rsp), %rax
movsd 0x38(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc1112
movb $0x0, 0x47(%rsp)
jmp 0xc112d
movq 0x20(%rsp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x12fb0
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: ncbi[P]amr/seq.cpp
// Function: Seq_sp::(anonymous namespace)::Cell::Cell()
Cell () 
    { constexpr AlignScore score_inf = numeric_limits<AlignScore>::infinity ();
      scores [dirLeft] = - score_inf;
      scores [dirUp]   = - score_inf;
      scores [dirDiag] = - score_inf;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movsd 0x22dce(%rip), %xmm0    # 0xe83c8
movsd %xmm0, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd8e00
movq (%rsp), %rdi
movsd 0x22dab(%rip), %xmm0    # 0xe83c0
movsd %xmm0, (%rax)
movl $0x1, %esi
callq 0xd8e00
movq (%rsp), %rdi
movsd 0x22d91(%rip), %xmm0    # 0xe83c0
movsd %xmm0, (%rax)
movl $0x2, %esi
callq 0xd8e00
movsd 0x22d7b(%rip), %xmm0    # 0xe83c0
movsd %xmm0, (%rax)
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x58, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd660
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd450
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4ca90
testb $0x1, %al
jne 0xca5af
jmp 0xca5fa
leaq 0x20(%rsp), %rdi
callq 0x4cad0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movb (%rcx), %cl
movb %cl, 0x17(%rsp)
movb 0x17(%rsp), %cl
movb 0x8(%rax), %al
andb $0x1, %al
movsbl %cl, %edi
movzbl %al, %esi
callq 0xd8f10
testb $0x1, %al
jne 0xca5e1
jmp 0xca5ec
movq 0x8(%rsp), %rax
movb $0x1, 0x79(%rax)
jmp 0xca5fa
jmp 0xca5ee
leaq 0x20(%rsp), %rdi
callq 0x4cb00
jmp 0xca59a
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movb 0x8(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xcbe0c
movb $0x1, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x8(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xcbe35
movb $0x0, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0xcbe52
jmp 0xcbe5c
movb $0x1, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0xcbe79
jmp 0xcbe83
movb $0x0, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jae 0xcbea1
movb $0x1, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
cmpq 0x30(%rcx), %rax
jae 0xcbebf
movb $0x0, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0xcbedc
jmp 0xcbee6
movb $0x1, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
addq $0x38, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0xcbf03
jmp 0xcbf0d
movb $0x0, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
movq 0x10(%rsp), %rsi
addq $0x58, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0xcbf2a
jmp 0xcbf31
movb $0x1, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
addq $0x58, %rsi
callq 0x12fb0
testb $0x1, %al
jne 0xcbf4e
jmp 0xcbf55
movb $0x0, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rax
movb 0x78(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movb 0x78(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xcbf7b
movb $0x1, 0x27(%rsp)
jmp 0xcbfa6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movb 0x78(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x78(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xcbfa1
movb $0x0, 0x27(%rsp)
jmp 0xcbfa6
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x10(%rsp)
cmpq $0x18, -0x10(%rsp)
jae 0xcd4f8
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movsbl 0x18(%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xcd4e6
jmp 0xcd4f8
jmp 0xcd4e8
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0xcd4c8
movq -0x10(%rsp), %rax
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x4d0e0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xd8d0
movq 0x10(%rsp), %rsi
movq (%rsi), %rdi
addq $0x10, %rdi
addq $0x10, %rsi
callq 0xd8fb0
movq $0x0, 0x18(%rsp)
cmpq $0x18, 0x18(%rsp)
jae 0xcd592
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
movq 0x18(%rsp), %rcx
movsbl 0x18(%rax,%rcx), %esi
callq 0xd060
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xcd55f
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xda50
movq 0x10(%rsp), %rdi
movl $0x18, %esi
callq 0xdb90
jmp 0xce71f
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rsp)
cmpq $0x0, %rax
jbe 0xce77b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl 0x18(%rax,%rcx), %esi
callq 0xd4b0
jmp 0xce75f
jmp 0xce72d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xdf08
jmp 0xce79a
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xce791
movq 0x10(%rsp), %rdi
callq 0xdf08
movq (%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xdd40
nopw %cs:(%rax,%rax)