LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::SoftwareVersion::SoftwareVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SoftwareVersion::SoftwareVersion (const string &fName)
{ 
  StringVector vec (fName, (size_t) 1, true);
  if (vec. size () != 1)
    throw runtime_error ("Cannot read software version. One line is expected in the file: " + shellQuote (fName));
  init (std::move (vec [0]), false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5d378(%rip), %rax     # 0xaf240
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
leaq 0x68(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movl $0x1, %ecx
callq 0x426a6
movq 0x8(%r15), %rax
subq (%r15), %rax
cmpq $0x20, %rax
jne 0x51f2f
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x2e39a
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x52044
leaq 0x68(%rsp), %rdi
callq 0x327d2
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2c212
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2cac1
leaq 0x3c09c(%rip), %rsi     # 0x8e00b
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2bbf7
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x5e051(%rip), %rsi     # 0xaffe8
movq 0x5dfc2(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51fcc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x51fcc
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51fe7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x51ffe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x52024
jmp 0x52031
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x52024
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x52024
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
jmp 0x52031
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x327d2
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::SoftwareVersion::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, bool)
void SoftwareVersion::init (string &&s,
                            bool minorOnly)
{ 
  try 
  { 
    major = str2<uint> (findSplit (s, '.'));
    if (minorOnly)
      minor = str2<uint> (s);
    else
    { 
      minor = str2<uint> (findSplit (s, '.'));
      patch = str2<uint> (s);
    }
  } 
  catch (...) 
  { 
    throw runtime_error ("Cannot read software version"); 
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x2e, %edx
callq 0x391de
leaq 0x8(%rsp), %rdi
callq 0x2ed6b
movl %eax, 0x8(%rbx)
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x5208d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
je 0x5209f
movq %r14, %rdi
callq 0x2ed6b
movl %eax, 0xc(%rbx)
jmp 0x520e0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x2e, %edx
callq 0x391de
leaq 0x8(%rsp), %rdi
callq 0x2ed6b
movl %eax, 0xc(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x520d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0x2ed6b
movl %eax, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x5210f
jmp 0x52121
jmp 0x5211e
jmp 0x5211e
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52121
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x52121
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa240
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3bf0f(%rip), %rsi     # 0x8e04c
movq %rax, %rdi
callq 0xa230
movq 0x5de9c(%rip), %rsi     # 0xaffe8
movq 0x5de0d(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
jmp 0x5216b
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
callq 0xa960
movq %r14, %rdi
callq 0xaa10
movq %rax, %rdi
callq 0x2c2a7
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::DataVersion::DataVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
DataVersion::DataVersion (const string &fName)
{ 
  StringVector vec (fName, (size_t) 1, true);
  if (vec. size () != 1)
    throw runtime_error ("Cannot read data version. One line is expected in the file: " + shellQuote (fName));
  init (std::move (vec [0]));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5d044(%rip), %rax     # 0xaf298
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x68(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movl $0x1, %ecx
callq 0x426a6
movq 0x8(%r15), %rax
subq (%r15), %rax
cmpq $0x20, %rax
jne 0x522b1
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x2e39a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x523c6
leaq 0x68(%rsp), %rdi
callq 0x327d2
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2c212
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2cac1
leaq 0x3bd78(%rip), %rsi     # 0x8e069
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2bbf7
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x5dccf(%rip), %rsi     # 0xaffe8
movq 0x5dc40(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5234e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x5234e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52369
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x52380
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x523a6
jmp 0x523b3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x523a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x523a6
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
jmp 0x523b3
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x327d2
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::DataVersion::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
void DataVersion::init (string &&s)
{ 
  try
  { 
    year  = str2<uint> (findSplit (s, '-'));
    month = str2<uint> (findSplit (s, '-'));
    day   = str2<uint> (findSplit (s, '.'));
    num   = str2<uint> (s);
  } 
  catch (...) 
  { 
    throw runtime_error ("Cannot read data version"); 
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x2d, %edx
callq 0x391de
movq %rsp, %rdi
callq 0x2ed6b
movl %eax, 0x8(%rbx)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x52408
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rsp, %rdi
movq %r14, %rsi
movl $0x2d, %edx
callq 0x391de
movq %rsp, %rdi
callq 0x2ed6b
movl %eax, 0xc(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x52439
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rsp, %rdi
movq %r14, %rsi
movl $0x2e, %edx
callq 0x391de
movq %rsp, %rdi
callq 0x2ed6b
movl %eax, 0x10(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5246a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0x2ed6b
movl %eax, 0x14(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x524b5
jmp 0x52485
jmp 0x524b5
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x524a6
jmp 0x524b8
jmp 0x524b5
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x524b8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x524b8
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa240
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3bbd2(%rip), %rsi     # 0x8e0a6
movq %rax, %rdi
callq 0xa230
movq 0x5db05(%rip), %rsi     # 0xaffe8
movq 0x5da76(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
jmp 0x52502
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
callq 0xa960
movq %r14, %rdi
callq 0xaa10
movq %rax, %rdi
callq 0x2c2a7
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::DataVersion::operator<(Common_sp::DataVersion const&) const
bool DataVersion::operator< (const DataVersion &other) const
{ 
  LESS_PART (*this, other, year);
  LESS_PART (*this, other, month);
  LESS_PART (*this, other, day);
  LESS_PART (*this, other, num);
  return false;
}

// Assembly:
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
movb $0x1, %al
cmpl %edx, %ecx
jb 0x525b6
jbe 0x525b7
xorl %eax, %eax
retq
movl 0xc(%rdi), %ecx
movl 0xc(%rsi), %edx
cmpl %edx, %ecx
jb 0x525b6
ja 0x525b4
movl 0x10(%rdi), %ecx
movl 0x10(%rsi), %edx
cmpl %edx, %ecx
jb 0x525b6
ja 0x525b4
movl 0x14(%rdi), %eax
cmpl 0x14(%rsi), %eax
setb %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Application::Key::saveText(std::ostream&) const
void Application::Key::saveText (ostream &os) const
{
  os << '-';
	if (app. gnu)
	{
		os << "-" << name;
		if (! flag)
			os << ' ' << var;
	}
	else
	{
	  os << name; 
	  if (! flag)
	  {
	    os << ' ';
	    const bool quoted = defaultValue. empty () || contains (defaultValue, ' ');
	    if (quoted)
	      os << '\"';
	    os << defaultValue;
	    if (quoted)
	      os << '\"';
	  }
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb(%rsp), %rsi
movb $0x2d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
movq 0x68(%r14), %rax
cmpb $0x1, 0xa9(%rax)
jne 0x54876
leaq 0x37721(%rip), %rsi     # 0x8bf44
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0xa640
cmpb $0x0, 0x70(%r14)
jne 0x5491c
leaq 0xc(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
movq %rax, %rdi
jmp 0x54917
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0xa640
cmpb $0x0, 0x70(%r14)
jne 0x5491c
leaq 0xd(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
cmpq $0x0, 0xc8(%r14)
je 0x548c9
leaq 0xc0(%r14), %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0xa740
cmpq $-0x1, %rax
je 0x54906
movb $0x22, %bpl
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
movq 0xc0(%r14), %rsi
movq 0xc8(%r14), %rdx
movq %rbx, %rdi
callq 0xa640
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
jmp 0x54914
movq 0xc0(%r14), %rsi
movq 0xc8(%r14), %rdx
movq %rbx, %rdi
callq 0xa640
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Application::Key::getShortHelp[abi:cxx11]() const
string Application::Key::getShortHelp () const
{
	string acronymS;
	if (acronym)
	{
		acronymS = string ("-") + acronym;
		if (! flag)
			acronymS += " " + var;
		acronymS += ", ";
	}
  return acronymS + str ();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpb $0x0, 0x98(%rsi)
je 0x54a7c
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x375d5(%rip), %rsi     # 0x8bf44
leaq 0x375cf(%rip), %rdx     # 0x8bf45
leaq 0x48(%rsp), %rdi
callq 0x2fa1a
movsbl 0x98(%r14), %r8d
leaq 0x48(%rsp), %rdi
movq 0x8(%rdi), %rsi
movl $0x1, %ecx
xorl %edx, %edx
callq 0xaa80
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x549c4
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x549cc
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0xa6e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x54a0a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x54a21
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpb $0x0, 0x70(%r14)
jne 0x54a6b
leaq 0xa0(%r14), %rdx
leaq 0x39dc4(%rip), %rsi     # 0x8e7fa
leaq 0x8(%rsp), %rdi
callq 0x2bb6f
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0xa190
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x54a6b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x357a9(%rip), %rsi     # 0x8a21b
leaq 0x28(%rsp), %rdi
callq 0xaac0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2dcfe
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa620
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x54ac3
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x54ac9
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54afb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x54b12
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
jne 0x54b5e
jmp 0x54b70
jmp 0x54b6d
jmp 0x54b6d
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x54b70
movq 0x58(%rsp), %rsi
jmp 0x54b63
jmp 0x54b6d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54b70
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x54b70
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x54b87
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::Application::getFlag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool Application::getFlag (const string &name) const
{
  const string value (getArg (name));
  const Key* key = name2arg. at (name) -> asKey ();
  if (! key || ! key->flag)
    throw logic_error ("Parameter " + strQuote (name) + " is not a flag");
  return value == "true";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x59862
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rsi
callq 0x65986
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testq %rax, %rax
je 0x59a9a
cmpb $0x0, 0x70(%rax)
je 0x59a9a
leaq 0x367ad(%rip), %rsi     # 0x9020b
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0xa160
movl %eax, %ebx
movq (%r14), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x59a87
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
testl %ebx, %ebx
sete %al
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38a3a
leaq 0x34bd5(%rip), %rsi     # 0x8e695
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2bbf7
leaq 0x34bd8(%rip), %rsi     # 0x8e6ae
leaq 0x68(%rsp), %rdi
callq 0xaac0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x59b01
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x59b0e
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa840
xorl %ebp, %ebp
movq 0x56482(%rip), %rsi     # 0xaffc0
movq 0x56443(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x59b6f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x59b6f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59b8a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59ba5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x59bcf
jmp 0x59bdc
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59bcf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x59bcf
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
jmp 0x59bdc
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59bf7
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::ShellApplication::~ShellApplication()
ShellApplication::~ShellApplication ()
{
	if (! tmp. empty () && ! logPtr)
	  removeDirectory (tmp);

  if (startTime)
  {
    const time_t endTime = time (NULL);
    const OColor oc (cerr, Chronometer_OnePass::color, false, ! stderr. quiet);  
    stderr << programName << " took " << endTime - startTime << " seconds to complete\n";
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x4e767(%rip), %rax     # 0xaee20
movq %rax, (%rdi)
cmpq $0x0, 0x170(%rdi)
je 0x606fa
cmpq $0x0, 0x503ea(%rip)     # 0xb0ab8
jne 0x606fa
leaq 0x168(%rbx), %rsi
leaq 0x8(%rsp), %rdi
movl $0x2, %edx
callq 0x66efe
leaq 0x8(%rsp), %rdi
callq 0xaaf0
leaq 0x8(%rsp), %rdi
callq 0x66f7e
cmpq $0x0, 0x1c0(%rbx)
je 0x607a3
xorl %edi, %edi
callq 0xa550
movq %rax, %r14
movzbl 0x1b8(%rbx), %r8d
xorl $0x1, %r8d
movq 0x4f8bb(%rip), %rsi     # 0xaffe0
leaq 0x8(%rsp), %rdi
movl $0x23, %edx
xorl %ecx, %ecx
callq 0x2f4e2
leaq 0x1b8(%rbx), %r15
cmpb $0x0, (%r15)
jne 0x6075d
movq 0x5034e(%rip), %rsi     # 0xb0a98
movq 0x5034f(%rip), %rdx     # 0xb0aa0
movq 0x4f888(%rip), %rdi     # 0xaffe0
callq 0xa640
leaq 0x2e2b9(%rip), %rsi     # 0x8ea1d
movq %r15, %rdi
callq 0x65b0e
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x6078a
subq 0x1c0(%rbx), %r14
movq 0x4f85e(%rip), %rdi     # 0xaffe0
movq %r14, %rsi
callq 0xa560
leaq 0x2e293(%rip), %rsi     # 0x8ea24
movq %r15, %rdi
callq 0x65b42
leaq 0x8(%rsp), %rdi
callq 0x2f5bc
movb $0x0, 0x502c7(%rip)     # 0xb0a71
leaq 0x188(%rbx), %rdi
callq 0x2c320
movq 0x168(%rbx), %rdi
leaq 0x178(%rbx), %rax
cmpq %rax, %rdi
je 0x607d4
movq (%rax), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0x2c096
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x66f7e
jmp 0x607f8
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2c2a7
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/common.cpp
// Function: Common_sp::ShellApplication::getHelp[abi:cxx11](bool) const
string ShellApplication::getHelp (bool screen) const 
{
  string help (Application::getHelp (screen));
  if (useTmp)
    help += "\n\nTemporary directory used is $TMPDIR or \"/tmp\"";
  return help;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5aff2
cmpb $0x1, 0x160(%r14)
jne 0x610b0
leaq 0x2da7d(%rip), %rsi     # 0x8eb25
movq %rbx, %rdi
callq 0xaac0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x610d5
movq (%rbx), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Enumerate<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_t add (const T &t)
      { size_t num = find (t);
        if (num == no_index)
        { num2elem. push_back (t);
          num = num2elem. size () - 1;
          elem2num [t] = num;
        }
        return num;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x670a0
testq %rax, %rax
je 0x64b3d
movq 0x28(%rax), %r12
cmpq $-0x1, %r12
jne 0x64b64
movq %r15, %rdi
movq %rbx, %rsi
callq 0x309da
movq 0x8(%r15), %r12
subq (%r15), %r12
sarq $0x5, %r12
decq %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x671b8
movq %r12, (%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Token::type2str[abi:cxx11](Common_sp::Token::Type)
static string type2str (Type type) 
	  { switch (type)
	  	{ case eName:      return "name";
	  		case eText:      return "text";
	  		case eInteger:   return "integer";
	  		case eDouble:    return "double";
	  		case eDelimiter: return "delimiter";
	  		case eDateTime:  return "datetime";
	  	}
	  	throwf ("Token::type2str()");
	  	return noString;
	  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x5, %esi
ja 0x64d7e
movq %rdi, %rbx
movl %esi, %eax
leaq 0x27ada(%rip), %rcx     # 0x8c7b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2b5b5(%rip), %rsi     # 0x902a6
leaq 0x2b5b2(%rip), %rdx     # 0x902aa
jmp 0x64d6b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2a1c3(%rip), %rsi     # 0x8eecb
leaq 0x2a1c2(%rip), %rdx     # 0x8eed1
jmp 0x64d6b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x28c21(%rip), %rsi     # 0x8d940
leaq 0x28c1e(%rip), %rdx     # 0x8d944
jmp 0x64d6b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2a18d(%rip), %rsi     # 0x8eec3
leaq 0x2a18d(%rip), %rdx     # 0x8eeca
jmp 0x64d6b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x28fab(%rip), %rsi     # 0x8dcf8
leaq 0x28fad(%rip), %rdx     # 0x8dd01
jmp 0x64d6b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2a16e(%rip), %rsi     # 0x8eed2
leaq 0x2a16f(%rip), %rdx     # 0x8eeda
movq %rbx, %rdi
callq 0x2fa1a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2a14d(%rip), %rsi     # 0x8eedb
leaq 0x2a157(%rip), %rdx     # 0x8eeec
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2fa1a
movq %rbx, %rdi
callq 0x34fa2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x64dc4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::DataVersion::saveText(std::ostream&) const
void saveText (ostream &os) const final
    { os << year 
         << '-' << std::setfill ('0') << std::setw (2) << month 
         << '-' << std::setfill ('0') << std::setw (2) << day 
         << '.' << num; 
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0xa3e0
leaq 0xd(%rsp), %rsi
movb $0x2d, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xa640
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rcx
leaq (%r14,%rcx), %r15
cmpb $0x0, 0xe1(%r14,%rcx)
jne 0x663b8
movq %r15, %rdi
movl $0x20, %esi
callq 0xa570
movb $0x1, 0xe1(%r15)
movq (%r14), %rax
movb $0x30, 0xe0(%r15)
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r14,%rax)
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0xa3e0
leaq 0xe(%rsp), %rsi
movb $0x2d, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xa640
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rcx
leaq (%r14,%rcx), %r15
cmpb $0x0, 0xe1(%r14,%rcx)
jne 0x6641e
movq %r15, %rdi
movl $0x20, %esi
callq 0xa570
movb $0x1, 0xe1(%r15)
movq (%r14), %rax
movb $0x30, 0xe0(%r15)
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r14,%rax)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0xa3e0
leaq 0xf(%rsp), %rsi
movb $0x2e, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xa640
movl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0xa3e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::JsonDouble::saveText(std::ostream&) const
void saveText (ostream& os) const final
    { const ONumber on (os, (streamsize) decimals, scientific);
    	if (isfinite (n))
        os << n; 
      else
        os << "null";  // NaN
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %rax
movq (%rsi), %rcx
movq -0x18(%rcx), %rdx
movq 0x8(%rsi,%rdx), %r14
movl 0x18(%rsi,%rdx), %ebp
movl %ebp, %esi
andl $0xfffffefb, %esi       # imm = 0xFFFFFEFB
cmpb $0x0, 0x18(%rdi)
movl $0x100, %r8d            # imm = 0x100
movl $0x4, %r9d
cmovnel %r8d, %r9d
orl %esi, %r9d
movl %r9d, 0x18(%rbx,%rdx)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rbx,%rcx)
movq 0x8(%rdi), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x66bb6
leaq 0x2a017(%rip), %rsi     # 0x90bbe
movl $0x4, %edx
movq %rbx, %rdi
callq 0xa640
jmp 0x66bbe
movq %rbx, %rdi
callq 0xa910
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl %ebp, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq %r14, 0x8(%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rcx
movq -0x18(%rcx), %rdx
movl %ebp, 0x18(%rbx,%rdx)
movq -0x18(%rcx), %rcx
movq %r14, 0x8(%rbx,%rcx)
movq %rax, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/gff.cpp
// Function: GFF_sp::Locus::operator<(GFF_sp::Locus const&) const
bool Locus::operator< (const Locus& other) const
{ 
	LESS_PART (*this, other, contig)
  LESS_PART (*this, other, start)
  LESS_PART (*this, other, stop)
  LESS_PART (*this, other, strand)
//LESS_PART (*this, other, contigLen);
  LESS_PART (*this, other, crossOrigin);
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %r12
leaq 0x8(%rsi), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xa050
movb $0x1, %bl
testl %eax, %eax
js 0x7682a
movq %r13, %rdi
movq %r12, %rsi
callq 0xa050
testl %eax, %eax
js 0x76828
movq 0x28(%r15), %rax
movq 0x28(%r14), %rcx
cmpq %rcx, %rax
jb 0x7682a
jbe 0x76836
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x30(%r15), %rax
movq 0x30(%r14), %rcx
cmpq %rcx, %rax
jb 0x7682a
ja 0x76828
movb 0x38(%r15), %al
movb 0x38(%r14), %cl
cmpb %cl, %al
jb 0x7682a
ja 0x76828
movb 0x48(%r15), %al
cmpb 0x48(%r14), %al
setb %bl
jmp 0x7682a
jmp 0x76862
movq %rax, %rdi
callq 0x2c2a7
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/gff.cpp
// Function: GFF_sp::Gff::name2type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gff::Type Gff::name2type (const string &name)
{
  if (name == "bakta")          return bakta;
  if (name == "genbank")        return genbank;
  if (name == "microscope")     return microscope;
  if (name == "patric")         return patric;
  if (name == "pgap")           return pgap;
  if (name == "prodigal")       return prodigal;
  if (name == "prokka")         return prokka;
  if (name == "pseudomonasdb")  return pseudomonasdb;
  if (name == "rast")           return rast;
  if (name == "standard")       return standard;
  throw runtime_error ("Unknown GFF type: " + strQuote (name));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x1974b(%rip), %rsi     # 0x8ffc7
callq 0xa160
testl %eax, %eax
je 0x769b8
leaq 0x139b3(%rip), %rsi     # 0x8a243
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x769bc
leaq 0x19726(%rip), %rsi     # 0x8ffcd
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x769c3
leaq 0x1971a(%rip), %rsi     # 0x8ffd8
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x769ca
leaq 0x197e8(%rip), %rsi     # 0x900bd
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x769d1
leaq 0x197ae(%rip), %rsi     # 0x9009a
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x769d8
leaq 0x196dc(%rip), %rsi     # 0x8ffdf
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x769df
leaq 0x196cc(%rip), %rsi     # 0x8ffe6
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x769e6
leaq 0x196c3(%rip), %rsi     # 0x8fff4
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x769ed
leaq 0x196b1(%rip), %rsi     # 0x8fff9
movq %r14, %rdi
callq 0xa160
movl %eax, %ecx
movl $0x9, %eax
testl %ecx, %ecx
je 0x769f2
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38a3a
leaq 0x1967f(%rip), %rsi     # 0x90002
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x2bbf7
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x3963f(%rip), %rsi     # 0xaffe8
movq 0x395b0(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
xorl %eax, %eax
jmp 0x769f2
movl $0x1, %eax
jmp 0x769f2
movl $0x2, %eax
jmp 0x769f2
movl $0x3, %eax
jmp 0x769f2
movl $0x4, %eax
jmp 0x769f2
movl $0x5, %eax
jmp 0x769f2
movl $0x6, %eax
jmp 0x769f2
movl $0x7, %eax
jmp 0x769f2
movl $0x8, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76a19
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76a34
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
jne 0x76a5e
jmp 0x76a66
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76a5e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x76a5e
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/tsv.cpp
// Function: Common_sp::Date::operator-(Common_sp::Date const&) const
Date Date::operator- (const Date &other) const
{ 
  Date d ( short (year  - other. year)
         , char  (month - other. month)
         , char  (day   - other. day)
         );
  // Normalization 
  // day < 0 ??
  while (d. month < 0)
  {
    d. month = char (d. month + 12);
    d. year --;
  }
  return d;
}

// Assembly:
movq %rdi, %rax
movl 0x8(%rsi), %ecx
movl 0x8(%rdx), %edi
movb 0xa(%rsi), %r9b
movb 0xa(%rdx), %r8b
movb 0xb(%rsi), %sil
subb 0xb(%rdx), %sil
movl %r9d, %edx
subb %r8b, %dl
leaq 0x31540(%rip), %r10     # 0xafca0
movq %r10, (%rax)
movb %sil, 0xb(%rax)
js 0x7e76d
subl %edi, %ecx
jmp 0x7e7b8
movzbl %dl, %edx
cmpb $-0xb, %dl
movl $0xf4, %esi
cmovael %edx, %esi
addb %r8b, %sil
cmpb %r9b, %sil
setne %dl
leal (%r9,%rdx), %r10d
subb %r10b, %sil
movzbl %sil, %esi
imull $0xab, %esi, %esi
shrl $0xb, %esi
addb %dl, %sil
movzbl %sil, %esi
leal (,%rsi,4), %edx
leal (%rdx,%rdx,2), %edx
addb %r9b, %dl
subb %r8b, %dl
addb $0xc, %dl
notl %edi
addl %edi, %ecx
subl %esi, %ecx
movb %dl, 0xa(%rax)
movw %cx, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::saveText(std::ostream&) const
void TextTable::saveText (ostream &os) const
{ 
  if (saveHeader)
  { 
    if (pound)
      os << '#';
    bool first = true;
    for (const Header& h : header)
    {
      if (! first)
        os << '\t';
      os << h. name;
      first = false;
    }
    os << endl;
  }
  
  for (const StringVector& row : rows)
  {
    save (os, row, '\t');
    os << endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x29(%rdi)
jne 0x813fe
cmpb $0x1, 0x28(%r14)
jne 0x8138d
leaq 0xf(%rsp), %rsi
movb $0x23, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
movq 0x30(%r14), %r12
movq 0x38(%r14), %r13
cmpq %r13, %r12
je 0x813d7
movb $0x1, %al
leaq 0xe(%rsp), %r15
testb $0x1, %al
jne 0x813ba
movb $0x9, 0xe(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa640
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0xa640
subq $-0x80, %r12
xorl %eax, %eax
cmpq %r13, %r12
jne 0x813a1
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xa570
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3f0
movq 0x50(%r14), %r15
movq 0x58(%r14), %r14
cmpq %r14, %r15
je 0x81448
movq %rbx, %rdi
movq %r15, %rsi
movl $0x9, %edx
callq 0x86475
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xa570
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3f0
addq $0x20, %r15
jmp 0x81406
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::compare(Common_sp::StringVector const&, Common_sp::StringVector const&, unsigned long) const
int TextTable::compare (const StringVector& row1,
                        const StringVector& row2,
                        ColNum column) const
{
  const string& s1 = row1 [column];
  const string& s2 = row2 [column];

  if (header [column]. numeric)
  {
    const double a = strNull (s1) ? 0.0 : stod (s1);
    const double b = strNull (s2) ? 0.0 : stod (s2);
    if (a < b)
      return -1;
    if (a > b)
      return 1;
    return 0;
  }
  
  if (s1 < s2)
    return -1;
  if (s1 > s2)
    return 1;

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x2dfb8
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2dfb8
movq %rax, %rbx
addq $0x30, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8634e
cmpb $0x1, 0x30(%rax)
jne 0x8220b
movq %r14, %rdi
callq 0x8627d
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x8223a
movq (%r14), %r15
callq 0xa070
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xa460
cmpq %r15, (%r12)
je 0x822b7
movl (%r14), %eax
testl %eax, %eax
je 0x82237
cmpl $0x22, %eax
jne 0x8223a
leaq 0xe98b(%rip), %rdi      # 0x90b91
callq 0xa800
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa050
testl %eax, %eax
js 0x82230
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa050
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x822aa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x822aa
movl %ebp, (%r14)
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x8627d
testb %al, %al
xorpd %xmm0, %xmm0
jne 0x82290
movq (%rbx), %r14
callq 0xa070
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa460
cmpq %r14, (%r15)
je 0x822c3
movl (%rbx), %eax
testl %eax, %eax
je 0x8228e
cmpl $0x22, %eax
jne 0x82290
leaq 0xe908(%rip), %rdi      # 0x90b91
callq 0xa800
movl %ebp, (%rbx)
xorl %ecx, %ecx
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %cl
ucomisd %xmm1, %xmm0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe8d3(%rip), %rdi      # 0x90b91
callq 0xa360
leaq 0xe8c7(%rip), %rdi      # 0x90b91
callq 0xa360
jmp 0x822eb
cmpl $0x0, (%rbx)
jne 0x822e3
movl %ebp, (%rbx)
jmp 0x822e3
cmpl $0x0, (%r14)
jne 0x822e3
movl %ebp, (%r14)
movq %rax, %rdi
callq 0xaa10
movq %rax, %rdi
callq 0x2c2a7
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::sort(Common_sp::StringVector const&)
void TextTable::sort (const StringVector &by)
{
  const Vector<ColNum> byIndex (columns2nums (by));
  
  const auto lt = [&byIndex,this] (const StringVector &a, const StringVector &b) 
                    { for (const ColNum i : byIndex) 
                        switch (this->compare (a, b, i))
                        { case -1: return true;
                          case  1: return false;
                        }
                      // Tie resolution
                      FFOR (size_t, i, a. size ())
                        switch (this->compare (a, b, i))
                        { case -1: return true;
                          case  1: return false;
                        }
                      return false;
                    };
  Common_sp::sort (rows, lt);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x864f4
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r14
cmpq %r14, %r15
je 0x825d9
movq %r14, %r12
subq %r15, %r12
movq %r12, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r8
callq 0x85335
cmpq $0x201, %r12            # imm = 0x201
jl 0x825c6
leaq 0x200(%r15), %r12
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x85ea9
cmpq %r14, %r12
je 0x825d9
leaq 0x8(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x85fa7
addq $0x20, %r12
cmpq %r14, %r12
jne 0x825ad
jmp 0x825d9
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x85ea9
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x825f0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x825fe
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x82618
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::colNumsRow2values(Common_sp::Vector<unsigned long> const&, unsigned long, Common_sp::StringVector&) const
void TextTable::colNumsRow2values (const Vector<ColNum> &colNums,
                                   RowNum row_num,
                                   StringVector &values) const
{
  values. clear ();
  values. reserve (colNums. size ());
  const StringVector& row = rows [row_num];    
  FFOR (ColNum, i, colNums. size ())
    values << row [colNums [i]];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rcx), %rsi
movq %rcx, %rdi
callq 0x2fece
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x2fb76
addq $0x50, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x863e2
movq 0x8(%r14), %r13
subq (%r14), %r13
je 0x8444b
movq %rax, %r15
sarq $0x3, %r13
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x86854
movq (%rax), %rsi
movq %r15, %rdi
callq 0x2dfb8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x309da
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x84443
movb $0x0, 0x18(%rbx)
incq %r12
cmpq %r12, %r13
jne 0x84411
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::Index::Index(Common_sp::TextTable const&, Common_sp::StringVector const&)
TextTable::Index::Index (const TextTable &tab,
                         const StringVector &columns)
: colNums (tab. columns2nums (columns))
{
  data. rehash (tab. rows. size ());
  StringVector values;  
  FFOR (RowNum, i, tab. rows. size ())
  {
    tab. colNumsRow2values (colNums, i, values);
    data [values] << i;
  }  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x864f4
leaq 0x20(%rbx), %r14
leaq 0x50(%rbx), %rax
movq %rax, 0x20(%rbx)
movq $0x1, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movl $0x3f800000, 0x40(%rbx) # imm = 0x3F800000
movups %xmm0, 0x48(%rbx)
movq 0x58(%r15), %rsi
subq 0x50(%r15), %rsi
sarq $0x5, %rsi
movq %r14, %rdi
callq 0x8970c
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x58(%r15), %rbp
movq 0x50(%r15), %rax
subq %rax, %rbp
je 0x852e6
sarq $0x5, %rbp
xorl %edx, %edx
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0x843b4
movq %r14, %rdi
movq %r12, %rsi
callq 0x898d2
movq %rax, %rdi
movq %r13, %rsi
callq 0x868e8
movq 0x8(%rsp), %rdx
incq %rdx
movq %rdx, 0x8(%rsp)
cmpq %rbp, %rdx
jb 0x852b0
leaq 0x10(%rsp), %rdi
callq 0x327d2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x85311
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x327d2
movq %r14, %rdi
callq 0x87506
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8532d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xa5a0
movq %r15, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::strNull(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool strNull (const string &s)
  { if (strBlank (s))
      return true;
    string s1 (s);
    trim (s1);
    strUpper (s1);
    return    s1 == "NULL"
           || s1 == "NA"
           || s1 == "N/A";
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
callq 0x37f01
movb $0x1, %bl
testb %al, %al
jne 0x86320
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2c212
movq %rbx, %rdi
callq 0x37275
movq %rsp, %rdi
callq 0x384ed
movq %rsp, %rdi
callq 0x382e4
leaq 0xa8b3(%rip), %rsi      # 0x90b88
movq %rsp, %rdi
callq 0xa160
movb $0x1, %bl
testl %eax, %eax
je 0x8630a
leaq 0x5e51(%rip), %rsi      # 0x8c13b
movq %rsp, %rdi
callq 0xa160
testl %eax, %eax
je 0x8630a
leaq 0xa890(%rip), %rsi      # 0x90b8d
movq %rsp, %rdi
callq 0xa160
testl %eax, %eax
sete %bl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x86320
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x86345
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TextTable::columns2nums(Common_sp::StringVector const&) const
Vector<ColNum> columns2nums (const StringVector &columns) const
    { Vector<ColNum> nums;  nums. reserve (columns. size ());
      for (const string &s : columns)
        nums << col2num (s);
      return nums;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rdi)
movups %xmm0, (%rdi)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x5, %rsi
callq 0x8723c
movq (%r12), %r15
movq 0x8(%r12), %r13
cmpq %r13, %r15
je 0x8655b
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e9da
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x872d8
addq $0x20, %r15
cmpq %r13, %r15
jne 0x86537
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x8656e
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x86585
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>& Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
Vector<T>& operator<< (const vector<U> &other)
        { reserveInc (other. size ());
          P::insert (P::end (), other. begin (), other. end ());
          unsetSearchSorted ();
        	return *this;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x5, %rax
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x5, %rsi
addq %rax, %rsi
callq 0x2fb76
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %rdi
callq 0x88b5c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x86730
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::aggregate(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&, char)
inline void aggregate (string& aggregation,
                       const string &addition,
                       char aggr_sep)
  { StringVector vec (aggregation, aggr_sep, true);
    vec << addition;
    vec. sort ();
    vec. uniq ();
    aggregation = vec. toString (string (1, aggr_sep));
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x42b7e
movq %r15, %rdi
movq %r14, %rsi
callq 0x309da
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
cmpq $0x21, %rax
jb 0x86782
movb $0x0, 0x20(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x2fb24
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x307a8
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movsbl %bpl, %edx
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0xa670
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x400fe
leaq 0x48(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6e0
movq (%r14), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x867f5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x8680c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x8(%rsp), %rdi
callq 0x327d2
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x86842
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x86842
jmp 0x8683f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x327d2
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::Date::toJson(Common_sp::JsonContainer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
JsonMap* toJson (JsonContainer* parent, 
                   const string& name = noString) const override
    { auto j = new JsonMap (parent, name);
      new JsonInt (year,  j, "year");
      new JsonInt (month, j, "month");
      new JsonInt (day,   j, "day");
      return j;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x38, %edi
callq 0xa590
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e29e
leaq 0x27cc3(%rip), %rax     # 0xaecc0
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x10, %rax
movl $0x0, 0x10(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
movl $0x10, %edi
callq 0xa590
movq %rax, %r15
movswq 0x8(%r14), %rbp
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x9b32(%rip), %rsi      # 0x90b79
leaq 0x9b2f(%rip), %rdx      # 0x90b7d
leaq 0x8(%rsp), %rdi
callq 0x2fa1a
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4e29e
leaq 0x285d1(%rip), %r13     # 0xaf640
movq %r13, (%r15)
movq %rbp, 0x8(%r15)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8708d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movl $0x10, %edi
callq 0xa590
movq %rax, %r15
movsbq 0xa(%r14), %rbp
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x9ad0(%rip), %rsi      # 0x90b7e
leaq 0x9ace(%rip), %rdx      # 0x90b83
callq 0x2fa1a
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4e29e
movq %r13, (%r15)
movq %rbp, 0x8(%r15)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x870e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movl $0x10, %edi
callq 0xa590
movq %rax, %r15
movsbq 0xb(%r14), %r14
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x9a7b(%rip), %rsi      # 0x90b84
leaq 0x9a77(%rip), %rdx      # 0x90b87
callq 0x2fa1a
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4e29e
movq %r13, (%r15)
movq %r14, 0x8(%r15)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x87143
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8715d
jmp 0x87179
jmp 0x8715d
jmp 0x87179
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8717c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x8717c
movq %rax, %r14
movl $0x10, %esi
movq %r15, %rdi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
jmp 0x87184