LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::concatTextDir(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&)
void concatTextDir (const string &inDirName,
                    const string &outFName)
{
  RawDirItemGenerator dig (0, inDirName, false);
  OFStream outF (outFName);
  string item;
  while (dig. next (item))
    copyText (inDirName + "/" + item, 0, outF);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp            # imm = 0x2E8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x320be
leaq 0xe8(%rsp), %rdi
movq %r14, %rsi
callq 0x1d958
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x68(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0xe8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2603a
testb %al, %al
je 0x25fb6
movq %r13, %rdi
movq %rbx, %rsi
leaq 0x36357(%rip), %rdx     # 0x5c2db
callq 0x1c88d
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1cbaf
movq %rbp, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x25770
movq %rbp, %rdi
callq 0xbb68
movq %r13, %rdi
callq 0xbb68
jmp 0x25f68
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0xe8(%rsp), %rdi
callq 0x1da04
leaq 0x68(%rsp), %rdi
callq 0x321a0
addq $0x2e8, %rsp            # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x26028
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x26000
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x26011
jmp 0x2600e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0xe8(%rsp), %rdi
callq 0x1da04
leaq 0x68(%rsp), %rdi
callq 0x321a0
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::readLine(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void readLine (istream &is,
               string &s)
{
  s. clear ();
  for (;;)
  {	
    char c;
    if (! getChar (is, c))
      break;
	  if (c == '\n')  // UNIX
	  	break;
	  s += c;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
andq $0x0, 0x8(%rsi)
movq %rdi, %r14
movq (%rsi), %rax
movb $0x0, (%rax)
leaq 0xf(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x276f1
testb %al, %al
je 0x27b09
movb 0xf(%rsp), %al
cmpb $0xa, %al
je 0x27b09
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb4e0
jmp 0x27ae5
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Rand::run()
void Rand::run ()
{
	qc ();
  
  const long ia = 16807;
  const long iq = 127773;
  const long ir = 2836;

  const long k = seed / iq;
  seed = ia * (seed - k * iq) - ir * k;
  if (seed < 0)
  	seed += max_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x27e12
movq (%rbx), %rcx
movl $0x1f31d, %esi          # imm = 0x1F31D
movq %rcx, %rax
cqto
idivq %rsi
imulq $-0x1f31d, %rax, %rdx   # imm = 0xFFFE0CE3
addq %rcx, %rdx
imulq $0x41a7, %rdx, %rcx     # imm = 0x41A7
imulq $-0xb14, %rax, %rax     # imm = 0xF4EC
leaq (%rcx,%rax), %rdx
addq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
addq %rax, %rcx
cmovnsq %rcx, %rdx
movq %rdx, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Rand::qc() const
void Rand::qc () const
{
  if (! qc_on)
    return;
  QC_ASSERT (seed > 0);
  QC_ASSERT (seed < max_);
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
cmpb $0x1, 0x5ccbf(%rip)     # 0x84ae0
jne 0x27e42
movq %rdi, %rbx
callq 0xb060
andl $0x0, (%rax)
movq (%rbx), %rax
testq %rax, %rax
jle 0x27e4b
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jae 0x27f1f
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xb6c0
testl %eax, %eax
jne 0x27ff3
leaq 0x33ae2(%rip), %rsi     # 0x5b941
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x650, %esi            # imm = 0x650
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x31d48(%rip), %rdx     # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0x3424f(%rip), %rsi     # 0x5c106
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x33a71(%rip), %rdx     # 0x5b93e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b92d
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1ca3c
leaq 0x3422a(%rip), %rdx     # 0x5c127
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1b92d
leaq 0xf0(%rsp), %rdi
callq 0x224fc
callq 0xb6c0
testl %eax, %eax
jne 0x27ff3
leaq 0x33a0e(%rip), %rsi     # 0x5b941
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x651, %esi            # imm = 0x651
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x31c74(%rip), %rdx     # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0x3417b(%rip), %rsi     # 0x5c106
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x3399d(%rip), %rdx     # 0x5b93e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b92d
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1ca3c
leaq 0x3415f(%rip), %rdx     # 0x5c130
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1b92d
leaq 0xf0(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
jmp 0x27fff
jmp 0x28011
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xbb68
jmp 0x28014
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x28028
jmp 0x28025
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x28039
jmp 0x28036
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x2804a
jmp 0x28047
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x2805e
jmp 0x2805b
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x28072
jmp 0x2806f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x28083
jmp 0x28080
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
jmp 0x28094
jmp 0x28091
movq %rax, %rbx
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::StringVector::toString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string StringVector::toString (const string& sep) const
{ 
//ASSERT (! sep. empty ());
  
  string res;
  for (const string& s : *this)
  { 
    if (! res. empty ())
      res += sep;
    res += s;
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x2855b
cmpq $0x0, 0x8(%rbx)
je 0x2854a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbb00
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbb00
addq $0x20, %r15
jmp 0x28533
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xbb68
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Threads::Threads(unsigned long, bool)
Threads::Threads (size_t threadsToStart_arg, 
                  bool quiet_arg)
{ 
  if (! isMainThread ())
	  throw logic_error ("Threads are started not from the main thread");
  if (! empty ())
	  throw logic_error ("Previous threads have not finished");

	threadsToStart = threadsToStart_arg;
	if (threadsToStart >= threads_max)
		throw logic_error ("Too many threads to start");
		
  quiet = quiet_arg;
		
	threads. reserve (threadsToStart);
	
	if (! quiet && verbose (1) && threadsToStart)
	{
    const OColor c (cerr, Color::green, false, true);  // Cf. Progress::report() 
    cerr << "# Threads started: " << threadsToStart + 1/*main thread*/ << endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3c62c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
callq 0x218c3
testb %al, %al
je 0x2893e
cmpq $0x0, 0x5c289(%rip)     # 0x84b20
jne 0x2895a
movq %r14, 0x5c27c(%rip)     # 0x84b20
cmpq %r14, 0x5bd2d(%rip)     # 0x845d8
jbe 0x28976
movb %bpl, 0x5c270(%rip)     # 0x84b28
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c67e
cmpb $0x0, 0x5c25e(%rip)     # 0x84b28
jne 0x28933
pushq $0x1
popq %rdi
callq 0x280a3
testb %al, %al
je 0x28933
cmpq $0x0, 0x5c240(%rip)     # 0x84b20
je 0x28933
movq 0x5b6f7(%rip), %rsi     # 0x83fe0
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
pushq $0x1
popq %r8
xorl %ecx, %ecx
callq 0x1e0c2
movq 0x5b6dd(%rip), %rdi     # 0x83fe0
leaq 0x33929(%rip), %rsi     # 0x5c233
callq 0xb590
movq 0x5c20a(%rip), %rsi     # 0x84b20
incq %rsi
movq %rax, %rdi
callq 0xb410
movq %rax, %rdi
callq 0xb2f0
leaq 0x8(%rsp), %rdi
callq 0x1e15c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
leaq 0x33879(%rip), %rsi     # 0x5c1c9
movq %rax, %rdi
callq 0xb800
jmp 0x28990
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
leaq 0x3388a(%rip), %rsi     # 0x5c1f6
movq %rax, %rdi
callq 0xb800
jmp 0x28990
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
leaq 0x33891(%rip), %rsi     # 0x5c219
movq %rax, %rdi
callq 0xb800
movq 0x5b629(%rip), %rsi     # 0x83fc0
movq 0x5b5da(%rip), %rdx     # 0x83f78
movq %r14, %rdi
callq 0xb9d0
jmp 0x289c8
jmp 0x289ac
jmp 0x289ac
movq %rax, %r15
movq %r14, %rdi
callq 0xb470
jmp 0x289cb
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x1e15c
jmp 0x289cb
movq %rax, %r15
movq %rbx, %rdi
callq 0x3c710
movb $0x0, 0x5c1c7(%rip)     # 0x84ba1
movq %r15, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Threads::~Threads()
Threads::~Threads ()
{ 
  {
    Progress prog (threads. size () + 1, ! quiet);
    const string step ("consecutive threads finished");
    prog (step);  // Main thread
    for (auto& t : threads) 
    { 
      t. join ();
      prog (step);
  	}
  }
	  
	threads. clear ();
	threadsToStart = 0;
	quiet = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x3, %rsi
incq %rsi
movzbl 0x5c120(%rip), %edx     # 0x84b28
xorq $0x1, %rdx
leaq 0x28(%rsp), %rdi
callq 0x2a288
leaq 0x3382a(%rip), %rsi     # 0x5c247
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x28ac0
movq (%rbx), %r14
movq 0x8(%rbx), %r13
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq %r13, %r14
je 0x28a6a
movq %r14, %rdi
callq 0xb9c0
movq %r15, %rdi
movq %r12, %rsi
callq 0x28ac0
addq $0x8, %r14
jmp 0x28a4c
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0x28(%rsp), %rdi
callq 0x2a430
movq %rbx, %rdi
callq 0x3c732
andq $0x0, 0x5c092(%rip)     # 0x84b20
xorl %ebp, %ebp
movb %bpl, 0x5c091(%rip)     # 0x84b28
movq %rbx, %rdi
callq 0x3c710
movb %bpl, 0x5c0fb(%rip)     # 0x84ba1
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28ab7
movq %rax, %rdi
callq 0x1bdcd
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Progress::operator() (const string& step_arg)
{ 
	n++;
	step = step_arg;
	if (   active 
		  && n % displayPeriod == 0
		 )
	{ 
		report ();
	  return true;
	}
	return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
incq 0x18(%rdi)
addq $0x20, %rdi
callq 0xb350
cmpb $0x1, 0x8(%rbx)
jne 0x28af4
movq 0x18(%rbx), %rax
xorl %ecx, %ecx
xorl %edx, %edx
divq 0x10(%rbx)
testq %rdx, %rdx
jne 0x28af6
movq %rbx, %rdi
callq 0x2a302
movb $0x1, %cl
jmp 0x28af6
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Xml::BinFile::printRaw(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Xml::BinFile::printRaw (const string &s)
{
	QC_ASSERT (! contains (s, '\0'));
	if (! isText)
		os << '\0' << '\0';  // Tags closing
	os << s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb060
andl $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c948
testb %al, %al
jne 0x29087
cmpb $0x0, 0x8(%r14)
jne 0x2906e
leaq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0xb680
movq %rax, %rdi
xorl %esi, %esi
callq 0xb680
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
jmp 0xb510
callq 0xb6c0
testl %eax, %eax
jne 0x2915b
leaq 0x328a6(%rip), %rsi     # 0x5b941
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x48(%rsp), %rdi
movl $0x742, %esi            # imm = 0x742
callq 0x1caa3
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1ca3c
leaq 0x30b0c(%rip), %rdx     # 0x59be3
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1b92d
leaq 0x331ed(%rip), %rsi     # 0x5c2e0
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1b7b6
leaq 0x32835(%rip), %rdx     # 0x5b93e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b92d
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1ca3c
leaq 0x331e6(%rip), %rdx     # 0x5c31f
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1b92d
leaq 0xe8(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb68
jmp 0x29178
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb68
jmp 0x2918a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x29199
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x291a8
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb68
jmp 0x291ba
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb68
jmp 0x291cc
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x291db
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Xml::Tag::Tag(Common_sp::Xml::File&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
Xml::Tag::Tag (Xml::File &f_arg,
               const string &name_arg,
               bool active_arg)
: f (f_arg)
, name (name_arg)
, active (active_arg)
{ 
	if (name. empty ())
		throw runtime_error (FUNC "Empty XML tag name");
  if (f. isText)
  	throw runtime_error (FUNC "Cannot put tag " + strQuote (name) + " after a text");
  if (active)
  	f. tagStart (name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %ebp
movq %rdi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xb7b0
movb %bpl, 0x28(%r14)
cmpq $0x0, 0x10(%r14)
je 0x2974c
movq (%r14), %rdi
cmpb $0x1, 0x8(%rdi)
je 0x297b0
testb %bpl, %bpl
je 0x2973e
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
leaq 0x32c6e(%rip), %rsi     # 0x5c3cc
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x1b7b6
leaq 0x32c94(%rip), %rdx     # 0x5c408
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b92d
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x5a84c(%rip), %rsi     # 0x83fe8
movq 0x5a7bd(%rip), %rdx     # 0x83f60
movq %r14, %rdi
callq 0xb9d0
jmp 0x2984f
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
leaq 0x32c0a(%rip), %rsi     # 0x5c3cc
leaq 0x88(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x32c42(%rip), %rdx     # 0x5c41d
leaq 0x48(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1b92d
leaq 0x68(%rsp), %rdi
pushq $0x22
popq %rdx
movq %rbx, %rsi
callq 0x243b1
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x1ca3c
leaq 0x32c17(%rip), %rdx     # 0x5c42f
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b92d
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x5a7a8(%rip), %rsi     # 0x83fe8
movq 0x5a719(%rip), %rdx     # 0x83f60
movq %r14, %rdi
callq 0xb9d0
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x29864
movq %rax, %r15
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x29876
movq %rax, %r15
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0xbb68
jmp 0x29888
movq %rax, %r15
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x2989a
movq %rax, %r15
movb $0x1, %bpl
leaq 0x88(%rsp), %rdi
jmp 0x298be
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x298b9
movq %rax, %r15
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x298d4
jmp 0x298dc
movq %rax, %r15
jmp 0x298dc
jmp 0x298d1
movq %rax, %r15
movq %r14, %rdi
callq 0xb470
movq %rbx, %rdi
callq 0xbb68
movq %r15, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Named::qc() const
void Named::qc () const
{
  if (! qc_on)
    return;
  Root::qc ();
    
  if (! goodName (name))
    throw runtime_error (FUNC "Bad name: " + strQuote (name));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
cmpb $0x1, 0x5b156(%rip)     # 0x84ae0
jne 0x2999f
movq %rdi, %r14
addq $0x8, %r14
movq %r14, %rdi
callq 0x23bcf
testb %al, %al
je 0x299ab
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x32a80(%rip), %rsi     # 0x5c43d
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x32a94(%rip), %rdx     # 0x5c467
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1b92d
leaq 0x10(%rsp), %rdi
pushq $0x22
popq %rdx
movq %r14, %rsi
callq 0x243b1
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1ca3c
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x5a5c9(%rip), %rsi     # 0x83fe8
movq 0x5a53a(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0xbb68
jmp 0x29a43
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x29a55
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x29a67
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x29a7b
jmp 0x29a83
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
movq %r14, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::StringVector::StringVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, bool)
StringVector::StringVector (const string &s,
                            char sep,
                            bool trimP)
{
	string s1 (s);
	while (! s1. empty ())
	  *this << std::move (findSplit (s1, sep));
	if (! s. empty () && s. back () == sep)
	  *this << noString;
	  
	if (trimP)
	  for (string& member : *this)
	    trim (member);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x4(%rsp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rdi)
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %rdi
callq 0xb7b0
movsbl %r14b, %r12d
leaq 0x28(%rsp), %r13
leaq 0x8(%rsp), %rbp
cmpq $0x0, 0x10(%rsp)
je 0x29d22
movq %r13, %rdi
movq %rbp, %rsi
movl %r12d, %edx
callq 0x248b1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1d14c
movq %r13, %rdi
callq 0xbb68
jmp 0x29cf7
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x29d44
movq (%r15), %rcx
cmpb %r14b, -0x1(%rcx,%rax)
jne 0x29d44
leaq 0x5adbc(%rip), %rsi     # 0x84af8
movq %rbx, %rdi
callq 0x1d1d0
cmpb $0x0, 0x4(%rsp)
je 0x29d65
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x29d65
movq %r14, %rdi
callq 0x3c32f
addq $0x20, %r14
jmp 0x29d52
leaq 0x8(%rsp), %rdi
callq 0xbb68
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29d87
movq %rax, %r14
jmp 0x29da3
jmp 0x29d87
movq %rax, %r14
jmp 0x29d99
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0x20bee
movq %r14, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::StringVector::same(Common_sp::StringVector const&, Common_sp::Vector<unsigned long> const&) const
bool StringVector::same (const StringVector &vec,
                         const Vector<size_t> &indexes) const
{
  ASSERT (size () == vec. size ());

  for (const size_t i : indexes)
    if ((*this) [i] != vec [i])
      return false;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb060
andl $0x0, (%rax)
movq 0x8(%r14), %rax
subq (%r14), %rax
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
cmpq %rcx, %rax
jne 0x29e40
movq (%r15), %rcx
movq 0x8(%r15), %r13
movq %rcx, %rbp
cmpq %r13, %rcx
je 0x29e28
movq (%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d398
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1d398
movq %r12, %rdi
movq %rax, %rsi
callq 0x1d401
leaq 0x8(%rbp), %rcx
testb %al, %al
je 0x29df0
cmpq %r13, %rbp
sete %al
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb6c0
testl %eax, %eax
jne 0x29f14
leaq 0x31aed(%rip), %rsi     # 0x5b941
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x48(%rsp), %rdi
movl $0x7f8, %esi            # imm = 0x7F8
callq 0x1caa3
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1ca3c
leaq 0x2fd53(%rip), %rdx     # 0x59be3
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1b92d
leaq 0x325d6(%rip), %rsi     # 0x5c482
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1b7b6
leaq 0x31a7c(%rip), %rdx     # 0x5b93e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b92d
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1ca3c
leaq 0x325e7(%rip), %rdx     # 0x5c4d9
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1b92d
leaq 0xe8(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb68
jmp 0x29f31
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb68
jmp 0x29f43
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x29f52
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x29f61
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb68
jmp 0x29f73
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb68
jmp 0x29f85
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x29f94
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::DisjointCluster::merge(Common_sp::DisjointCluster&)
void DisjointCluster::merge (DisjointCluster &other)
// Trying to keep rank's small
{ 
  if (this == & other)
    return;
  DisjointCluster* root1 =        getDisjointCluster ();
  DisjointCluster* root2 = other. getDisjointCluster ();
	if (root1->rankDC > root2->rankDC)
		root2->parentDC = root1;
	else
	{
		root1->parentDC = root2;
		if (root1->rankDC == root2->rankDC)
			root2->rankDC ++;
	}
}

// Assembly:
cmpq %rsi, %rdi
je 0x2a0e8
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x2a0ea
movq %rax, %rbx
movq %r14, %rdi
callq 0x2a0ea
movq 0x8(%rbx), %rcx
cmpq 0x8(%rax), %rcx
jbe 0x2a0d5
movq %rbx, (%rax)
jmp 0x2a0e1
movq %rax, (%rbx)
jne 0x2a0e1
incq %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::DisjointCluster::getDisjointCluster()
DisjointCluster* DisjointCluster::getDisjointCluster ()
{ 
  ASSERT (parentDC);
	if (this == parentDC)
	  return this;
	parentDC = parentDC->getDisjointCluster ();
	return parentDC;
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
callq 0xb060
andl $0x0, (%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2a121
cmpq %rbx, %rdi
je 0x2a115
callq 0x2a0ea
movq %rax, (%rbx)
movq %rax, %rbx
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xb6c0
testl %eax, %eax
jne 0x2a1f5
leaq 0x3180c(%rip), %rsi     # 0x5b941
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x831, %esi            # imm = 0x831
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x2fa72(%rip), %rdx     # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0x32369(%rip), %rsi     # 0x5c4f6
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x3179b(%rip), %rdx     # 0x5b93e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b92d
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1ca3c
leaq 0x32365(%rip), %rdx     # 0x5c538
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1b92d
leaq 0xf0(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xbb68
jmp 0x2a212
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x2a224
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x2a233
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x2a242
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x2a254
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x2a266
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x2a275
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::Progress(unsigned long, unsigned long)
Progress::Progress (size_t n_max_arg,
	                  size_t displayPeriod_arg)
: n_max (n_max_arg)
, active (enabled () && displayPeriod_arg && (! n_max_arg || displayPeriod_arg <= n_max_arg))
, displayPeriod (displayPeriod_arg)
{ 
	if (active) 
	  beingUsed++; 
	if (active)
	  report ();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
callq 0x3c7c0
testq %r14, %r14
setne %cl
andb %al, %cl
testq %r15, %r15
sete %al
cmpq %r15, %r14
setbe %dl
orb %al, %dl
andq $0x0, 0x18(%rbx)
leaq 0x30(%rbx), %rax
andq $0x0, 0x28(%rbx)
andb %cl, %dl
movb %dl, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rax, 0x20(%rbx)
movb $0x0, 0x30(%rbx)
je 0x2a2e8
leaq 0x20(%rbx), %r14
incq 0x5a858(%rip)           # 0x84b38
movq %rbx, %rdi
callq 0x2a302
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::report() const
void Progress::report () const
{ 
  if (! n)
    return;
  cerr << '\r';
#ifndef _MSC_VER
  cerr << "\033[2K";
  const OColor c (cerr, Color::green, false, true);  // PAR
#endif
  cerr << n; 
	if (n_max)
		cerr << " / " << n_max;
	if (! step. empty ())
		cerr << ' ' << step;
	cerr << ' ';
	if (! Threads::empty () && ! contains (step, "thread"))
	  cerr << "(main thread) ";
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpq $0x0, 0x18(%rdi)
je 0x2a40f
movq %rdi, %rbx
movq 0x59cc1(%rip), %r14     # 0x83fe0
pushq $0xd
popq %rsi
movq %r14, %rdi
callq 0xb680
leaq 0x32210(%rip), %rsi     # 0x5c541
movq %r14, %rdi
callq 0xb590
leaq 0x10(%rsp), %rdi
pushq $0x20
popq %rdx
pushq $0x1
popq %r8
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1e0c2
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xb410
cmpq $0x0, (%rbx)
je 0x2a37f
movq 0x59c78(%rip), %rdi     # 0x83fe0
leaq 0x321d7(%rip), %rsi     # 0x5c546
callq 0xb590
movq (%rbx), %rsi
movq %rax, %rdi
callq 0xb410
leaq 0x20(%rbx), %r14
cmpq $0x0, 0x28(%rbx)
je 0x2a3a4
movq 0x59c4f(%rip), %rdi     # 0x83fe0
pushq $0x20
popq %rsi
callq 0xb680
movq %rax, %rdi
movq %r14, %rsi
callq 0xb510
movq 0x59c35(%rip), %rdi     # 0x83fe0
pushq $0x20
popq %rsi
callq 0xb680
cmpq $0x0, 0x5a765(%rip)     # 0x84b20
je 0x2a405
leaq 0x31e2b(%rip), %rsi     # 0x5c1ef
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x20(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d40b
movl %eax, %ebp
movq %rbx, %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x2a405
movq 0x59be7(%rip), %rdi     # 0x83fe0
leaq 0x3214a(%rip), %rsi     # 0x5c54a
callq 0xb590
leaq 0x10(%rsp), %rdi
callq 0x1e15c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2a41a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1e15c
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Progress::~Progress()
Progress::~Progress () 
{ 
	if (! active)
		return;

	report ();
  if (n)
    cerr << endl;
  beingUsed--;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x2a45c
movq %rbx, %rdi
callq 0x2a302
cmpq $0x0, 0x18(%rbx)
je 0x2a455
movq 0x59b90(%rip), %rdi     # 0x83fe0
callq 0xb2f0
decq 0x5a6dc(%rip)           # 0x84b38
addq $0x20, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0xbb68
movq %rax, %rdi
callq 0x1bdcd
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::TextPos::str[abi:cxx11]() const
string TextPos::str () const
{ 
  if (lineNum == -1)
    return noString;
  return "line " + to_string (lineNum + 1) + ", " +
	          (eol () 
	             ? "end of line" 
	             : last ()
	                 ?	"last position"
	                 : "pos. " + to_string (charNum + 1)
	          ) + 
	          ": ";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
cmpl $-0x1, %esi
je 0x2a4f3
incl %esi
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0x1caa3
leaq 0x34a48(%rip), %rsi     # 0x5eeed
leaq 0x48(%rsp), %rdi
movq %r15, %rdx
callq 0x1b94c
leaq 0x2ed65(%rip), %rdx     # 0x5921e
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1b92d
movl 0x4(%r14), %r14d
cmpl $-0x1, %r14d
je 0x2a507
cmpl $-0x2, %r14d
jne 0x2a524
leaq 0x32086(%rip), %rsi     # 0x5c565
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1b7b6
movb $0x1, %bpl
jmp 0x2a51f
leaq 0x5a5fe(%rip), %rsi     # 0x84af8
movq %rbx, %rdi
callq 0xb7b0
jmp 0x2a5c9
leaq 0x3204b(%rip), %rsi     # 0x5c559
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1b7b6
xorl %ebp, %ebp
xorl %r15d, %r15d
jmp 0x2a54d
leal 0x1(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x1d918
leaq 0x3203a(%rip), %rsi     # 0x5c573
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1b94c
movb $0x1, %r15b
xorl %ebp, %ebp
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1ca3c
leaq 0x313a5(%rip), %rdx     # 0x5b910
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b92d
leaq 0x88(%rsp), %rdi
callq 0xbb68
leaq 0x28(%rsp), %rdi
callq 0xbb68
testb %r15b, %r15b
je 0x2a5a1
leaq 0x8(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
cmpl $-0x1, %r14d
leaq 0x68(%rsp), %rdi
callq 0xbb68
leaq 0x48(%rsp), %rdi
callq 0xbb68
leaq 0xa8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
xorl %ebp, %ebp
jmp 0x2a60e
jmp 0x2a5e5
jmp 0x2a5e5
movq %rax, %rbx
jmp 0x2a61f
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb68
jmp 0x2a5ff
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
testb %r15b, %r15b
je 0x2a618
leaq 0x8(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
cmpl $-0x1, %r14d
leaq 0x68(%rsp), %rdi
callq 0xbb68
jmp 0x2a62e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
leaq 0xa8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
movq %rax, %rbx
jmp 0x2a638
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::TextPos::inc(bool)
void TextPos::inc (bool eol_arg)
{ 
 	if (eol ())
 		lineNum++;
  if (eol_arg)
  	charNum = eol_pos;
  else
  	charNum++;
  ASSERT (eol_arg == eol ());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl $-0x1, %eax
jne 0x2a66c
incl (%r14)
incl %eax
testb %bl, %bl
pushq $-0x1
popq %rcx
cmovel %eax, %ecx
movl %ecx, 0x4(%r14)
callq 0xb060
andl $0x0, (%rax)
cmpl $-0x1, 0x4(%r14)
sete %al
cmpb %bl, %al
jne 0x2a699
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
callq 0xb6c0
testl %eax, %eax
jne 0x2a76d
leaq 0x31294(%rip), %rsi     # 0x5b941
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x48(%rsp), %rdi
movl $0x89c, %esi            # imm = 0x89C
callq 0x1caa3
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1ca3c
leaq 0x2f4fa(%rip), %rdx     # 0x59be3
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1b92d
leaq 0x31e74(%rip), %rsi     # 0x5c579
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1b7b6
leaq 0x31223(%rip), %rdx     # 0x5b93e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b92d
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1ca3c
leaq 0x31e51(%rip), %rdx     # 0x5c59c
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1b92d
leaq 0xe8(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb68
jmp 0x2a78a
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb68
jmp 0x2a79c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x2a7ab
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x2a7ba
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb68
jmp 0x2a7cc
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb68
jmp 0x2a7de
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x2a7ed
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::CharInput::getLine[abi:cxx11]()
string CharInput::getLine ()
{
  string s;
  while (! eof)
  {
    const char c = get ();
    if (tp. eol ())
      break;
    s += c;
  }
  return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpb $0x0, 0x218(%r14)
jne 0x2b541
movq %r14, %rdi
callq 0x2ae60
cmpl $-0x1, 0x264(%r14)
je 0x2b541
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb4e0
jmp 0x2b518
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xbb68
movq %r14, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Token::saveText(std::ostream&) const
void Token::saveText (ostream &os) const 
{ 
  if (empty ())
    return;
    
  switch (type)
	{ 
	  case eName:      
	  case eDateTime:  os << name; 
	                   break;
		case eText:      if (quote)
		                   os << quote;
		                 os << name;
		                 if (quote)
		                   os << quote; 
		                 break;
		case eInteger:   os << n;             
		                 break;
		case eDouble:    { 
		                   const ONumber on (os, decimals, scientific); 
		                   os << d; 
		                 } 
		                 break;
		case eDelimiter: os << name;          
		                 break;
 		default: throw logic_error ("Token: Unknown type");
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x2c8bf
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%r14), %eax
cmpq $0x5, %rax
ja 0x2c987
leaq 0x2ed20(%rip), %rcx     # 0x5b5f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xb510
movb 0x30(%r14), %al
testb %al, %al
je 0x2c906
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb680
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xb510
movb 0x30(%r14), %al
testb %al, %al
je 0x2c8b7
movsbl %al, %esi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xb680
movq 0x48(%r14), %rdx
movzbl 0x50(%r14), %ecx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3c1e4
movsd 0x40(%r14), %xmm0
movq %rbx, %rdi
callq 0xb920
movq (%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x10(%rsp), %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq 0x8(%rsp), %rdx
movq %rdx, 0x8(%rax,%rcx)
jmp 0x2c8b7
movq 0x38(%r14), %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xb220
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
leaq 0x2feef(%rip), %rsi     # 0x5c888
movq %rax, %rdi
callq 0xb800
movq 0x57618(%rip), %rsi     # 0x83fc0
movq 0x575c9(%rip), %rdx     # 0x83f78
movq %r14, %rdi
callq 0xb9d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xb470
jmp 0x2c9e8
movq %rax, %rbx
movq (%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x10(%rsp), %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq 0x8(%rsp), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Token::operator<(Common_sp::Token const&) const
bool Token::operator< (const Token &other) const
{
  LESS_PART (*this, other, type);
  switch (type)
  { 
    case eName:
    case eText:
    case eDateTime:
    case eDelimiter: LESS_PART (*this, other, name); break;
    case eInteger:   LESS_PART (*this, other, n);    break; 
    case eDouble:    LESS_PART (*this, other, d);    break;
  }  
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x8(%rdi), %eax
movl 0x8(%rsi), %ecx
movb $0x1, %bl
cmpl %ecx, %eax
jl 0x2ca44
jg 0x2ca42
cmpl $0x5, %eax
ja 0x2ca42
movq %rsi, %r15
movq %rdi, %r14
movl %eax, %eax
leaq 0x2ebf5(%rip), %rcx     # 0x5b60c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x10, %r14
addq $0x10, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c260
testb %al, %al
jne 0x2ca44
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c260
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movsd 0x40(%r15), %xmm0
ucomisd 0x40(%r14), %xmm0
jbe 0x2ca42
jmp 0x2ca44
movq 0x38(%r14), %rax
cmpq 0x38(%r15), %rax
setl %bl
jmp 0x2ca44
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::TokenInput::get()
Token TokenInput::get ()
{ 
  const Token last_ (last);
  last = Token ();
  if (! last_. empty ())
  {
    tp = last_. tp;
    return last_;
  }
    
  for (;;)  
  { 
    Token t (ci, dashInName, consecutiveQuotesInText);
    if (t. empty ())
      break;
    tp = t. tp;
    if (! t. isDelimiter (commentStart))
      return t;
    ci. getLine ();
  }
  
  return Token ();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x280(%rsi), %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3cb38
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rax
movups %xmm0, -0x18(%rax)
movups %xmm0, -0x8(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
andq $0x0, 0x38(%rax)
leaq 0x56340(%rip), %rcx     # 0x82e00
movq %rcx, -0x20(%rax)
movl $0x1, -0x18(%rax)
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
movups %xmm0, 0x21(%rax)
orl $-0x1, 0x34(%rax)
orl $-0x1, 0x38(%rax)
leaq 0x80(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3cbc2
movq %r13, %rdi
callq 0x3cc0c
cmpl $0x1, 0x8(%r15)
jne 0x2cb75
cmpq $0x0, 0x18(%rsp)
jne 0x2cb75
leaq 0x8(%r14), %r15
leaq 0x60(%rsp), %r12
movzbl 0x279(%r14), %edx
movzbl 0x27a(%r14), %ecx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3cc32
cmpl $0x1, 0x8(%rbx)
jne 0x2cb39
cmpq $0x0, 0x18(%rbx)
je 0x2cb8d
movq 0x54(%rbx), %rax
movq %rax, 0x2e0(%r14)
movsbl 0x278(%r14), %esi
movq %rbx, %rdi
callq 0x3cc94
testb %al, %al
je 0x2cbb7
movq %r12, %rdi
movq %r15, %rsi
callq 0x2b4fe
movq %r12, %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0x3cc0c
jmp 0x2cb11
movq %rsp, %rsi
movq 0x54(%rsi), %rax
movq %rax, 0x2e0(%r14)
movq %rbx, %rdi
callq 0x3cb38
jmp 0x2cbb7
movq %rbx, %rdi
callq 0x3cc0c
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rdi
callq 0x3cb88
movq %rsp, %rdi
callq 0x3cc0c
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2cbd5
movq %rax, %r14
jmp 0x2cbe5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3cc0c
movq %rsp, %rdi
callq 0x3cc0c
movq %r14, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::TokenInput::getNextChar(bool)
char TokenInput::getNextChar (bool unget) 
{ 
  QC_ASSERT (last. empty ());

	char c = '\0';
	do { c = ci. get (); }
	  while (! ci. eof && isSpace (c));

	if (ci. eof)
		return '\0';  
		
  if (unget)
    ci. unget ();
  return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movq %rdi, %r15
callq 0xb060
andl $0x0, (%rax)
cmpl $0x1, 0x288(%r15)
jne 0x2d89a
cmpq $0x0, 0x298(%r15)
jne 0x2d89a
leaq 0x8(%r15), %r14
movq %r14, %rdi
callq 0x2ae60
movl %eax, %ebp
movb 0x220(%r15), %cl
testb %cl, %cl
jne 0x2d86d
movsbl %bpl, %edi
callq 0x3c341
testb %al, %al
jne 0x2d844
movb 0x220(%r15), %cl
notb %bl
orb %cl, %bl
movzbl %bpl, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovel %edx, %eax
testb $0x1, %bl
jne 0x2d88c
movq %r14, %rdi
callq 0x2b16c
movl %ebp, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xb6c0
testl %eax, %eax
jne 0x2d96e
leaq 0x2e093(%rip), %rsi     # 0x5b941
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x48(%rsp), %rdi
movl $0xb37, %esi            # imm = 0xB37
callq 0x1caa3
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1ca3c
leaq 0x2c2f9(%rip), %rdx     # 0x59be3
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1b92d
leaq 0x2f1b6(%rip), %rsi     # 0x5cabc
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1b7b6
leaq 0x2e022(%rip), %rdx     # 0x5b93e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b92d
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1ca3c
leaq 0x2efa7(%rip), %rdx     # 0x5c8f3
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1b92d
leaq 0xe8(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb68
jmp 0x2d98b
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb68
jmp 0x2d99d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x2d9ac
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x2d9bb
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb68
jmp 0x2d9cd
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb68
jmp 0x2d9df
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x2d9ee
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::BraceInput::skipComment()
void BraceInput::skipComment ()
{
	get ('{');
	size_t n = 1;
	for (;;)
	{
		const Token t (get ());
		if (t. isDelimiter ('{'))
			n++;
		else if (t. isDelimiter ('}'))
		{
			ASSERT (n);
			n--;
			if (! n)
				break;
		}
	}
//get (endChar);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rdi, %rbx
pushq $0x7b
popq %rbp
movl %ebp, %esi
callq 0x3cd00
pushq $0x1
popq %r12
leaq 0x108(%rsp), %r14
pushq $0x7d
popq %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ca6a
movq %r14, %rdi
movl %ebp, %esi
callq 0x3cc94
testb %al, %al
je 0x2eb5f
incq %r12
movb $0x1, %r13b
jmp 0x2eb85
movq %r14, %rdi
movl %r15d, %esi
callq 0x3cc94
movb $0x1, %r13b
testb %al, %al
je 0x2eb85
callq 0xb060
andl $0x0, (%rax)
testq %r12, %r12
je 0x2eba4
decq %r12
setne %r13b
movq %r14, %rdi
callq 0x3cc0c
testb %r13b, %r13b
jne 0x2eb3e
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb6c0
testl %eax, %eax
jne 0x2ec78
leaq 0x2cd89(%rip), %rsi     # 0x5b941
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x48(%rsp), %rdi
movl $0xb55, %esi            # imm = 0xB55
callq 0x1caa3
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1ca3c
leaq 0x2afef(%rip), %rdx     # 0x59be3
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1b92d
leaq 0x2deda(%rip), %rsi     # 0x5caea
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1b7b6
leaq 0x2cd18(%rip), %rdx     # 0x5b93e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b92d
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1ca3c
leaq 0x2cf66(%rip), %rdx     # 0x5bbbc
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1b92d
leaq 0xe8(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb68
jmp 0x2ec95
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb68
jmp 0x2eca7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x2ecb6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x2ecc5
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb68
jmp 0x2ecd7
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb68
jmp 0x2ece9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x2ecf8
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb68
jmp 0x2ed09
jmp 0x2ed06
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x3cc0c
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::csvLine2vec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
StringVector csvLine2vec (const string &line)
{
  StringVector words;  words. reserve (256);  // PAR
  Csv csv (line);
  string s;
  while (csv. goodPos ())
  {
    s = csv. getWord ();
    trim (s);
    words << std::move (s);
  }
  return words;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rdi)
movups %xmm0, (%rdi)
movl $0x100, %esi            # imm = 0x100
callq 0x1e7ce
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
andq $0x0, 0x8(%r14)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x38(%rsp), %r15
leaq 0x18(%rsp), %r12
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rax), %rcx
jae 0x30295
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ff02
movq %r12, %rdi
movq %r15, %rsi
callq 0xb6f0
movq %r15, %rdi
callq 0xbb68
movq %r12, %rdi
callq 0x3c32f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1d14c
jmp 0x30252
leaq 0x18(%rsp), %rdi
callq 0xbb68
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x302c2
jmp 0x302b5
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0x20bee
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::toStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string Json::toStr (const string& s)
{ 
  if (isNatural (s, false))
    return s;
    
  // https://www.json.org/json-en.html
  string res ("\"");
  for (const char c : s)
    switch (c)
    {
      case '\"': res += "\\\""; break;
      case '\\': res += "\\\\"; break;
      case '\n': res += "\\n"; break;
      case '\r': res += "\\t"; break;
      case '\t': res += "\\t"; break;
      default:   res += c;
    }
  return res + "\""; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x23c7e
testb %al, %al
je 0x307e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb7b0
jmp 0x3088e
movq %rbx, 0x10(%rsp)
leaq 0x2b1e7(%rip), %rsi     # 0x5b9d3
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1b7b6
movq (%r15), %r12
movq 0x8(%r15), %r15
xorl %r13d, %r13d
leaq 0x2b3a9(%rip), %rbp     # 0x5bbb8
leaq 0x2c4dc(%rip), %rbx     # 0x5ccf2
cmpq %r13, %r15
je 0x3086b
movzbl (%r12,%r13), %eax
cmpl $0x9, %eax
je 0x30845
cmpl $0xa, %eax
je 0x3084a
cmpl $0xd, %eax
je 0x30845
movq %rbp, %rsi
cmpl $0x5c, %eax
je 0x30851
cmpl $0x22, %eax
jne 0x3085e
leaq 0x2c4ac(%rip), %rsi     # 0x5ccef
jmp 0x30851
movq %rbx, %rsi
jmp 0x30851
leaq 0x2b36a(%rip), %rsi     # 0x5bbbb
movq %r14, %rdi
callq 0xbac0
incq %r13
jmp 0x30816
movsbl %al, %esi
movq %r14, %rdi
callq 0xb4e0
jmp 0x30859
leaq 0x2b161(%rip), %rdx     # 0x5b9d3
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c88d
leaq 0x18(%rsp), %rdi
callq 0xbb68
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x308a2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
nop