LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./common.hpp
// Function: Common_sp::Application::arg2uint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
uint arg2uint (const string &name) const
    { uint n = 0;
    	if (! str2<uint> (getArg (name), n))
    	  throw runtime_error ("Cannot convert " + strQuote (name) + " to non-negative number"); 
    	return n;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x4(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x59d34
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2f11b
movl %eax, %ebx
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x2d25b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bl, %bl
je 0x2d26e
movl 0x4(%rsp), %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38d2b
leaq 0x5ec28(%rip), %rsi     # 0x8bebc
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2c037
leaq 0x5ec3d(%rip), %rsi     # 0x8bee7
leaq 0x48(%rsp), %rdi
callq 0xaac0
movq %r15, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2d2d1
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2d2de
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%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 0x82cda(%rip), %rsi     # 0xaffe8
movq 0x82c4b(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d33f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2d33f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d362
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2d362
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d385
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2d385
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2d3b2
movq %rbx, %rdi
callq 0xa440
jmp 0x2d3b2
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d3b2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d81c
cmpq $0x1, 0x10(%rsi)
jne 0x2d7da
cmpq $0x0, 0x18(%rax)
je 0x2d8b9
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x2de16
leaq 0x5e750(%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 0x2d83b
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2d842
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5e715(%rip), %rsi     # 0x8bf3f
leaq 0x5e710(%rip), %rdx     # 0x8bf41
movq %rbx, %rdi
callq 0x2fdd8
jmp 0x2d8ae
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 0x3c5fc
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2d87c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d897
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2de16
leaq 0x20(%rsp), %rdi
callq 0x2fd92
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x5e645(%rip), %rsi     # 0x8bf12
movq %rax, %rdi
callq 0xa230
movq 0x8270c(%rip), %rsi     # 0xaffe8
movq 0x8267d(%rip), %rdx     # 0xaff60
movq %r14, %rdi
callq 0xa9b0
movq %rax, %rbx
movq %r14, %rdi
callq 0xa440
jmp 0x2d940
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2fd92
jmp 0x2d940
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2d925
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2d925
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d940
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e02a
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 0x2fdd8
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 0x2c652
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2cefd
leaq 0x5dedc(%rip), %rsi     # 0x8bf46
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2c037
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x81f56(%rip), %rsi     # 0xaffe8
movq 0x81ec7(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e0c7
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2e0c7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e0ea
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2e0ea
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e109
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2e109
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2e116
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ea3e
movq %rdi, %r14
leaq 0x820df(%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 0x2ea51
leaq 0x82093(%rip), %rsi     # 0xb0ad8
movq %rdx, %rdi
callq 0x3fd63
xorl %eax, %eax
jmp 0x2ea8c
leaq 0x1130b(%rip), %rsi     # 0x3fd63
leaq 0x82079(%rip), %rcx     # 0xb0ad8
movq %rsp, %r15
movq %r15, %rdi
callq 0x31b34
movq %r14, %rdi
movq %r15, %rsi
callq 0x3197e
cmpq $0x0, (%rsp)
jne 0x2eaa7
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 0x2eaa7
movq %rax, %rdi
callq 0xaa10
callq 0xa150
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8014c
cmpq $-0x1, %rax
je 0x2edfa
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 0x38d2b
leaq 0x5d3de(%rip), %rsi     # 0x8c1fe
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2c037
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32a1e
xorl %ebp, %ebp
leaq 0x7fc55(%rip), %rsi     # 0xaeaa0
movq 0x8112e(%rip), %rdx     # 0xaff80
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ee80
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2ee80
movq %rax, %r14
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eea3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2eea3
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2eeb0
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x381c2
testb %al, %al
jne 0x2efc8
movq 0x78(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x98(%rsp,%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
jne 0x2efc8
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x80fbb(%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 0x38(%rsp), %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38d2b
leaq 0x5cece(%rip), %rsi     # 0x8bebc
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x2c037
leaq 0x5ced8(%rip), %rsi     # 0x8bedc
leaq 0x58(%rsp), %rdi
callq 0xaac0
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2f02f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2f03c
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq 0x8(%rax), %rdx
leaq 0x18(%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 0x80f7c(%rip), %rsi     # 0xaffe8
movq 0x80eed(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f09d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2f09d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f0c0
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2f0c0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f0e3
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x2f0e3
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2f0f5
movq %rbx, %rdi
callq 0xa440
jmp 0x2f0f5
movq %rax, %r14
movq 0x80e5c(%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_O1/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 0x2ff2e
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x2feb1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x30032
addq $0x20, %r15
jmp 0x2fe9b
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x2fec2
movb $0x0, 0x18(%rbx)
movq (%r14), %rsi
movq %r14, %rdi
callq 0x3027e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ff2c
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x2ff23
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 0x3030f
movq %r14, %rdi
movq %r15, %rsi
callq 0x303f3
movb $0x1, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31862
je 0x31856
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x5a9ad(%rip), %rsi     # 0x8c1ab
leaq 0x5a9af(%rip), %rdx     # 0x8c1b4
leaq 0x8(%rsp), %rdi
callq 0x2fdd8
leaq -0x1(%rbx), %rdx
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x31354
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x31837
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 0x318c8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x5a916(%rip), %rsi     # 0x8c18c
movq %rax, %rdi
callq 0xa230
movq 0x7e763(%rip), %rsi     # 0xaffe8
movq 0x7e6d4(%rip), %rdx     # 0xaff60
movq %r14, %rdi
callq 0xa9b0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x318c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x318c0
movq %rax, %rbx
jmp 0x318c0
movq %rax, %rbx
movq %r14, %rdi
callq 0xa440
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator<(Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) const
bool operator< (const Vector<T> &other) const
      // Lexicographic comparison
      { const size_t n = std::min (P::size (), other. size ());
        for (size_t i = 0; i < n; i++)
      	{ if ((*this) [i] < other [i]) return true;
      		if (other [i] < (*this) [i]) return false;
        }
        return P::size () < other. size ();
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x5, %rax
movq 0x8(%rsi), %r13
subq (%rsi), %r13
sarq $0x5, %r13
cmpq %rax, %r13
cmovaeq %rax, %r13
testq %r13, %r13
setne %bpl
je 0x331d0
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e3d8
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e3d8
movq %r12, %rdi
movq %rax, %rsi
callq 0xa050
testl %eax, %eax
js 0x331d2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e3d8
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e3d8
movq %r12, %rdi
movq %rax, %rsi
callq 0xa050
testl %eax, %eax
js 0x331d6
incq %r15
cmpq %r13, %r15
setb %bpl
jne 0x33172
jmp 0x331d8
jmp 0x331d8
movb $0x1, %al
jmp 0x331d8
xorl %eax, %eax
testb $0x1, %bpl
jne 0x331f2
movq 0x8(%r14), %rax
subq (%r14), %rax
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
cmpq %rcx, %rax
setb %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33205
movq %rax, %rdi
callq 0x2c6e2
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x7c567(%rip)     # 0xb0ac1
jne 0x34563
xorl %edi, %edi
callq 0xa6c0
movl $0x1, %edi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x7afc4(%rip)     # 0xb0ad2
jne 0x35b2d
cmpq $0x1, 0x7aaa0(%rip)     # 0xb05b8
jne 0x35b2d
movq %rdi, %r14
cmpq $-0x1, 0x28(%rdi)
jne 0x35b3f
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 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x56e39(%rip), %rsi     # 0x8c995
leaq 0x56e56(%rip), %rdx     # 0x8c9b9
leaq 0x48(%rsp), %rdi
callq 0x2fdd8
leaq 0x56e46(%rip), %rsi     # 0x8c9ba
leaq 0x48(%rsp), %rdi
callq 0xaac0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x35ba1
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x35bae
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%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 0x2d75c
leaq 0x56dec(%rip), %rsi     # 0x8c9ca
leaq 0x68(%rsp), %rdi
callq 0xaac0
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x35c0a
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x35c17
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)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x7a3a1(%rip), %rsi     # 0xaffe8
movq 0x7a312(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x35c78
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35c78
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35c9b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35c9b
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x35cba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35cba
movq %rax, %r14
movb $0x1, %bpl
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x35cd9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35cd9
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x35ce6
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x7adcc(%rip)     # 0xb0ad2
jne 0x35d31
cmpq $0x1, 0x7a8a8(%rip)     # 0xb05b8
jne 0x35d31
movq %rdi, %r14
cmpq $-0x1, 0x28(%rdi)
je 0x35d43
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 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x56c7b(%rip), %rsi     # 0x8c9db
leaq 0x56c97(%rip), %rdx     # 0x8c9fe
leaq 0x48(%rsp), %rdi
callq 0x2fdd8
leaq 0x56c42(%rip), %rsi     # 0x8c9ba
leaq 0x48(%rsp), %rdi
callq 0xaac0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x35da5
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x35db2
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%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 0x2d75c
leaq 0x56c1d(%rip), %rsi     # 0x8c9ff
leaq 0x68(%rsp), %rdi
callq 0xaac0
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x35e0e
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x35e1b
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)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x7a19d(%rip), %rsi     # 0xaffe8
movq 0x7a10e(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x35e7c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35e7c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35e9f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35e9f
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x35ebe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35ebe
movq %rax, %r14
movb $0x1, %bpl
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x35edd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x35edd
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x35eea
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x7abd2(%rip)     # 0xb0ad2
jne 0x35fe5
cmpq $0x1, 0x7a6aa(%rip)     # 0xb05b8
jne 0x35fe5
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x56aef(%rip), %rsi     # 0x8ca10
movl $0x7, %edx
movq %rbx, %rdi
callq 0xa640
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa640
leaq 0x569c1(%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 0x56605(%rip), %xmm0    # 0x8c590
movq %rbx, %rdi
callq 0xa910
movq %rax, %r14
leaq 0x56a7b(%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_O1/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 0x361b9
callq 0xa6b0
testl %eax, %eax
jne 0x361b9
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 0x2f8a0
movq 0x20(%rbx), %r15
leaq 0x5695a(%rip), %rsi     # 0x8ca10
movl $0x7, %edx
movq %r15, %rdi
callq 0xa640
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0xa640
leaq 0x5682c(%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 0x568e5(%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 0x2f97a
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 0x361b9
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 0x361d0
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 0x2c6e2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36206
testb $0x1, %dil
jne 0x3620c
movzbl %dil, %ecx
movl $0x1, %edx
xorl %eax, %eax
notl %ecx
incq %rax
addl %edx, %edx
testl %ecx, %edx
jne 0x361fc
retq
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36254
cmpq $0x1, %rdi
je 0x3625b
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3636b
testq %rsi, %rsi
je 0x3626b
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 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x56796(%rip), %rsi     # 0x8ca1e
leaq 0x567b7(%rip), %rdx     # 0x8ca46
leaq 0x20(%rsp), %rdi
callq 0x2fdd8
leaq 0x567a7(%rip), %rsi     # 0x8ca47
leaq 0x20(%rsp), %rdi
callq 0xaac0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x362cd
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x362d9
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %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 0x79ce1(%rip), %rsi     # 0xaffe8
movq 0x79c52(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x36337
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x36337
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x36356
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x36356
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x36363
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x363a8
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1, %rsi
je 0x363ad
movq %r14, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0x3636b
testb $0x1, %r14b
movl $0x1, %ecx
cmovneq %rbx, %rcx
movq %rax, %rbx
imulq %rax, %rbx
imulq %rcx, %rbx
jmp 0x363ad
movl $0x1, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3728b
movq (%rsi), %r12
xorl %r15d, %r15d
leaq 0x57d88(%rip), %r14     # 0x8eeb7
movsbl (%r12,%r15), %ebp
movl %ebp, %edi
callq 0xa810
movl $0x1b, %edx
movq %r14, %rdi
movl %eax, %esi
callq 0xa610
testq %rax, %rax
je 0x37166
movq %rbx, %rdi
movl %ebp, %esi
callq 0xa4d0
incq %r15
cmpq %r15, %r13
jne 0x3712f
jmp 0x3728b
movl $0xb, %edx
leaq 0x57d3a(%rip), %rdi     # 0x8eeac
movl %ebp, %esi
callq 0xa610
cmpb $0x5f, %bpl
je 0x3714f
testq %rax, %rax
jne 0x3714f
movl $0xb, %edx
leaq 0x57d1c(%rip), %rdi     # 0x8eeac
movl %ebp, %esi
callq 0xa610
testq %rax, %rax
jne 0x3714f
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movw $0x2020, 0x10(%rsp)     # imm = 0x2020
movq $0x2, 0x8(%rsp)
movb $0x0, 0x12(%rsp)
movzbl %bpl, %eax
shrl $0x4, %eax
leaq 0x55638(%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 0x55889(%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 0x3721b
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x37221
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 0x37267
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x37159
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x37159
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 0x372c1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x372c1
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x372e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x372e1
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x40(%rsp), %rdi
je 0x372fb
movq 0x40(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa5d0
movq 0x8(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x373d2
testq %rdx, %rdx
je 0x373cf
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0xa5c0
testl %eax, %eax
sete %r15b
jmp 0x373d2
movb $0x1, %r15b
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x373ed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %r15b, %r15b
je 0x37400
movq 0x8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa100
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37303
testb %al, %al
je 0x3743a
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq 0x8(%r14), %rdx
jb 0x37442
movq %rdx, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x57ac1(%rip), %rdi     # 0x8ef0a
leaq 0x57b08(%rip), %rsi     # 0x8ef58
xorl %eax, %eax
callq 0xa890
// File: /workspace/github_cpp_makefile_star2_O1/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 0x374e6
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x374d7
leaq 0x57a3d(%rip), %r14     # 0x8eeb7
leaq 0x57a2b(%rip), %r15     # 0x8eeac
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 0x374d7
movl $0xb, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0xa610
testq %rax, %rax
jne 0x374d7
decq %r12
movq %r12, 0x8(%rbx)
movb $0x0, (%r13,%r12)
movq %rbx, %rdi
callq 0x374e6
movq 0x8(%rbx), %r12
testq %r12, %r12
jne 0x37481
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq (%rdi), %r12
movq 0x8(%rdi), %rbx
movq %rbx, %r13
movq %r13, %r14
subq $0x1, %r13
jb 0x3751d
movzbl -0x1(%r12,%r14), %edi
leal -0x1(%rdi), %eax
cmpb $0x1f, %al
ja 0x37520
callq 0xa0a0
testl %eax, %eax
jne 0x374fc
jmp 0x37520
xorl %r14d, %r14d
cmpq %r14, %rbx
jb 0x3753b
movq %r14, 0x8(%r15)
movq (%r15), %rax
movb $0x0, (%rax,%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x579c8(%rip), %rdi     # 0x8ef0a
leaq 0x57a0f(%rip), %rsi     # 0x8ef58
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xa890
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37585
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x3758e
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
cmpq $-0x1, %rax
setne %al
popq %rbx
retq
leaq 0x57975(%rip), %rdi     # 0x8ef0a
leaq 0x579bc(%rip), %rsi     # 0x8ef58
movq %rax, %rdx
xorl %eax, %eax
callq 0xa890
// File: /workspace/github_cpp_makefile_star2_O1/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 0x374e6
movq %rbx, %rdi
callq 0x387de
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x375df
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x9, (%rcx,%rdx)
jne 0x375d7
movb $0x20, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x375cd
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x375ff
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x2c, (%rcx,%rdx)
jne 0x375f7
movb $0x20, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x375ed
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x57200(%rip), %rsi     # 0x8e80f
leaq 0x571fb(%rip), %rdx     # 0x8e811
leaq 0x20(%rsp), %rdi
callq 0x2fdd8
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x571e0(%rip), %rsi     # 0x8e810
leaq 0x571da(%rip), %rdx     # 0x8e811
movq %rsp, %rdi
callq 0x2fdd8
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x37703
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x37665
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x3767c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3769c
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x20, (%rcx,%rdx)
jne 0x37694
movb $0x2c, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x3768a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x376c4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x376c4
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x376db
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %r8
cmpq $0x1, %r8
je 0x38881
leaq -0x1(%r8), %rdx
cmpb %sil, -0x2(%rax,%r8)
movq %rdx, %r8
je 0x3886b
jmp 0x38883
xorl %edx, %edx
cmpq %rdx, %rcx
jb 0x38895
movq %rdx, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax,%rdx)
popq %rax
retq
leaq 0x5666e(%rip), %rdi     # 0x8ef0a
leaq 0x566b5(%rip), %rsi     # 0x8ef58
xorl %eax, %eax
callq 0xa890
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
cmpq $-0x1, %rax
je 0x38994
leaq 0x565da(%rip), %r12     # 0x8eeb7
movq 0x8(%rbx), %r13
addq %r15, %r13
testq %r15, %r15
je 0x3892b
movq (%r14), %rax
movsbl -0x1(%rax,%r15), %ebp
movl %ebp, %edi
callq 0xa810
movl $0x1b, %edx
movq %r12, %rdi
movl %eax, %esi
callq 0xa610
testq %rax, %rax
jne 0x38972
movl $0xb, %edx
leaq 0x56593(%rip), %rdi     # 0x8eeac
movl %ebp, %esi
callq 0xa610
cmpb $0x5f, %bpl
je 0x38972
testq %rax, %rax
jne 0x38972
cmpq 0x8(%r14), %r13
je 0x38994
movq (%r14), %rax
movsbl (%rax,%r13), %ebp
movl %ebp, %edi
callq 0xa810
movl $0x1b, %edx
movq %r12, %rdi
movl %eax, %esi
callq 0xa610
testq %rax, %rax
jne 0x38972
movl $0xb, %edx
leaq 0x5654c(%rip), %rdi     # 0x8eeac
movl %ebp, %esi
callq 0xa610
cmpb $0x5f, %bpl
je 0x38972
testq %rax, %rax
je 0x38994
incq %r15
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0xa9e0
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x388dd
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c652
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x53e47(%rip), %rsi     # 0x8cbb5
leaq 0x53e41(%rip), %rdx     # 0x8cbb6
leaq 0x8(%rsp), %rdi
callq 0x2fdd8
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x53e1d(%rip), %rsi     # 0x8cbad
leaq 0x53e18(%rip), %rdx     # 0x8cbaf
leaq 0x28(%rsp), %rdi
callq 0x2fdd8
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x37703
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x38dcc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x38de3
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 0x2fdd8
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x37703
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x38e5d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x38e74
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movl %ebp, %esi
callq 0x64a9d
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 0x38ebf
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x38ec5
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 0x38ef3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x38f0f
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 0x38f47
jmp 0x38f63
jmp 0x38f2b
jmp 0x38f47
jmp 0x38f63
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x38f4a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x38f4a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x38f66
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x38f66
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x38f82
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3906d
movq (%rsi), %r12
leaq 0x28(%rsp), %r14
xorl %r13d, %r13d
movq %rbx, 0x10(%rsp)
movb (%r12,%r13), %bpl
cmpb $0xa, %bpl
jne 0x38feb
movq %rbx, %rdi
leaq 0x53bcc(%rip), %rsi     # 0x8cbb0
callq 0xaac0
jmp 0x39061
movq %r14, 0x18(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
leaq 0x53bb4(%rip), %rsi     # 0x8cbb3
leaq 0x53bb0(%rip), %rdx     # 0x8cbb6
callq 0x2fdd8
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 0x3903a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpq $-0x1, %rbx
movq %rbp, %r14
movq 0x10(%rsp), %rbx
je 0x39055
movq %rbx, %rdi
movl $0x5c, %esi
callq 0xa4d0
movq %rbx, %rdi
movl 0x4(%rsp), %esi
callq 0xa4d0
incq %r13
cmpq %r13, %r15
jne 0x38fd0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39081
movq %rax, %r14
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0x390a3
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10