LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::at(unsigned long) const
const Json* Json::at (size_t index) const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return nullptr;
  if (const JsonArray* j = asJsonArray ())
  {
    if (index >= j->data. size ())
      throw runtime_error (FUNC "Index out of range");
    else
      return j->data [index];
  }
  throw logic_error ("Not a JsonArray");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
je 0x4f8d1
xorl %eax, %eax
jmp 0x4f909
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
movq %rax, %r14
testq %rax, %rax
je 0x4f904
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
cmpq %rbx, %rax
jbe 0x4f948
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x65966
movq (%rax), %rax
jmp 0x4f904
testq %r14, %r14
je 0x4f916
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e495(%rip), %rsi     # 0x8ddbf
movq %rax, %rdi
callq 0xa7f0
movq 0x60687(%rip), %rsi     # 0xaffc0
movq 0x60648(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3e417(%rip), %rsi     # 0x8dd7c
leaq 0x3e43d(%rip), %rdx     # 0x8dda9
leaq 0x20(%rsp), %rdi
callq 0x2fdd8
leaq 0x3e42d(%rip), %rsi     # 0x8ddaa
leaq 0x20(%rsp), %rdi
callq 0xaac0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4f9aa
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x4f9b6
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x60604(%rip), %rsi     # 0xaffe8
movq 0x60575(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4fa14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x4fa14
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x4fa33
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x4fa33
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
jne 0x4fa3d
jmp 0x4fa45
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getSize() const
size_t Json::getSize () const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return 0;
  if (const JsonArray* j = asJsonArray ())
    return j->data. size ();
  throw logic_error ("Not a JsonArray");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x48(%rax)
testq %rax, %rax
je 0x4fa64
xorl %eax, %eax
jmp 0x4fa88
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq %rax, %rcx
testq %rax, %rax
je 0x4fa83
movq 0x10(%rcx), %rax
subq 0x8(%rcx), %rax
sarq $0x3, %rax
jmp 0x4fa83
testq %rcx, %rcx
je 0x4fa90
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3e31b(%rip), %rsi     # 0x8ddbf
movq %rax, %rdi
callq 0xa7f0
movq 0x6050d(%rip), %rsi     # 0xaffc0
movq 0x604ce(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/common.cpp
// Function: Common_sp::FileItemGenerator::next(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool FileItemGenerator::next (string &item)
{ 
  if (f. eof ())
    return false;
    
	readLine (f, item);
  if (! tsv)
    trim (item);
  if (item. empty () && f. eof ())
    return false;

  prog (item);
    
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x68(%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x88(%rdi,%rax)
jne 0x51a5c
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %r15
movq %r15, %rdi
callq 0x3f152
cmpb $0x0, 0x270(%r14)
jne 0x51a33
movq %rbx, %rdi
callq 0x374e6
movq %rbx, %rdi
callq 0x387de
cmpq $0x0, 0x8(%rbx)
jne 0x51a49
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r15,%rax)
jne 0x51a5c
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40ee8
movb $0x1, %al
jmp 0x51a5e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ce14(%rip), %rax     # 0xaf200
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 0x42b16
movq 0x8(%r15), %rax
subq (%r15), %rax
cmpq $0x20, %rax
jne 0x52453
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x2e7a8
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x52556
leaq 0x68(%rsp), %rdi
callq 0x32c12
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 0x2c652
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2cefd
leaq 0x3bb8e(%rip), %rsi     # 0x8e021
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2c037
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x5db2d(%rip), %rsi     # 0xaffe8
movq 0x5da9e(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x524f0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x524f0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52513
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x52513
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x52532
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x52532
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x52544
movq %rbx, %rdi
callq 0xa440
jmp 0x52544
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x32c12
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x394d9
leaq 0x8(%rsp), %rdi
callq 0x2f13b
movl %eax, 0x8(%rbx)
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x5259f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
testb %bpl, %bpl
je 0x525b1
movq %r14, %rdi
callq 0x2f13b
movl %eax, 0xc(%rbx)
jmp 0x525f2
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x2e, %edx
callq 0x394d9
leaq 0x8(%rsp), %rdi
callq 0x2f13b
movl %eax, 0xc(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x525e7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0x2f13b
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 0x52621
jmp 0x52633
jmp 0x52630
jmp 0x52630
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52633
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x52633
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa240
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3ba13(%rip), %rsi     # 0x8e062
movq %rax, %rdi
callq 0xa230
movq 0x5d98a(%rip), %rsi     # 0xaffe8
movq 0x5d8fb(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
jmp 0x5267d
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
callq 0xa960
movq %r14, %rdi
callq 0xaa10
movq %rax, %rdi
callq 0x2c6e2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5caf2(%rip), %rax     # 0xaf258
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x68(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movl $0x1, %ecx
callq 0x42b16
movq 0x8(%r15), %rax
subq (%r15), %rax
cmpq $0x20, %rax
jne 0x527c3
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x2e7a8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x528c6
leaq 0x68(%rsp), %rdi
callq 0x32c12
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 0x2c652
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2cefd
leaq 0x3b87c(%rip), %rsi     # 0x8e07f
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2c037
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x5d7bd(%rip), %rsi     # 0xaffe8
movq 0x5d72e(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52860
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x52860
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52883
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x52883
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x528a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x528a2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x528b4
movq %rbx, %rdi
callq 0xa440
jmp 0x528b4
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x32c12
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x394d9
movq %rsp, %rdi
callq 0x2f13b
movl %eax, 0x8(%rbx)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x52908
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rsp, %rdi
movq %r14, %rsi
movl $0x2d, %edx
callq 0x394d9
movq %rsp, %rdi
callq 0x2f13b
movl %eax, 0xc(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x52939
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rsp, %rdi
movq %r14, %rsi
movl $0x2e, %edx
callq 0x394d9
movq %rsp, %rdi
callq 0x2f13b
movl %eax, 0x10(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5296a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0x2f13b
movl %eax, 0x14(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x529b5
jmp 0x52985
jmp 0x529b5
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x529a6
jmp 0x529b8
jmp 0x529b5
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x529b8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x529b8
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa240
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
leaq 0x3b6e8(%rip), %rsi     # 0x8e0bc
movq %rax, %rdi
callq 0xa230
movq 0x5d605(%rip), %rsi     # 0xaffe8
movq 0x5d576(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
jmp 0x52a02
movq %rax, %r14
movq %rbx, %rdi
callq 0xa440
callq 0xa960
movq %r14, %rdi
callq 0xaa10
movq %rax, %rdi
callq 0x2c6e2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52ab6
jbe 0x52ab7
xorl %eax, %eax
retq
movl 0xc(%rdi), %ecx
movl 0xc(%rsi), %edx
cmpl %edx, %ecx
jb 0x52ab6
ja 0x52ab4
movl 0x10(%rdi), %ecx
movl 0x10(%rsi), %edx
cmpl %edx, %ecx
jb 0x52ab6
ja 0x52ab4
movl 0x14(%rdi), %eax
cmpl 0x14(%rsi), %eax
setb %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x54d1c
leaq 0x3727b(%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 0x54dc2
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 0x54dbd
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0xa640
cmpb $0x0, 0x70(%r14)
jne 0x54dc2
leaq 0xd(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa640
cmpq $0x0, 0xc8(%r14)
je 0x54d6f
leaq 0xc0(%r14), %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0xa740
cmpq $-0x1, %rax
je 0x54dac
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 0x54dba
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_O1/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 0x54f22
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x3712f(%rip), %rsi     # 0x8bf44
leaq 0x37129(%rip), %rdx     # 0x8bf45
leaq 0x48(%rsp), %rdi
callq 0x2fdd8
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 0x54e6a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x54e72
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 0x54eb0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x54ec7
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
cmpb $0x0, 0x70(%r14)
jne 0x54f11
leaq 0xa0(%r14), %rdx
leaq 0x39934(%rip), %rsi     # 0x8e810
leaq 0x8(%rsp), %rdi
callq 0x2bfaf
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0xa190
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x54f11
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
leaq 0x35303(%rip), %rsi     # 0x8a21b
leaq 0x28(%rsp), %rdi
callq 0xaac0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2e11e
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 0x54f69
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x54f6f
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 0x54fa1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x54fb8
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 0x55004
jmp 0x55016
jmp 0x55013
jmp 0x55013
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x55016
movq 0x58(%rsp), %rsi
jmp 0x55009
jmp 0x55013
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55016
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x55016
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x5502d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x59d34
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rsi
callq 0x65dbe
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testq %rax, %rax
je 0x59f58
cmpb $0x0, 0x70(%rax)
je 0x59f58
leaq 0x362ef(%rip), %rsi     # 0x9020b
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xa160
movl %eax, %ebx
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x59f45
movq 0x38(%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 0x48(%rsp), %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38d2b
leaq 0x3472d(%rip), %rsi     # 0x8e6ab
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x2c037
leaq 0x34730(%rip), %rsi     # 0x8e6c4
leaq 0x68(%rsp), %rdi
callq 0xaac0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x59fbf
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x59fcc
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xa840
xorl %ebp, %ebp
movq 0x55fc4(%rip), %rsi     # 0xaffc0
movq 0x55f85(%rip), %rdx     # 0xaff88
movq %rbx, %rdi
callq 0xa9b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5a02d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x5a02d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a050
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x5a050
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a073
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x5a073
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5a085
movq %rbx, %rdi
callq 0xa440
jmp 0x5a085
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a0a0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/common.cpp
// Function: Common_sp::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 0x4e25f(%rip), %rax     # 0xaede0
movq %rax, (%rdi)
cmpq $0x0, 0x170(%rdi)
je 0x60bc2
cmpq $0x0, 0x4ff22(%rip)     # 0xb0ab8
jne 0x60bc2
leaq 0x168(%rbx), %rsi
leaq 0x8(%rsp), %rdi
movl $0x2, %edx
callq 0x67358
leaq 0x8(%rsp), %rdi
callq 0xaaf0
leaq 0x8(%rsp), %rdi
callq 0x673d8
cmpq $0x0, 0x1c0(%rbx)
je 0x60c6b
xorl %edi, %edi
callq 0xa550
movq %rax, %r14
movzbl 0x1b8(%rbx), %r8d
xorl $0x1, %r8d
movq 0x4f3f3(%rip), %rsi     # 0xaffe0
leaq 0x8(%rsp), %rdi
movl $0x23, %edx
xorl %ecx, %ecx
callq 0x2f8a0
leaq 0x1b8(%rbx), %r15
cmpb $0x0, (%r15)
jne 0x60c25
movq 0x4fe86(%rip), %rsi     # 0xb0a98
movq 0x4fe87(%rip), %rdx     # 0xb0aa0
movq 0x4f3c0(%rip), %rdi     # 0xaffe0
callq 0xa640
leaq 0x2de07(%rip), %rsi     # 0x8ea33
movq %r15, %rdi
callq 0x65f4a
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x60c52
subq 0x1c0(%rbx), %r14
movq 0x4f396(%rip), %rdi     # 0xaffe0
movq %r14, %rsi
callq 0xa560
leaq 0x2dde1(%rip), %rsi     # 0x8ea3a
movq %r15, %rdi
callq 0x65f7e
leaq 0x8(%rsp), %rdi
callq 0x2f97a
movb $0x0, 0x4fdff(%rip)     # 0xb0a71
leaq 0x188(%rbx), %rdi
callq 0x2c75c
movq 0x168(%rbx), %rdi
leaq 0x178(%rbx), %rax
cmpq %rax, %rdi
je 0x60c9c
movq (%rax), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0x2c4d6
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x673d8
jmp 0x60cc0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2c6e2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b48a
cmpb $0x1, 0x160(%r14)
jne 0x61574
leaq 0x2d5cf(%rip), %rsi     # 0x8eb3b
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 0x61599
movq (%rbx), %rsi
incq %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x674f8
testq %rax, %rax
je 0x64f8f
movq 0x28(%rax), %r12
jmp 0x64f96
movq $-0x1, %r12
cmpq $-0x1, %r12
jne 0x64fc3
movq %r15, %rdi
movq %rbx, %rsi
callq 0x30dca
movq 0x8(%r15), %r12
subq (%r15), %r12
sarq $0x5, %r12
decq %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67610
movq %r12, (%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./common.hpp
// Function: Common_sp::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 0x651dc
movq %rdi, %rbx
movl %esi, %eax
leaq 0x2767c(%rip), %rcx     # 0x8c7b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2b157(%rip), %rsi     # 0x902a6
leaq 0x2b154(%rip), %rdx     # 0x902aa
jmp 0x651c9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x29d7b(%rip), %rsi     # 0x8eee1
leaq 0x29d7a(%rip), %rdx     # 0x8eee7
jmp 0x651c9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x287d9(%rip), %rsi     # 0x8d956
leaq 0x287d6(%rip), %rdx     # 0x8d95a
jmp 0x651c9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x29d45(%rip), %rsi     # 0x8eed9
leaq 0x29d45(%rip), %rdx     # 0x8eee0
jmp 0x651c9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x28b63(%rip), %rsi     # 0x8dd0e
leaq 0x28b65(%rip), %rdx     # 0x8dd17
jmp 0x651c9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x29d26(%rip), %rsi     # 0x8eee8
leaq 0x29d27(%rip), %rdx     # 0x8eef0
movq %rbx, %rdi
callq 0x2fdd8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x29d05(%rip), %rsi     # 0x8eef1
leaq 0x29d0f(%rip), %rdx     # 0x8ef02
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2fdd8
movq %rbx, %rdi
callq 0x3523b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x65222
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./common.hpp
// Function: Common_sp::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), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0x66802
movq %r15, %rdi
movl $0x20, %esi
callq 0xa570
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq (%r14), %rax
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), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0x6686f
movq %r15, %rdi
movl $0x20, %esi
callq 0xa570
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq (%r14), %rax
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_O1/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 0x67010
leaq 0x29bbd(%rip), %rsi     # 0x90bbe
movl $0x4, %edx
movq %rbx, %rdi
callq 0xa640
jmp 0x67018
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_O1/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 0x76b72
movq %r13, %rdi
movq %r12, %rsi
callq 0xa050
testl %eax, %eax
js 0x76b70
movq 0x28(%r15), %rax
movq 0x28(%r14), %rcx
cmpq %rcx, %rax
jb 0x76b72
jbe 0x76b7e
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 0x76b72
ja 0x76b70
movb 0x38(%r15), %al
movb 0x38(%r14), %cl
cmpb %cl, %al
jb 0x76b72
ja 0x76b70
movb 0x48(%r15), %al
cmpb 0x48(%r14), %al
setb %bl
jmp 0x76b72
jmp 0x76baa
movq %rax, %rdi
callq 0x2c6e2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19403(%rip), %rsi     # 0x8ffc7
callq 0xa160
testl %eax, %eax
je 0x76d00
leaq 0x1366b(%rip), %rsi     # 0x8a243
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x76d04
leaq 0x193de(%rip), %rsi     # 0x8ffcd
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x76d0b
leaq 0x193d2(%rip), %rsi     # 0x8ffd8
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x76d12
leaq 0x194a0(%rip), %rsi     # 0x900bd
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x76d19
leaq 0x19466(%rip), %rsi     # 0x9009a
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x76d20
leaq 0x19394(%rip), %rsi     # 0x8ffdf
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x76d27
leaq 0x19384(%rip), %rsi     # 0x8ffe6
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x76d2e
leaq 0x1937b(%rip), %rsi     # 0x8fff4
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x76d35
leaq 0x19369(%rip), %rsi     # 0x8fff9
movq %r14, %rdi
callq 0xa160
movl %eax, %ecx
movl $0x9, %eax
testl %ecx, %ecx
je 0x76d3a
movl $0x10, %edi
callq 0xa2c0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x38d2b
leaq 0x19337(%rip), %rsi     # 0x90002
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x2c037
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xa930
xorl %ebp, %ebp
movq 0x392f7(%rip), %rsi     # 0xaffe8
movq 0x39268(%rip), %rdx     # 0xaff60
movq %rbx, %rdi
callq 0xa9b0
xorl %eax, %eax
jmp 0x76d3a
movl $0x1, %eax
jmp 0x76d3a
movl $0x2, %eax
jmp 0x76d3a
movl $0x3, %eax
jmp 0x76d3a
movl $0x4, %eax
jmp 0x76d3a
movl $0x5, %eax
jmp 0x76d3a
movl $0x6, %eax
jmp 0x76d3a
movl $0x7, %eax
jmp 0x76d3a
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 0x76d69
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x76d69
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76d8c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
jmp 0x76d8c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x76d99
movq %rbx, %rdi
callq 0xa440
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %ecx, %r9d
subl %edi, %r9d
movb 0xa(%rsi), %r8b
movb 0xb(%rsi), %r10b
subb 0xb(%rdx), %r10b
movb 0xa(%rdx), %dl
movl %r8d, %esi
subb %dl, %sil
leaq 0x31273(%rip), %r11     # 0xafca0
movq %r11, (%rax)
movw %r9w, 0x8(%rax)
movb %sil, 0xa(%rax)
movb %r10b, 0xb(%rax)
jns 0x7ea94
movzbl %sil, %r9d
cmpb $-0xb, %sil
movl $0xf4, %esi
cmovgel %r9d, %esi
addb %dl, %sil
cmpb %r8b, %sil
setne %r9b
leal (%r8,%r9), %r10d
subb %r10b, %sil
movzbl %sil, %esi
imull $0xab, %esi, %esi
shrl $0xb, %esi
addb %r9b, %sil
movzbl %sil, %r9d
leal (,%r9,4), %esi
leal (%rsi,%rsi,2), %esi
addb %r8b, %sil
subb %dl, %sil
addb $0xc, %sil
notl %edi
addl %edi, %ecx
subl %r9d, %ecx
movl %ecx, %r9d
movb %sil, 0xa(%rax)
movw %r9w, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81570
cmpb $0x1, 0x28(%r14)
jne 0x814ff
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 0x81549
movb $0x1, %al
leaq 0xe(%rsp), %r15
testb $0x1, %al
jne 0x8152c
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 0x81513
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 0x815ba
movq %rbx, %rdi
movq %r15, %rsi
movl $0x9, %edx
callq 0x864f3
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 0x81578
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e3d8
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e3d8
movq %rax, %rbx
addq $0x30, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x863cc
cmpb $0x1, 0x30(%rax)
jne 0x823af
movq %r14, %rdi
callq 0x862fb
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x823de
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 0x8245b
movl (%r14), %eax
testl %eax, %eax
je 0x823db
cmpl $0x22, %eax
jne 0x823de
leaq 0xe7e7(%rip), %rdi      # 0x90b91
callq 0xa800
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa050
testl %eax, %eax
js 0x823d4
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa050
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x8244e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x8244e
movl %ebp, (%r14)
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x862fb
testb %al, %al
xorpd %xmm0, %xmm0
jne 0x82434
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 0x82467
movl (%rbx), %eax
testl %eax, %eax
je 0x82432
cmpl $0x22, %eax
jne 0x82434
leaq 0xe764(%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 0xe72f(%rip), %rdi      # 0x90b91
callq 0xa360
leaq 0xe723(%rip), %rdi      # 0x90b91
callq 0xa360
jmp 0x8248f
cmpl $0x0, (%rbx)
jne 0x82487
movl %ebp, (%rbx)
jmp 0x82487
cmpl $0x0, (%r14)
jne 0x82487
movl %ebp, (%r14)
movq %rax, %rdi
callq 0xaa10
movq %rax, %rdi
callq 0x2c6e2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x86572
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r14
cmpq %r14, %r15
je 0x8277b
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 0x85406
cmpq $0x201, %r12            # imm = 0x201
jl 0x82768
leaq 0x200(%r15), %r12
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x85edd
cmpq %r14, %r12
je 0x8277b
leaq 0x8(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x86039
addq $0x20, %r12
cmpq %r14, %r12
jne 0x8274f
jmp 0x8277b
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x85edd
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x82792
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x827a0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x827ba
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3027e
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x2ff2e
addq $0x50, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x86460
movq 0x8(%r14), %r13
subq (%r14), %r13
je 0x8453d
movq %rax, %r15
sarq $0x3, %r13
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x868c6
movq (%rax), %rsi
movq %r15, %rdi
callq 0x2e3d8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30dca
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x84535
movb $0x0, 0x18(%rbx)
incq %r12
cmpq %r12, %r13
jne 0x84503
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x86572
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 0x89796
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x58(%r15), %rbp
subq 0x50(%r15), %rbp
sarq $0x5, %rbp
je 0x853b7
xorl %edx, %edx
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0x844a6
movq %r14, %rdi
movq %r12, %rsi
callq 0x89962
movq %rax, %rdi
movq %r13, %rsi
callq 0x8695a
movq 0x8(%rsp), %rdx
incq %rdx
movq %rdx, 0x8(%rsp)
cmpq %rbp, %rdx
jb 0x85381
leaq 0x10(%rsp), %rdi
callq 0x32c12
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x853e2
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x32c12
movq %r14, %rdi
callq 0x875b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x853fe
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xa5a0
movq %r15, %rdi
callq 0xaa10
// File: /workspace/github_cpp_makefile_star2_O1/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 0x381c2
movb $0x1, %bl
testb %al, %al
jne 0x8639e
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 0x2c652
movq %rbx, %rdi
callq 0x374e6
movq %rsp, %rdi
callq 0x387de
movq %rsp, %rdi
callq 0x385b9
leaq 0xa835(%rip), %rsi      # 0x90b88
movq %rsp, %rdi
callq 0xa160
movb $0x1, %bl
testl %eax, %eax
je 0x86388
leaq 0x5dd3(%rip), %rsi      # 0x8c13b
movq %rsp, %rdi
callq 0xa160
testl %eax, %eax
je 0x86388
leaq 0xa812(%rip), %rsi      # 0x90b8d
movq %rsp, %rdi
callq 0xa160
testl %eax, %eax
sete %bl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x8639e
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 0x863c3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5a0
movq %rbx, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x872ec
movq (%r12), %r15
movq 0x8(%r12), %r13
cmpq %r13, %r15
je 0x865d9
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2edd4
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x87382
addq $0x20, %r15
cmpq %r13, %r15
jne 0x865b5
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x865ec
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x86603
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xa5a0
movq %r14, %rdi
callq 0xaa10
nop
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>& 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 0x2ff2e
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %rdi
callq 0x88be2
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x867a2
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq