LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Dir::getParent[abi:cxx11]() const
string getParent () const
    { if (items. empty ())
        return "..";
      if (items. size () == 1 && items. front (). empty ())
        throw runtime_error ("Cannot get the parent directory of the root");
      const Dir parent (get () + "/..");
      return parent. get ();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rsi, %rax
je 0x2d40c
cmpq $0x1, 0x10(%rsi)
jne 0x2d3ca
cmpq $0x0, 0x18(%rax)
je 0x2d4a9
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x2da06
leaq 0x5eb60(%rip), %rsi     # 0x8bf3e
movq %r14, %rdi
callq 0xaac0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2d42b
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2d432
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5eb25(%rip), %rsi     # 0x8bf3f
leaq 0x5eb20(%rip), %rdx     # 0x8bf41
movq %rbx, %rdi
callq 0x2fa1a
jmp 0x2d49e
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x20(%rsp), %rdi
callq 0x3c154
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2d46c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d487
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2da06
leaq 0x20(%rsp), %rdi
callq 0x2f9d4
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x5ea55(%rip), %rsi     # 0x8bf12
movq %rax, %rdi
callq 0xa230
movq 0x82b1c(%rip), %rsi     # 0xaffe8
movq 0x82a8d(%rip), %rdx     # 0xaff60
movq %r14, %rdi
callq 0xa9b0
movq %rax, %rbx
movq %r14, %rdi
callq 0xa440
jmp 0x2d530
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2f9d4
jmp 0x2d530
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2d515
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2d515
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d530
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::path2canonical(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline string path2canonical (const string &path)
    { if (char* p = realpath (path. c_str (), nullptr))
      { const string s (p);
        free (p);
        return s;
      }
      throw runtime_error ("path2canonical " + shellQuote (path));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
xorl %esi, %esi
callq 0xa1e0
testq %rax, %rax
je 0x2dbf8
movq %rax, %r15
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0xa260
movq %r15, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2fa1a
movq %r15, %rdi
callq 0xa690
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2c212
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2cac1
leaq 0x5e30e(%rip), %rsi     # 0x8bf46
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2bbf7
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x82388(%rip), %rsi     # 0xaffe8
movq 0x822f9(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dc95
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2dc95
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dcb0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2dcc7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x2dced
jmp 0x2dcf5
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2dced
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2dced
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Threads::exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
bool exec (const string cmd,
	           size_t cmdThreads = 1)
	  { if (cmdThreads && getAvailable () >= cmdThreads)
	    { *this << thread (Common_sp::exec, cmd, noString);
	      threadsToStart -= cmdThreads - 1;
	      return true;
	    }
      Common_sp::exec (cmd);
	    return false;
	  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdx
testq %rbx, %rbx
je 0x2e630
movq %rdi, %r14
leaq 0x824ed(%rip), %r12     # 0xb0b00
movq (%r12), %rax
movq 0x8(%rdi), %rcx
subq (%rdi), %rcx
sarq $0x3, %rcx
xorl %esi, %esi
subq %rcx, %rax
cmovaeq %rax, %rsi
cmpq %rbx, %rsi
jae 0x2e643
leaq 0x824a1(%rip), %rsi     # 0xb0ad8
movq %rdx, %rdi
callq 0x3f921
xorl %eax, %eax
jmp 0x2e67e
leaq 0x112d7(%rip), %rsi     # 0x3f921
leaq 0x82487(%rip), %rcx     # 0xb0ad8
movq %rsp, %r15
movq %r15, %rdi
callq 0x3174e
movq %r14, %rdi
movq %r15, %rsi
callq 0x31588
cmpq $0x0, (%rsp)
jne 0x2e699
movq (%r12), %rax
subq %rbx, %rax
incq %rax
movq %rax, (%r12)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x0, (%rsp)
jne 0x2e699
movq %rax, %rdi
callq 0xaa10
callq 0xa150
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TextTable::col2num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
ColNum col2num (const string &columnName) const
    { const ColNum i = col2num_ (columnName);
      if (i == no_index)
        throw Error (*this, "Table has no column " + strQuote (columnName));
      return i;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x7ff96
cmpq $-0x1, %rax
je 0x2ea00
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x22, %edx
callq 0x38a3a
leaq 0x5d7d8(%rip), %rsi     # 0x8c1fe
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2bbf7
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3263e
xorl %ebp, %ebp
leaq 0x8008f(%rip), %rsi     # 0xaeae0
movq 0x81528(%rip), %rdx     # 0xaff80
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ea7e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ea99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x2eac3
jmp 0x2eacb
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eac3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2eac3
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: double Common_sp::str2<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T str2 (const string &s)
    { static_assert (numeric_limits<T>::max() > 256, "str2 does not work on chars");
    	T i;
    	istringstream iss (s);
      iss >> i;
      if (   Common_sp::strBlank (s)
          || ! iss. eof ()
          || iss. fail ()
         )
        throw runtime_error ("Cannot convert " + strQuote (s) + " to number");
      return i;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, %r14
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0xa980
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xa3c0
movq %r14, %rdi
callq 0x37f01
testb %al, %al
jne 0x2ebe3
movq 0x78(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x98(%rsp,%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
jne 0x2ebe3
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x813a0(%rip), %rsi     # 0xaff58
leaq 0x78(%rsp), %rdi
callq 0xa7e0
leaq 0xf0(%rsp), %rdi
callq 0xa1c0
movsd 0x8(%rsp), %xmm0
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38a3a
leaq 0x5d2b3(%rip), %rsi     # 0x8bebc
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x2bbf7
leaq 0x5d2bd(%rip), %rsi     # 0x8bedc
leaq 0x58(%rsp), %rdi
callq 0xaac0
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2ec4a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2ec57
movq %rdx, 0x38(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x48(%rsp)
movq 0x8(%rax), %rdx
leaq 0x38(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x81361(%rip), %rsi     # 0xaffe8
movq 0x812d2(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ecb8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2ecb8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ecd3
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ecee
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x2ed18
jmp 0x2ed25
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ed18
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2ed18
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
jmp 0x2ed25
movq %rax, %r14
movq 0x8122c(%rip), %rsi     # 0xaff58
leaq 0x78(%rsp), %rdi
callq 0xa7e0
leaq 0xf0(%rsp), %rdi
callq 0xa1c0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>& Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&)
Vector<T>& operator<< (vector<U> &&other)
        { reserveInc (other. size ());
          for (U& t : other)
            P::push_back (std::move (t));
          unsetSearchSorted ();
          other. clear ();
        	return *this;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x5, %rax
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x5, %rsi
addq %rax, %rsi
callq 0x2fb76
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x2faf9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2fc7a
addq $0x20, %r15
jmp 0x2fae3
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x2fb0a
movb $0x0, 0x18(%rbx)
movq (%r14), %rsi
movq %r14, %rdi
callq 0x2fece
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::sort()
void sort ()
      { if (searchSorted)
          return;
        Common_sp::sort (*this); 
        searchSorted = true;
      }

// Assembly:
cmpb $0x0, 0x18(%rdi)
jne 0x2fb74
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x2fb6b
movq %r15, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ff5f
movq %r14, %rdi
movq %r15, %rsi
callq 0x30033
movb $0x1, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::eraseMany(unsigned long, unsigned long)
void eraseMany (size_t from,
                    size_t to)
      { if (to < from)
          throw runtime_error ("Vector::eraseMany(): to < from");
        if (to == from)
          return;
        checkIndex ("eraseMany", to - 1);
        auto it1 = P::begin ();
        std::advance (it1, from);
        auto it2 = it1;
        std::advance (it2, to - from);
        P::erase (it1, it2);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq %rsi, %rdx
jb 0x31464
je 0x31458
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x5adab(%rip), %rsi     # 0x8c1ab
leaq 0x5adad(%rip), %rdx     # 0x8c1b4
leaq 0x8(%rsp), %rdi
callq 0x2fa1a
leaq -0x1(%rbx), %rdx
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x30f2c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x31439
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq (%r15), %rax
shlq $0x5, %r14
addq %rax, %r14
shlq $0x5, %rbx
addq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x314ca
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x5ad14(%rip), %rsi     # 0x8c18c
movq %rax, %rdi
callq 0xa230
movq 0x7eb61(%rip), %rsi     # 0xaffe8
movq 0x7ead2(%rip), %rdx     # 0xaff60
movq %r14, %rdi
callq 0xa9b0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x314c2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x314c2
movq %rax, %rbx
jmp 0x314c2
movq %rax, %rbx
movq %r14, %rdi
callq 0xa440
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::(anonymous namespace)::sigpipe_handler(int)
[[noreturn]] void sigpipe_handler (int /*sig_num*/) 
{
  signal (SIGPIPE, SIG_DFL);
  if (sigpipe)
    exit (0);
  exit (1);
}

// Assembly:
pushq %rax
movl $0xd, %edi
xorl %esi, %esi
callq 0xa680
cmpb $0x1, 0x7c800(%rip)     # 0xb0ac1
jne 0x342ca
xorl %edi, %edi
callq 0xa6c0
movl $0x1, %edi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Chronometer::start()
void Chronometer::start ()
{ 
  if (! on ())
    return;
  if (started ())
    throw runtime_error (FUNC "Chronometer \""  + name + "\" is not stopped");
  startTime = clock (); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpb $0x1, 0x7b248(%rip)     # 0xb0ad2
jne 0x358a9
cmpq $0x1, 0x7ad24(%rip)     # 0xb05b8
jne 0x358a9
movq %rdi, %r14
cmpq $-0x1, 0x28(%rdi)
jne 0x358bb
callq 0xa3d0
movq %rax, 0x28(%r14)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x570bd(%rip), %rsi     # 0x8c995
leaq 0x570da(%rip), %rdx     # 0x8c9b9
leaq 0x8(%rsp), %rdi
callq 0x2fa1a
leaq 0x570ca(%rip), %rsi     # 0x8c9ba
leaq 0x8(%rsp), %rdi
callq 0xaac0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3591d
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x3592a
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x68(%rsp), %rdi
movq %r14, %rdx
callq 0x2d34c
leaq 0x57070(%rip), %rsi     # 0x8c9ca
leaq 0x68(%rsp), %rdi
callq 0xaac0
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x35986
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x35993
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x7a625(%rip), %rsi     # 0xaffe8
movq 0x7a596(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x359f4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x359f4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35a17
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35a17
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x35a2e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x35a45
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x35a6b
jmp 0x35a73
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x35a6b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35a6b
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Chronometer::stop()
void Chronometer::stop () 
{ 
  if (! on ())
    return;
  if (! started ())
    throw runtime_error (FUNC "Chronometer \"" + name + "\" is not started");
  time += clock () - startTime; 
  startTime = noclock;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpb $0x1, 0x7b03e(%rip)     # 0xb0ad2
jne 0x35abf
cmpq $0x1, 0x7ab1a(%rip)     # 0xb05b8
jne 0x35abf
movq %rdi, %r14
cmpq $-0x1, 0x28(%rdi)
je 0x35ad1
callq 0xa3d0
subq 0x28(%r14), %rax
addq %rax, 0x20(%r14)
movq $-0x1, 0x28(%r14)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x56eed(%rip), %rsi     # 0x8c9db
leaq 0x56f09(%rip), %rdx     # 0x8c9fe
leaq 0x8(%rsp), %rdi
callq 0x2fa1a
leaq 0x56eb4(%rip), %rsi     # 0x8c9ba
leaq 0x8(%rsp), %rdi
callq 0xaac0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x35b33
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x35b40
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x68(%rsp), %rdi
movq %r14, %rdx
callq 0x2d34c
leaq 0x56e8f(%rip), %rsi     # 0x8c9ff
leaq 0x68(%rsp), %rdi
callq 0xaac0
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x35b9c
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x35ba9
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x7a40f(%rip), %rsi     # 0xaffe8
movq 0x7a380(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x35c0a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35c0a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35c2d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35c2d
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x35c44
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x35c5b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x35c81
jmp 0x35c89
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x35c81
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35c81
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Chronometer::print(std::ostream&) const
void Chronometer::print (ostream &os) const
{ 
  if (! on ())
    return;       
  os << "CHRON: " << name << ": ";
  const ONumber onm (os, 2, false);
  os << (double) time / CLOCKS_PER_SEC << " sec." << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x7ae32(%rip)     # 0xb0ad2
jne 0x35d85
cmpq $0x1, 0x7a90a(%rip)     # 0xb05b8
jne 0x35d85
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x56d4f(%rip), %rsi     # 0x8ca10
movl $0x7, %edx
movq %rbx, %rdi
callq 0xa640
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa640
leaq 0x56c21(%rip), %rsi     # 0x8c905
movl $0x2, %edx
movq %rax, %rdi
callq 0xa640
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movq 0x8(%rbx,%rcx), %r15
movl 0x18(%rbx,%rcx), %ebp
movl %ebp, %edx
andl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
orl $0x4, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%rbx,%rax)
cvtsi2sdq 0x20(%r14), %xmm0
divsd 0x56865(%rip), %xmm0    # 0x8c590
movq %rbx, %rdi
callq 0xa910
movq %rax, %r14
leaq 0x56cdb(%rip), %rsi     # 0x8ca18
movl $0x5, %edx
movq %rax, %rdi
callq 0xa640
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xa570
movsbl %al, %esi
movq %r14, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3f0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl %ebp, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq %r15, 0x8(%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rcx
movq -0x18(%rcx), %rdx
movl %ebp, 0x18(%rbx,%rdx)
movq -0x18(%rcx), %rcx
movq %r15, 0x8(%rbx,%rcx)
movq %rax, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Chronometer_OnePass::~Chronometer_OnePass()
Chronometer_OnePass::~Chronometer_OnePass ()
{ 
  if (! active)
    return;
  if (uncaught_exceptions ())
    return;
    
  const time_t stop = time (nullptr);
  
  {
    const OColor oc (os, color, false, true);  
    os << "CHRON: " << name << ": ";
    const ONumber on (os, 0, false);
    os << difftime (stop, start) << " sec.";
  }
  os << endl;  

  if (addNewLine)
    os << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x29(%rdi)
jne 0x35f59
callq 0xa6b0
testl %eax, %eax
jne 0x35f59
xorl %edi, %edi
callq 0xa550
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rsp, %rdi
movl $0x23, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2f4e2
movq 0x20(%rbx), %r15
leaq 0x56bba(%rip), %rsi     # 0x8ca10
movl $0x7, %edx
movq %r15, %rdi
callq 0xa640
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0xa640
leaq 0x56a8c(%rip), %rsi     # 0x8c905
movl $0x2, %edx
movq %rax, %rdi
callq 0xa640
movq 0x20(%rbx), %r15
movq (%r15), %rax
movq -0x18(%rax), %rcx
movq 0x8(%r15,%rcx), %r12
movl 0x18(%r15,%rcx), %ebp
movl %ebp, %edx
andl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
orl $0x4, %edx
movl %edx, 0x18(%r15,%rcx)
movq -0x18(%rax), %rax
movq $0x0, 0x8(%r15,%rax)
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0xa2e0
movq %r15, %rdi
callq 0xa910
leaq 0x56b45(%rip), %rsi     # 0x8ca18
movl $0x5, %edx
movq %rax, %rdi
callq 0xa640
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl %ebp, 0x18(%r15,%rcx)
movq -0x18(%rax), %rax
movq %r12, 0x8(%r15,%rax)
movq %rsp, %rdi
callq 0x2f5bc
movq 0x20(%rbx), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xa570
movsbl %al, %esi
movq %r14, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3f0
cmpb $0x1, 0x28(%rbx)
jne 0x35f59
movq 0x20(%rbx), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xa570
movsbl %al, %esi
movq %r14, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3f0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x35f70
movq (%rbx), %rsi
incq %rsi
callq 0xa5a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x2c2a7
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::byte2first(unsigned char)
size_t byte2first (uchar b)
{ 
  if (! b)
    return sizeof (uchar);
	const uint u = b;
	size_t i = 0;
	uint mask = 1;
	while (! contains (u, mask))
	{
		i++;
		mask <<= 1;
	}
	return i;
}

// Assembly:
testl %edi, %edi
je 0x35fa6
testb $0x1, %dil
jne 0x35fac
movzbl %dil, %ecx
movl $0x1, %edx
xorl %eax, %eax
notl %ecx
incq %rax
addl %edx, %edx
testl %ecx, %edx
jne 0x35f9c
retq
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::powInt(unsigned long, unsigned long)
size_t powInt (size_t a,
               size_t b)
{
	if (a)
		if (a == 1)
			return 1;
		else
			return powInt_ (a, b);
	else
		if (b)
			return 0;
		else
			throw runtime_error (FUNC "powInt: 0^0");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
testq %rdi, %rdi
je 0x35ff4
cmpq $0x1, %rdi
je 0x35ffb
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3611a
testq %rsi, %rsi
je 0x3600b
xorl %edi, %edi
movq %rdi, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x569f6(%rip), %rsi     # 0x8ca1e
leaq 0x56a17(%rip), %rdx     # 0x8ca46
movq %rsp, %rdi
callq 0x2fa1a
leaq 0x56a09(%rip), %rsi     # 0x8ca47
movq %rsp, %rdi
callq 0xaac0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x36069
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x36076
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x79f42(%rip), %rsi     # 0xaffe8
movq 0x79eb3(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x360cf
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x360e5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x3610a
jmp 0x36112
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3610a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x3610a
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::(anonymous namespace)::powInt_(unsigned long, unsigned long)
size_t powInt_ (size_t a,
                size_t b)
// Input: a: !0, != 1
{
	if (! b)
		return 1;
	if (b == 1)
		return a;
	const size_t half = b / 2;
	const size_t res = powInt_ (a, half);
	return res * res * (divisible (b, 2) ? 1 : a);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x36157
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1, %rsi
je 0x3615c
movq %r14, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0x3611a
testb $0x1, %r14b
movl $0x1, %ecx
cmovneq %rbx, %rcx
movq %rax, %rbx
imulq %rax, %rbx
imulq %rcx, %rbx
jmp 0x3615c
movl $0x1, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::to_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string to_url (const string &s)
{
  string url;
  for (const char c : s)
    if (   isLetter (c)
        || isDigit (c)
        || c == '_'
       )
      url += c;
    else
      url += "%" + uchar2hex ((uchar) c);
      
  return url;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x3700f
movq (%rsi), %r15
xorl %r12d, %r12d
leaq 0x57fcf(%rip), %r14     # 0x8eea1
movsbl (%r15,%r12), %ebp
movl %ebp, %edi
callq 0xa810
movl $0x1b, %edx
movq %r14, %rdi
movl %eax, %esi
callq 0xa610
testq %rax, %rax
je 0x36f09
movq %rbx, %rdi
movl %ebp, %esi
callq 0xa4d0
incq %r12
cmpq %r12, %r13
jne 0x36ed2
jmp 0x3700f
movl $0xb, %edx
leaq 0x57f81(%rip), %rdi     # 0x8ee96
movl %ebp, %esi
callq 0xa610
cmpb $0x5f, %bpl
je 0x36ef2
testq %rax, %rax
jne 0x36ef2
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq $0x2, 0x8(%rsp)
movb $0x0, 0x12(%rsp)
movzbl %bpl, %eax
shrl $0x4, %eax
leaq 0x558b4(%rip), %rcx     # 0x8c800
movb (%rax,%rcx), %al
movb %al, 0x10(%rsp)
andl $0xf, %ebp
movb (%rbp,%rcx), %al
movb %al, 0x11(%rsp)
movl $0x1, %r8d
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x55b05(%rip), %rcx     # 0x8ca77
callq 0xa620
leaq 0x30(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x36f9f
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x36fa5
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xa190
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x36feb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x36efc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x36efc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x37045
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x37045
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x37065
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x37065
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x40(%rsp), %rdi
je 0x3707f
movq 0x40(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::trimPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool trimPrefix (string &s,
                 const string &prefix)
{
  if (! isLeft (s, prefix))
    return false;
  s. erase (0, prefix. size ());
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa5d0
movq 0x8(%r15), %rdx
cmpq 0x8(%r14), %rdx
jne 0x37158
movq 0x8(%rsp), %r15
testq %rdx, %rdx
je 0x37161
movq (%r14), %rsi
movq %r15, %rdi
callq 0xa5c0
testl %eax, %eax
sete %bpl
jmp 0x37164
movq 0x8(%rsp), %r15
xorl %ebp, %ebp
jmp 0x37164
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r15
je 0x3717e
movq 0x18(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0xa5a0
testb %bpl, %bpl
je 0x37191
movq 0x8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa100
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::trimSuffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool trimSuffix (string &s,
                 const string &suffix)
{
  if (! isRight (s, suffix))
    return false;
  s. erase (s. size () - suffix. size ());
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x37087
testb %al, %al
je 0x371c9
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq 0x8(%r14), %rdx
jb 0x371d1
movq %rdx, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x57d1c(%rip), %rdi     # 0x8eef4
leaq 0x57d63(%rip), %rsi     # 0x8ef42
xorl %eax, %eax
callq 0xa890
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::trimSuffixNonAlphaNum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trimSuffixNonAlphaNum (string &s)
{
  for (;;)
  {
    trimTrailing (s);
    if (s. empty ())
      break;
    const size_t pos = s. size () - 1;
    if (   isAlpha (s [pos])
        || isDigit (s [pos])
       )
      break;
    s. erase (pos);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x37275
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x37266
leaq 0x57c98(%rip), %r14     # 0x8eea1
leaq 0x57c86(%rip), %r15     # 0x8ee96
movq (%rbx), %r13
movsbl -0x1(%r13,%r12), %ebp
movl %ebp, %edi
callq 0xa810
movl $0x1b, %edx
movq %r14, %rdi
movl %eax, %esi
callq 0xa610
testq %rax, %rax
jne 0x37266
movl $0xb, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0xa610
testq %rax, %rax
jne 0x37266
decq %r12
movq %r12, 0x8(%rbx)
movb $0x0, (%r13,%r12)
movq %rbx, %rdi
callq 0x37275
movq 0x8(%rbx), %r12
testq %r12, %r12
jne 0x37210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::trimTrailing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trimTrailing (string &s)
{
	size_t i = s. size ();
	while (i)
		if (isSpace (s [i - 1]))
			i--;
		else
			break;
  s. erase (i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r12
movq %r12, %r15
subq $0x1, %r12
jb 0x372af
movzbl -0x1(%r14,%r15), %edi
leal -0x1(%rdi), %eax
cmpb $0x1f, %al
ja 0x372a6
callq 0xa0a0
testl %eax, %eax
jne 0x37287
movq %r15, 0x8(%rbx)
addq %r15, %r14
jmp 0x372b7
movq $0x0, 0x8(%rbx)
movb $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::trimTailAt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool trimTailAt (string &s,
                 const string &tailStart)
{
  const size_t pos = s. find (tailStart);
  const bool trimmed = pos != string::npos;
  if (trimmed)
    s. erase (pos);
  return trimmed;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rax, %rsi
xorl %edx, %edx
callq 0xa9e0
cmpq $-0x1, %rax
je 0x372f6
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x372ff
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
cmpq $-0x1, %rax
setne %al
popq %rbx
retq
leaq 0x57bee(%rip), %rdi     # 0x8eef4
leaq 0x57c35(%rip), %rsi     # 0x8ef42
movq %rax, %rdx
xorl %eax, %eax
callq 0xa890
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::commaize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void commaize (string &s)
{
  trim (s);
  replace (s, '\t', ' ');
  replace (s, ',', ' ');
  replaceStr (s, "  ", " ");
  replace (s, ' ', ',');
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x37275
movq %rbx, %rdi
callq 0x384ed
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x37370
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x9, (%rcx,%rdx)
jne 0x37348
movb $0x20, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x3733e
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x37370
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x2c, (%rcx,%rdx)
jne 0x37368
movb $0x20, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x3735e
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x57479(%rip), %rsi     # 0x8e7f9
leaq 0x57474(%rip), %rdx     # 0x8e7fb
leaq 0x20(%rsp), %rdi
callq 0x2fa1a
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x57459(%rip), %rsi     # 0x8e7fa
leaq 0x57453(%rip), %rdx     # 0x8e7fb
movq %rsp, %rdi
callq 0x2fa1a
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x37474
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x373d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x373ed
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3740d
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x20, (%rcx,%rdx)
jne 0x37405
movb $0x2c, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x373fb
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x37435
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x37435
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x3744c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::trimTrailing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
void trimTrailing (string &s,
                   char c)
{
	size_t i = s. size ();
	while (i)
		if (s [i - 1] == c)
			i--;
		else
			break;
  s. erase (i);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq (%rax,%rcx), %rdx
incq %rdx
incq %rcx
cmpq $0x1, %rcx
je 0x3859e
leaq -0x1(%rdx), %r8
decq %rcx
cmpb %sil, -0x2(%rdx)
movq %r8, %rdx
je 0x3857f
movq %rcx, 0x8(%rdi)
movq %r8, %rax
jmp 0x385a6
movq $0x0, 0x8(%rdi)
movb $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::containsWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_t containsWord (const string& hay,
                     const string& needle)
{
  size_t pos = string::npos;
  for (;;)
  {
    pos = hay. find (needle, pos == string::npos ? 0 : pos + 1);
    if (pos == string::npos)
      break;
    const size_t pos1 = pos + needle. size ();
    if (   (pos  == 0            || ! isLetter (hay [pos - 1]))
        && (pos1 == hay. size () || ! isLetter (hay [pos1]))
       )
      break;
  }
  return pos;  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%rbx), %rcx
xorl %edx, %edx
callq 0xa9e0
movq %rax, %r12
movq $-0x1, %rax
cmpq $-0x1, %r12
je 0x386a6
leaq 0x568bd(%rip), %r13     # 0x8eea1
movq 0x8(%rbx), %r15
testq %r12, %r12
je 0x3862f
movq (%r14), %rax
movsbl -0x1(%rax,%r12), %ebp
movl %ebp, %edi
callq 0xa810
movl $0x1b, %edx
movq %r13, %rdi
movl %eax, %esi
callq 0xa610
testq %rax, %rax
jne 0x38679
movl $0xb, %edx
leaq 0x56879(%rip), %rdi     # 0x8ee96
movl %ebp, %esi
callq 0xa610
cmpb $0x5f, %bpl
je 0x38679
testq %rax, %rax
jne 0x38679
leaq (%r15,%r12), %rax
cmpq 0x8(%r14), %rax
je 0x386a3
movq (%r14), %rcx
movsbl (%rcx,%rax), %ebp
movl %ebp, %edi
callq 0xa810
movl $0x1b, %edx
movq %r13, %rdi
movl %eax, %esi
callq 0xa610
testq %rax, %rax
jne 0x38679
movl $0xb, %edx
leaq 0x5682f(%rip), %rdi     # 0x8ee96
movl %ebp, %esi
callq 0xa610
cmpb $0x5f, %bpl
je 0x38679
testq %rax, %rax
je 0x386a3
incq %r12
movq (%rbx), %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0xa9e0
movq %rax, %r12
cmpq $-0x1, %rax
jne 0x385e4
movq $-0x1, %rax
jmp 0x386a6
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::strQuote(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
string strQuote (const string &s,
                 char quote)
{ 
	string s1 (s);
	replaceStr (s1, "\\", "\\\\");
	const char slashQuote [] = {'\\', quote, '\0'};
	replaceStr (s1, string (1, quote), slashQuote);
	return quote + s1 + quote; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x2c212
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x54138(%rip), %rsi     # 0x8cbb5
leaq 0x54132(%rip), %rdx     # 0x8cbb6
leaq 0x8(%rsp), %rdi
callq 0x2fa1a
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x5410e(%rip), %rsi     # 0x8cbad
leaq 0x54109(%rip), %rdx     # 0x8cbaf
leaq 0x28(%rsp), %rdi
callq 0x2fa1a
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x37474
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x38adb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x38af2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movb $0x5c, 0x5(%rsp)
movb %bpl, 0x6(%rsp)
movb $0x0, 0x7(%rsp)
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movsbl %bpl, %ebp
movl $0x1, %esi
movl %ebp, %edx
callq 0xa670
leaq 0x28(%rsp), %r14
movq %r12, (%r14)
leaq 0x5(%rsp), %r15
movq %r15, %rdi
callq 0xa260
leaq (%rsp,%rax), %rdx
addq $0x5, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2fa1a
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x37474
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x38b6c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x38b83
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movl %ebp, %esi
callq 0x64633
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rsi
movl $0x1, %ecx
xorl %edx, %edx
movl %ebp, %r8d
callq 0xaa80
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x38bce
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x38bd4
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x38c02
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x38c1e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38c56
jmp 0x38c72
jmp 0x38c3a
jmp 0x38c56
jmp 0x38c72
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x38c59
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x38c59
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x38c75
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x38c75
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x38c91
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::to_c(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string to_c (const string &s)
{
  string r;
  for (const char c : s)
    if (c == '\n')
      r += "\\n";
    else
    {
      if (charInSet (c, "\"\'\\"))
        r += '\\';
      r += c;
    }   
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x38d7c
movq (%rsi), %r12
leaq 0x28(%rsp), %r14
xorl %r13d, %r13d
movq %rbx, 0x10(%rsp)
movb (%r12,%r13), %bpl
cmpb $0xa, %bpl
jne 0x38cfa
movq %rbx, %rdi
leaq 0x53ebd(%rip), %rsi     # 0x8cbb0
callq 0xaac0
jmp 0x38d70
movq %r14, 0x18(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
leaq 0x53ea5(%rip), %rsi     # 0x8cbb3
leaq 0x53ea1(%rip), %rdx     # 0x8cbb6
callq 0x2fa1a
movsbl %bpl, %esi
movq %rbx, %rdi
movl %esi, 0x4(%rsp)
xorl %edx, %edx
callq 0xa740
movq %rax, %rbx
movq 0x18(%rsp), %rdi
movq %r14, %rbp
cmpq %r14, %rdi
je 0x38d49
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpq $-0x1, %rbx
movq %rbp, %r14
movq 0x10(%rsp), %rbx
je 0x38d64
movq %rbx, %rdi
movl $0x5c, %esi
callq 0xa4d0
movq %rbx, %rdi
movl 0x4(%rsp), %esi
callq 0xa4d0
incq %r13
cmpq %r13, %r15
jne 0x38cdf
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38d90
movq %rax, %r14
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0x38db2
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::collapseSpace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void collapseSpace (string &s)
{
  string s1;
  do 
  {
    s1 = s;
    replaceStr (s, "  ", " ");
  }
  while (s1 != s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x58(%rsp), %rbp
leaq 0x38(%rsp), %r14
leaq 0x48(%rsp), %r13
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xa320
movq %rbp, 0x48(%rsp)
movq %r13, %rdi
leaq 0x559ea(%rip), %rsi     # 0x8e7f9
leaq 0x559e5(%rip), %rdx     # 0x8e7fb
callq 0x2fa1a
movq %r14, 0x28(%rsp)
movq %r15, %rdi
leaq 0x559d0(%rip), %rsi     # 0x8e7fa
leaq 0x559ca(%rip), %rdx     # 0x8e7fb
callq 0x2fa1a
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x37474
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x38e5b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x38e72
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x10(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x38df3
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x38e9e
movq (%rbx), %rsi
movq %r12, %rdi
callq 0xa5c0
testl %eax, %eax
jne 0x38df3
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x38eb8
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0xa5a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x38ee6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x38ee6
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x38f04
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x38f04
jmp 0x38f01
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x38f20
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::str2streamWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
string str2streamWord (const string &s,
                       size_t wordNum)
{
  istringstream iss (s);
  string word;
  FOR (size_t, i, wordNum + 1)
    if (iss. eof ())
    	return noString;
    else
      iss >> word;
  return word;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0xa980
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
cmpq $-0x1, %r14
je 0x39067
incq %r14
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x39081
movq %r15, %rdi
movq %r12, %rsi
callq 0xa720
decq %r14
jne 0x39029
movq (%rsp), %rcx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
cmpq %r13, %rcx
je 0x3906e
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x39076
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movups (%r13), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
jmp 0x390b7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x77a49(%rip), %rsi     # 0xb0ad8
movq 0x77a4a(%rip), %rdx     # 0xb0ae0
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c212
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x390b7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x76e9a(%rip), %rsi     # 0xaff58
leaq 0x20(%rsp), %rdi
callq 0xa7e0
leaq 0x98(%rsp), %rdi
callq 0xa1c0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x390eb
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x39104
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x76e4d(%rip), %rsi     # 0xaff58
leaq 0x20(%rsp), %rdi
callq 0xa7e0
leaq 0x98(%rsp), %rdi
callq 0xa1c0
movq %rbx, %rdi
callq 0xaa10