LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xd
popq %rdi
xorl %esi, %esi
callq 0xb690
cmpb $0x1, 0x62cce(%rip)     # 0x84ae1
jne 0x21e1c
xorl %edi, %edi
callq 0xb6d0
pushq $0x1
popq %rdi
callq 0xb6d0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::beep()
void beep ()
{ 
  if (getEnv ("SHLVL") != "1")
    return;
	constexpr char c = '\x07';
	if (! isRedirected (cerr))
	  cerr << c;
	else if (! isRedirected (cout))
	  cout << c;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
leaq 0x39550(%rip), %rsi     # 0x5b99a
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x1b7b6
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x3c19a
leaq 0x3a3f4(%rip), %rsi     # 0x5c864
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3c1d9
movl %eax, %ebp
movq %rbx, %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x224c7
movq 0x61b43(%rip), %rbx     # 0x83fe0
movq %rbx, %rdi
callq 0x2271e
testb %al, %al
je 0x224bc
movq 0x61ad8(%rip), %rbx     # 0x83f88
movq %rbx, %rdi
callq 0x2271e
testb %al, %al
jne 0x224c7
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0xb680
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x90, %rsp
cmpb $0x1, 0x621d8(%rip)     # 0x84af2
jne 0x22939
cmpq $0x1, 0x61cb4(%rip)     # 0x845d8
jne 0x22939
movq %rdi, %r14
cmpq $-0x1, 0x28(%rdi)
jne 0x22945
callq 0xb400
movq %rax, 0x28(%r14)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x39049(%rip), %rsi     # 0x5b9a0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x39058(%rip), %rdx     # 0x5b9c5
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b92d
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r14, %rdx
callq 0x1cbaf
leaq 0x39040(%rip), %rdx     # 0x5b9d5
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1b92d
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x6162b(%rip), %rsi     # 0x83fe8
movq 0x6159c(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0xbb68
jmp 0x229e1
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x229f3
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x22a05
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x22a19
jmp 0x22a21
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::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 %r14
pushq %rbx
subq $0x90, %rsp
cmpb $0x1, 0x620b6(%rip)     # 0x84af2
jne 0x22a64
cmpq $0x1, 0x61b92(%rip)     # 0x845d8
jne 0x22a64
movq %rdi, %r14
cmpq $-0x1, 0x28(%rdi)
je 0x22a70
callq 0xb400
subq 0x28(%r14), %rax
addq %rax, 0x20(%r14)
orq $-0x1, 0x28(%r14)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x38f64(%rip), %rsi     # 0x5b9e6
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x38f2d(%rip), %rdx     # 0x5b9c5
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b92d
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r14, %rdx
callq 0x1cbaf
leaq 0x38f4a(%rip), %rdx     # 0x5ba0a
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1b92d
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x61500(%rip), %rsi     # 0x83fe8
movq 0x61471(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0xbb68
jmp 0x22b0c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x22b1e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x22b30
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x22b44
jmp 0x22b4c
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
cmpb $0x1, 0x61f90(%rip)     # 0x84af2
jne 0x22c03
cmpq $0x1, 0x61a68(%rip)     # 0x845d8
jne 0x22c03
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38e98(%rip), %rsi     # 0x5ba1b
movq %rbx, %rdi
callq 0xb590
movq %rax, %rdi
movq %r14, %rsi
callq 0xb510
leaq 0x38d73(%rip), %rsi     # 0x5b910
movq %rax, %rdi
callq 0xb590
movq %rsp, %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x3c1e4
cvtsi2sdq 0x20(%r14), %xmm0
divsd 0x389cd(%rip), %xmm0    # 0x5b590
movq %rbx, %rdi
callq 0xb920
leaq 0x38e51(%rip), %rsi     # 0x5ba23
movq %rax, %rdi
callq 0xb590
movq %rax, %rdi
callq 0xb2f0
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)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq (%rsp), %rcx
movq (%rcx), %rdx
movq -0x18(%rdx), %rsi
movl 0x10(%rsp), %edi
movl %edi, 0x18(%rcx,%rsi)
movq -0x18(%rdx), %rdx
movq 0x8(%rsp), %rsi
movq %rsi, 0x8(%rcx,%rdx)
movq %rax, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x29(%rdi)
jne 0x22d61
callq 0xb6c0
testl %eax, %eax
jne 0x22d61
xorl %edi, %edi
callq 0xb570
movq %rax, %r14
movq 0x20(%rbx), %rsi
leaq 0x20(%rsp), %rdi
pushq $0x23
popq %rdx
pushq $0x1
popq %r8
xorl %ecx, %ecx
callq 0x1e0c2
movq 0x20(%rbx), %rdi
leaq 0x38d56(%rip), %rsi     # 0x5ba1b
callq 0xb590
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb510
leaq 0x38c34(%rip), %rsi     # 0x5b910
movq %rax, %rdi
callq 0xb590
movq 0x20(%rbx), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3c1e4
movq 0x20(%rbx), %r15
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0xb320
movq %r15, %rdi
callq 0xb920
leaq 0x38d0e(%rip), %rsi     # 0x5ba23
movq %rax, %rdi
callq 0xb590
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rsp), %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rax,%rcx)
leaq 0x20(%rsp), %rdi
callq 0x1e15c
movq 0x20(%rbx), %rdi
callq 0xb2f0
cmpb $0x1, 0x28(%rbx)
jne 0x22d61
movq 0x20(%rbx), %rdi
callq 0xb2f0
movq %rbx, %rdi
callq 0xbb68
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1bdcd
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22d95
movzbl %dil, %ecx
pushq $0x1
popq %rdx
xorl %eax, %eax
notl %ecx
testl %ecx, %edx
je 0x22d98
incq %rax
addl %edx, %edx
jmp 0x22d8a
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0x22dd0
cmpq $0x1, %rdi
je 0x22dd7
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x22e7b
testq %rsi, %rsi
je 0x22de3
xorl %edi, %edi
movq %rdi, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x38c34(%rip), %rsi     # 0x5ba29
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x38c47(%rip), %rdx     # 0x5ba52
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b92d
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x611b5(%rip), %rsi     # 0x83fe8
movq 0x61126(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x22e57
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x22e6b
jmp 0x22e73
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22eb6
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1, %rsi
je 0x22eb9
movq %r14, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0x22e7b
testb $0x1, %r14b
pushq $0x1
popq %rcx
cmovneq %rbx, %rcx
movq %rax, %rbx
imulq %rax, %rbx
imulq %rcx, %rbx
jmp 0x22eb9
pushq $0x1
popq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::nonPrintable2str[abi:cxx11](char)
string nonPrintable2str (char c)
{
	string s;
	switch (c)
	{
		case  7: s = "BEL"; break;
		case  8: s = "BS"; break;
		case  9: s = "TAB"; break;
		case 10: s = "LF"; break;
		case 12: s = "FF"; break;
		case 13: s = "CR"; break;
		case 27: s = "ESC"; break;
		case 32: s = "SPACE"; break;
		default: s = "x" + uchar2hex ((uchar) c);
	}	  	
	return "<" + s + ">";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
leal -0x7(%rsi), %eax
cmpl $0x6, %eax
ja 0x23280
leaq 0x38335(%rip), %rcx     # 0x5b5a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x387e7(%rip), %rsi     # 0x5ba62
jmp 0x23315
cmpl $0x1b, %esi
je 0x2330e
cmpl $0x20, %esi
jne 0x23297
leaq 0x387e5(%rip), %rsi     # 0x5ba7a
jmp 0x23315
movzbl %sil, %esi
leaq 0x48(%rsp), %rdi
callq 0x3c28b
leaq 0x3961b(%rip), %rsi     # 0x5c8c7
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x1b94c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0xb6f0
movq %r14, %rdi
callq 0xbb68
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x2331f
leaq 0x38785(%rip), %rsi     # 0x5ba6d
jmp 0x23315
leaq 0x38775(%rip), %rsi     # 0x5ba66
jmp 0x23315
leaq 0x38776(%rip), %rsi     # 0x5ba70
jmp 0x23315
leaq 0x38766(%rip), %rsi     # 0x5ba69
jmp 0x23315
leaq 0x38767(%rip), %rsi     # 0x5ba73
jmp 0x23315
leaq 0x38761(%rip), %rsi     # 0x5ba76
leaq 0x28(%rsp), %rdi
callq 0xbad0
leaq 0x3875a(%rip), %rsi     # 0x5ba80
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1b8b7
leaq 0x3ab4c(%rip), %rdx     # 0x5de88
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b92d
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0x28(%rsp), %rdi
callq 0xbb68
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x2337e
jmp 0x23385
jmp 0x23385
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x23388
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %r14
movq %rbx, %rdi
callq 0x235ab
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x235a5
movq (%rbx), %rax
movsbl -0x1(%rax,%r15), %edi
callq 0x3c310
testb %al, %al
jne 0x235a5
decq %r15
movq (%rbx), %rax
movsbl (%rax,%r15), %edi
callq 0x3c2f6
testb %al, %al
jne 0x235a5
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb100
jmp 0x2355e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq %r15, %r14
subq $0x1, %r15
jb 0x235d2
movq (%rbx), %rax
movsbl -0x1(%rax,%r14), %edi
callq 0x3c341
testb %al, %al
jne 0x235b7
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edx, %edx
callq 0xbb30
movq %rax, %r14
cmpq $-0x1, %rax
je 0x2360a
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb100
cmpq $-0x1, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x3c32f
pushq $0x9
popq %rsi
pushq $0x20
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x236cf
pushq $0x2c
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x236cf
leaq 0x3a1b9(%rip), %rsi     # 0x5d804
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x3a1a4(%rip), %rsi     # 0x5d805
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1b7b6
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x236ec
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0x28(%rsp), %rdi
callq 0xbb68
pushq $0x20
popq %rsi
pushq $0x2c
popq %rdx
movq %rbx, %rdi
callq 0x236cf
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x236bd
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::replaceStr(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void replaceStr (string &s,
                 const string &from,
                 const string &to)
{
  ASSERT (! from. empty ());
  
  if (from == to)
    return;
  
  const bool inside = contains (to, from);

  size_t start = 0;    
  for (;;)
  {
    const size_t pos = s. find (from, start);
    if (pos == string::npos)
      break;
    s. replace (pos, from. size (), to);
    start = pos + (inside ? to. size () : 0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xb060
andl $0x0, (%rax)
cmpq $0x0, 0x8(%r14)
je 0x23779
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d9db
testb %al, %al
je 0x23732
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d40b
movl %eax, %ebp
xorl %edx, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xbb30
cmpq $-0x1, %rax
je 0x23722
movq %rax, %r12
movq 0x8(%r14), %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0xb210
testb %bpl, %bpl
je 0x23772
movq 0x8(%rbx), %rdx
jmp 0x23774
xorl %edx, %edx
addq %r12, %rdx
jmp 0x23741
callq 0xb6c0
testl %eax, %eax
jne 0x2384d
leaq 0x381b4(%rip), %rsi     # 0x5b941
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x3c3, %esi            # imm = 0x3C3
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x3641a(%rip), %rdx     # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0x3837d(%rip), %rsi     # 0x5bb62
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x38143(%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 0x3837c(%rip), %rdx     # 0x5bba7
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 0x2386a
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x2387c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x2388b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x2389a
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x238ac
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x238be
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x238cd
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::visualizeTrailingSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void visualizeTrailingSpaces (string &s)
{
	size_t spaces = 0;
	while (   ! s. empty ()
	       && s. back () == ' '
	      )
	{
		s. erase (s. size () - 1);
		spaces++;
	}
	FFOR (size_t, i, spaces)
	  s += nonPrintable2str (' ');
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $-0x1
popq %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x24708
movq (%rbx), %rax
cmpb $0x20, -0x1(%rax,%rsi)
jne 0x24708
decq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb100
incq %r15
jmp 0x246c1
movq %rsp, %r14
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x23241
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbb00
movq %rsp, %rdi
callq 0xbb68
subq $0x1, %r15
jae 0x246e7
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::matches(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&, Common_sp::StringMatch::Type)
bool matches (const string &hay,
              const string &needle,
              StringMatch::Type type)
{ 
	switch (type)
	{ 
		case StringMatch::part:  return contains (hay, needle);   
		case StringMatch::word:  return containsWord (hay, needle) != string::npos;
		case StringMatch::whole: return hay == needle;
	}
	NEVER_CALL;
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
cmpl $0x2, %edx
je 0x241fd
cmpl $0x1, %edx
je 0x241e8
testl %edx, %edx
jne 0x2420a
addq $0x110, %rsp            # imm = 0x110
popq %rbx
jmp 0x1d40b
callq 0x24155
cmpq $-0x1, %rax
setne %al
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
addq $0x110, %rsp            # imm = 0x110
popq %rbx
jmp 0x1d9db
callq 0xb6c0
testl %eax, %eax
jne 0x242de
leaq 0x37723(%rip), %rsi     # 0x5b941
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x3a4, %esi            # imm = 0x3A4
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x35989(%rip), %rdx     # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0x378a1(%rip), %rsi     # 0x5bb17
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x376b2(%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 0x37803(%rip), %rdx     # 0x5babf
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 0x242fb
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x2430d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x2431c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x2432b
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x2433d
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x2434f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x2435e
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::getScientific(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool&, long&)
bool getScientific (string numberS,
                    bool &hasPoint,
                    streamsize &decimals)
{
  strUpper (numberS);
  const size_t ePos     = numberS. find ('E');
  const size_t pointPos = numberS. find ('.');
  
  hasPoint = (pointPos != string::npos);  
  decimals = 0;
  if (ePos == string::npos)
  {
    if (hasPoint)
      decimals = (streamoff) (numberS. size () - (pointPos + 1));
  }
  else
  {
    ASSERT (ePos != pointPos);
    if (hasPoint && ePos < pointPos)
      hasPoint = false;
    if (hasPoint)
      decimals = (streamoff) (ePos - (pointPos + 1));
  }
  
  return ePos != string::npos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r13
callq 0x23f17
pushq $0x45
popq %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0xb760
movq %rax, %r14
pushq $0x2e
popq %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0xb760
movq %rax, %r12
cmpq $-0x1, %rax
setne (%r15)
andq $0x0, (%rbx)
cmpq $-0x1, %r14
je 0x23d7b
callq 0xb060
andl $0x0, (%rax)
cmpq %r12, %r14
je 0x23db1
cmpq $-0x1, %r12
sete %al
cmpq %r12, %r14
setae %cl
orb %al, %cl
jne 0x23d8a
movb $0x0, (%r15)
jmp 0x23d99
cmpq $-0x1, %r12
je 0x23d99
notq %r12
addq 0x8(%r13), %r12
jmp 0x23d96
cmpq $-0x1, %r12
je 0x23d99
notq %r12
addq %r14, %r12
movq %r12, (%rbx)
cmpq $-0x1, %r14
setne %al
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xb6c0
testl %eax, %eax
jne 0x23e85
leaq 0x37b7c(%rip), %rsi     # 0x5b941
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x2fb, %esi            # imm = 0x2FB
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x35de2(%rip), %rdx     # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0x37cad(%rip), %rsi     # 0x5baca
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x37b0b(%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 0x37ca3(%rip), %rdx     # 0x5bb06
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 0x23ea2
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x23eb4
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x23ec3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x23ed2
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x23ee4
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x23ef6
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x23f05
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::stringNotInSet(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&, Common_sp::ebool)
size_t stringNotInSet (const string &s,
                   	   const string &charSet,
                   	   ebool uppercase)
{
  FFOR (size_t, i, s. size ())
  {
    char c = s [i];
    switch (uppercase)
    {
      case efalse: c = toLower (c); break;
      case etrue:  c = toUpper (c); break;
      case enull: break;
    }
    if (! charInSet (c, charSet))
      return i;
  }
  return no_index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r13
xorl %r12d, %r12d
pushq $-0x1
popq %rbx
cmpq %r12, %r13
je 0x24031
movq (%r15), %rax
movb (%rax,%r12), %al
movsbl %al, %edi
cmpl $0x1, %ebp
je 0x24015
testl %ebp, %ebp
jne 0x2401a
callq 0x3c367
jmp 0x2401a
callq 0x3c35f
movsbl %al, %edi
movq %r14, %rsi
callq 0x3c38d
testb %al, %al
je 0x2402e
incq %r12
jmp 0x23ff6
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::strCountSet(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 strCountSet (const string &s,
 		                const string &charSet)
{
  size_t n = 0;
  for (const char c : s)
	  if (charInSet (c, charSet))		
	    n++;
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpq %r13, %r12
je 0x24079
movsbl (%r15,%r13), %edi
movq %rbx, %rsi
callq 0x3c38d
movzbl %al, %eax
addq %rax, %r14
incq %r13
jmp 0x2405c
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::trimTrailing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
void trimTrailing (string &s,
                   char c)
{
	size_t i = s. size ();
	while (i)
		if (s [i - 1] == c)
			i--;
		else
			break;
  s. erase (i);
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq $0x1, %rdx
jb 0x2414a
cmpb %sil, -0x1(%rcx,%rax)
je 0x2413a
pushq $-0x1
popq %rdx
movq %rax, %rsi
jmp 0xb100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r15
incq %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xbb30
movq %rax, %r15
cmpq $-0x1, %rax
je 0x241b6
movq 0x8(%rbx), %r12
addq %r15, %r12
testq %r15, %r15
je 0x2419f
movq (%r14), %rax
movsbl -0x1(%rax,%r15), %edi
callq 0x3c2d0
testb %al, %al
jne 0x24167
cmpq 0x8(%r14), %r12
je 0x241b6
movq (%r14), %rax
movsbl (%rax,%r12), %edi
callq 0x3c2d0
testb %al, %al
jne 0x24167
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0xb7b0
leaq 0x377f3(%rip), %rsi     # 0x5bbc0
leaq 0x8(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x1b7b6
leaq 0x377d5(%rip), %rsi     # 0x5bbb8
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x1b7b6
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x236ec
leaq 0x28(%rsp), %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
callq 0xbb68
movb $0x5c, 0x5(%rsp)
movb %bpl, 0x6(%rsp)
movb $0x0, 0x7(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movl %ebp, %edx
callq 0xb670
leaq 0x28(%rsp), %rdi
leaq 0x5(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x1b7b6
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x236ec
leaq 0x28(%rsp), %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movl %ebp, %esi
callq 0x3c3c7
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x3c3a5
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0x48(%rsp), %rdi
callq 0xbb68
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0x244d8
jmp 0x244e7
jmp 0x244c9
jmp 0x244d8
jmp 0x244e7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x244db
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x244ea
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r13
xorl %r12d, %r12d
leaq 0x18(%rsp), %r14
movq %rdi, 0x10(%rsp)
cmpq %r12, %r13
je 0x245a0
movb (%r15,%r12), %bpl
cmpb $0xa, %bpl
jne 0x24551
movq %rbx, %rdi
leaq 0x37671(%rip), %rsi     # 0x5bbbb
callq 0xbac0
jmp 0x2459b
movq %r14, %rdi
leaq 0x37663(%rip), %rsi     # 0x5bbbe
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
movsbl %bpl, %ebp
movl %ebp, %edi
movq %r14, %rsi
callq 0x3c38d
movl %eax, %ebx
movq %r14, %rdi
callq 0xbb68
testb %bl, %bl
movq 0x10(%rsp), %rbx
je 0x24591
movq %rbx, %rdi
pushq $0x5c
popq %rsi
callq 0xb4e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb4e0
incq %r12
jmp 0x24531
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x245b4
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0xbb68
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::collapseSpace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void collapseSpace (string &s)
{
  string s1;
  do 
  {
    s1 = s;
    replaceStr (s, "  ", " ");
  }
  while (s1 != s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r14
leaq 0x48(%rsp), %r12
leaq 0x39209(%rip), %rbp     # 0x5d805
leaq 0x28(%rsp), %r15
leaq 0x6(%rsp), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb350
movq %r12, %rdi
leaq 0x391e9(%rip), %rsi     # 0x5d804
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1b7b6
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x236ec
movq %r15, %rdi
callq 0xbb68
movq %r12, %rdi
callq 0xbb68
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d401
testb %al, %al
jne 0x24606
leaq 0x8(%rsp), %rdi
callq 0xbb68
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2467b
movq %rax, %rbx
jmp 0x2469c
movq %rax, %rbx
jmp 0x24692
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
leaq 0x48(%rsp), %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::str2streamWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
string str2streamWord (const string &s,
                       size_t wordNum)
{
  istringstream iss (s);
  string word;
  FOR (size_t, i, wordNum + 1)
    if (iss. eof ())
    	return noString;
    else
      iss >> word;
  return word;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0xb9a0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
andq $0x0, -0x8(%r13)
movb $0x0, (%r13)
incq %r14
movq %rsp, %r12
subq $0x1, %r14
jb 0x2478d
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x247ab
movq %r15, %rdi
movq %r12, %rsi
callq 0xb730
jmp 0x2476a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rcx
cmpq %r13, %rcx
je 0x247bc
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x247c4
leaq 0x60346(%rip), %rsi     # 0x84af8
movq %rbx, %rdi
callq 0xb7b0
jmp 0x247dc
movups (%r13), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r13, (%rsp)
andq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %rsp, %rdi
callq 0xbb68
leaq 0x20(%rsp), %rdi
callq 0xb2d0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x24804
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbb68
leaq 0x20(%rsp), %rdi
callq 0xb2d0
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::findSplit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
string findSplit (string &s,
                  char c)
{
	const size_t pos = s. find (c);
	if (pos == string::npos)
	{
		const string s1 (s);
		s. clear ();
		return s1;
	}
	const string before (s. substr (0, pos));
	s. erase (0, pos + 1);
	return before;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xb760
cmpq $-0x1, %rax
je 0x248f3
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb5e0
incq %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xb100
jmp 0x24909
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb7b0
andq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
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::rfindSplit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
string rfindSplit (string &s,
                   char c)
{
	const size_t pos = s. rfind (c);
	if (pos == string::npos)
	{
		const string s1 (s);
		s. clear ();
		return s1;
	}
	const string after (s. substr (pos + 1));
	s. erase (pos);
	return after;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $-0x1
popq %rax
movq %rsi, %rdi
movl %edx, %esi
movq %rax, %rdx
callq 0xbb20
cmpq $-0x1, %rax
je 0x24974
movq %rax, %r15
movq %rax, %rdx
incq %rdx
pushq $-0x1
popq %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0xb5e0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb100
jmp 0x2498a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb7b0
andq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
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::str2list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
List<string> str2list (const string &s,
                       char c) 
{
	List<string> res;
	string s1 (s);
	while (! s1. empty ())
	  res << std::move (findSplit (s1, c));
	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
callq 0xb7b0
movsbl %bpl, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
cmpq $0x0, 0x10(%rsp)
je 0x24e6d
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x248b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e628
movq %r14, %rdi
callq 0xbb68
jmp 0x24e43
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x24ea6
movq %rax, %r14
jmp 0x24e9c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0x1e654
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::list2str(Common_sp::List<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&)
string list2str (const List<string> &strList,
                 const string &sep) 
{
	string s;
	bool first = true;
	for (const string& e : strList)
	{
    if (! first)
			s += sep;
	  s += e;
	  first = false;
	}
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
movb $0x1, %bpl
movq %rsi, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x24f08
testb $0x1, %bpl
jne 0x24ef7
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbb00
leaq 0x10(%r12), %rsi
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xbb00
jmp 0x24edd
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
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::getFiletype(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
Filetype getFiletype (const string &path,
                      bool expandLink)
{
  struct stat buf;
  if (expandLink)
  {
    if (stat (path. c_str (), & buf))
      return Filetype::none;
  }
  else
  {
    if (lstat (path. c_str (), & buf))
      return Filetype::none;
  }
    
  if (S_ISDIR  (buf. st_mode))  return Filetype::dir;
  if (S_ISCHR  (buf. st_mode))  return Filetype::terminal;
  if (S_ISBLK  (buf. st_mode))  return Filetype::disk;
  if (S_ISREG  (buf. st_mode))  return Filetype::file;
  if (S_ISFIFO (buf. st_mode))  return Filetype::pipe;
  if (! expandLink)
  {
    if (S_ISLNK  (buf. st_mode))  return Filetype::link;
  }
  if (S_ISSOCK (buf. st_mode))  return Filetype::socket;
    
  NEVER_CALL;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %esi, %ebx
movq (%rdi), %rdi
testl %esi, %esi
je 0x24f58
leaq 0x110(%rsp), %rsi
callq 0xb530
jmp 0x24f65
leaq 0x110(%rsp), %rsi
callq 0xbaf0
testl %eax, %eax
je 0x24f6d
xorl %eax, %eax
jmp 0x24fbf
movl $0xf000, %eax           # imm = 0xF000
andl 0x128(%rsp), %eax
leal -0x1000(%rax), %ecx
cmpl $0x8000, %ecx           # imm = 0x8000
jae 0x24fa2
shrl $0xc, %ecx
movl $0xab, %edx
btl %ecx, %edx
jae 0x24fa2
movl %ecx, %eax
leaq 0x39efb(%rip), %rcx     # 0x5ee98
movl (%rcx,%rax,4), %eax
jmp 0x24fbf
cmpl $0xa000, %eax           # imm = 0xA000
sete %cl
xorb $0x1, %bl
testb %bl, %cl
jne 0x24fbc
cmpl $0xc000, %eax           # imm = 0xC000
jne 0x24fc8
pushq $0x7
jmp 0x24fbe
pushq $0x6
popq %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
callq 0xb6c0
testl %eax, %eax
jne 0x2509c
leaq 0x36965(%rip), %rsi     # 0x5b941
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x51a, %esi            # imm = 0x51A
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x34bcb(%rip), %rdx     # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0x36d33(%rip), %rsi     # 0x5bd67
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x368f4(%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 0x36a45(%rip), %rdx     # 0x5babf
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 0x250b9
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x250cb
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x250da
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x250e9
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x250fb
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x2510d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x2511c
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::copyText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::ostream&)
void copyText (const string &inFName,
               size_t skipLines,
               ostream &os)
{
  QC_ASSERT (os. good ());
  LineInput li (inFName);
  while (li. nextLine ())
    if ((size_t) li. lineNum > skipLines)
      os << li. line << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x398, %rsp            # imm = 0x398
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0xb060
andl $0x0, (%rax)
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
jne 0x25803
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1d20a
leaq 0x358(%rsp), %r12
movq %r15, %rdi
callq 0x219d4
testb %al, %al
je 0x257e7
movl 0x350(%rsp), %eax
cmpq %r14, %rax
jbe 0x257ba
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb510
movq %rax, %rdi
callq 0xb2f0
jmp 0x257ba
leaq 0xf0(%rsp), %rdi
callq 0x1d368
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xb6c0
testl %eax, %eax
jne 0x258d7
leaq 0x3612a(%rip), %rsi     # 0x5b941
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x4e3, %esi            # imm = 0x4E3
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x34390(%rip), %rdx     # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0x36467(%rip), %rsi     # 0x5bcd6
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x360b9(%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 0x3645d(%rip), %rdx     # 0x5bd12
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 0x258f4
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x25906
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x25915
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x25924
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x25936
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x25948
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x25957
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
jmp 0x25978
movq %rax, %rbx
jmp 0x25978
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x1d368
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::filetype2name[abi:cxx11](Common_sp::Filetype)
string filetype2name (Filetype t)
{
  switch (t)
  {
    case Filetype::none:     return "none";
    case Filetype::dir:      return "dir";
    case Filetype::terminal: return "terminal";
    case Filetype::disk:     return "disk";      
    case Filetype::file:     return "file";
    case Filetype::pipe:     return "pipe";
    case Filetype::link:     return "link";
    case Filetype::socket:   return "socket";
    default:
      NEVER_CALL;
  }
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
cmpl $0x7, %esi
ja 0x25a01
movq %rdi, %rbx
movl %esi, %eax
leaq 0x35c23(%rip), %rcx     # 0x5b5bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x36375(%rip), %rsi     # 0x5bd1e
jmp 0x259e8
leaq 0x37093(%rip), %rsi     # 0x5ca45
jmp 0x259e8
leaq 0x36368(%rip), %rsi     # 0x5bd23
jmp 0x259e8
leaq 0x36368(%rip), %rsi     # 0x5bd2c
jmp 0x259e8
leaq 0x36369(%rip), %rsi     # 0x5bd36
jmp 0x259e8
leaq 0x34f13(%rip), %rsi     # 0x5a8e9
jmp 0x259e8
leaq 0x37c07(%rip), %rsi     # 0x5d5e6
jmp 0x259e8
leaq 0x36349(%rip), %rsi     # 0x5bd31
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1b7b6
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xb6c0
testl %eax, %eax
jne 0x25ad5
leaq 0x35f2c(%rip), %rsi     # 0x5b941
leaq 0x90(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x70(%rsp), %rdi
movl $0x4fa, %esi            # imm = 0x4FA
callq 0x1caa3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x1ca3c
leaq 0x3418c(%rip), %rdx     # 0x59be3
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x1b92d
leaq 0x362ca(%rip), %rsi     # 0x5bd3d
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0x35eb5(%rip), %rdx     # 0x5b93e
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1b92d
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x36006(%rip), %rdx     # 0x5babf
leaq 0x10(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x1b92d
leaq 0x10(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x25aef
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xbb68
jmp 0x25b01
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x25b10
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x25b1f
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x25b31
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x25b43
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
jmp 0x25b52
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30