LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0xca10
movq 0x18(%rsp), %rax
cmpb $0x0, 0x98(%rax)
je 0x62f05
leaq 0x77(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xcd00
movq (%rsp), %rdx
leaq 0x6a127(%rip), %rsi     # 0xccf00
leaq 0x78(%rsp), %rdi
callq 0x29fd0
jmp 0x62de5
movq 0x18(%rsp), %rax
movsbl 0x98(%rax), %edx
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x739e0
jmp 0x62e05
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xc8f0
leaq 0x98(%rsp), %rdi
callq 0xce98
leaq 0x78(%rsp), %rdi
callq 0xce98
leaq 0x77(%rsp), %rdi
callq 0xc7a0
movq 0x18(%rsp), %rax
testb $0x1, 0x70(%rax)
jne 0x62eed
movq 0x18(%rsp), %rdx
addq $0xa0, %rdx
leaq 0x6cad1(%rip), %rsi     # 0xcf92e
leaq 0x40(%rsp), %rdi
callq 0x2a1c0
jmp 0x62e69
leaq 0xb8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xc960
jmp 0x62e7d
leaq 0x40(%rsp), %rdi
callq 0xce98
jmp 0x62eed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x62eb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xce98
leaq 0x77(%rsp), %rdi
callq 0xc7a0
jmp 0x62f6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x62f6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce98
jmp 0x62f6b
leaq 0x68312(%rip), %rsi     # 0xcb206
leaq 0xb8(%rsp), %rdi
callq 0xc6e0
jmp 0x62f03
jmp 0x62f05
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2ee30
jmp 0x62f16
movq 0x8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x765c0
jmp 0x62f2f
leaq 0x20(%rsp), %rdi
callq 0xce98
leaq 0xb8(%rsp), %rdi
callq 0xce98
movq 0x10(%rsp), %rax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xce98
leaq 0xb8(%rsp), %rdi
callq 0xce98
movq 0x68(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0xc8(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
callq 0x68600
movq 0x18(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq 0xc8(%rsp), %rsi
callq 0x77040
movq %rax, 0x20(%rsp)
jmp 0x687e9
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x68801
movq 0x10(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpq $0x0, 0xa0(%rsp)
je 0x6882b
movq 0xa0(%rsp), %rax
testb $0x1, 0x70(%rax)
jne 0x6895d
movb $0x1, 0x2f(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, 0x8(%rsp)
movq 0xc8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movl $0x22, %edx
callq 0x424f0
jmp 0x68858
leaq 0x66f6a(%rip), %rsi     # 0xcf7c9
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x2a340
jmp 0x68870
leaq 0x66f6b(%rip), %rdx     # 0xcf7e2
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2a2f0
jmp 0x68888
movq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xcad0
jmp 0x68899
movq 0x8(%rsp), %rdi
movb $0x0, 0x2f(%rsp)
movq 0x9d71e(%rip), %rsi     # 0x105fc8
movq 0x9d6cf(%rip), %rdx     # 0x105f80
callq 0xcc80
jmp 0x689ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x68992
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x68948
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x6893e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x68934
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xce98
leaq 0x50(%rsp), %rdi
callq 0xce98
leaq 0x30(%rsp), %rdi
callq 0xce98
testb $0x1, 0x2f(%rsp)
jne 0x68951
jmp 0x6895b
movq 0x8(%rsp), %rdi
callq 0xc580
jmp 0x68992
leaq 0x6896f(%rip), %rsi     # 0xd12d3
leaq 0xa8(%rsp), %rdi
callq 0x2e1b0
movb %al, 0x7(%rsp)
jmp 0x68977
leaq 0xa8(%rsp), %rdi
callq 0xce98
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
leaq 0xa8(%rsp), %rdi
callq 0xce98
movq 0x98(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x952e6(%rip), %rax     # 0x104bb0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x168, %rdi            # imm = 0x168
callq 0xcc10
testb $0x1, %al
jne 0x6f900
cmpq $0x0, 0x9738f(%rip)     # 0x106c78
jne 0x6f900
movq 0x28(%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
callq 0x77660
jmp 0x6f8fe
jmp 0x6f900
movq 0x28(%rsp), %rax
cmpq $0x0, 0x1c0(%rax)
je 0x6f9dc
xorl %eax, %eax
movl %eax, 0x24(%rsp)
movl %eax, %edi
callq 0xc6c0
movl 0x24(%rsp), %ecx
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq %rdx, 0x48(%rsp)
movb 0x1b8(%rax), %al
notb %al
movzbl %al, %r8d
andl $0x1, %r8d
movq 0x966a0(%rip), %rsi     # 0x105fe8
leaq 0x38(%rsp), %rdi
movl $0x23, %edx
callq 0x30fc0
jmp 0x6f959
movq 0x28(%rsp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
leaq 0x972ec(%rip), %rsi     # 0x106c58
callq 0x2da80
movq %rax, 0x18(%rsp)
jmp 0x6f978
movq 0x18(%rsp), %rdi
leaq 0x601cd(%rip), %rsi     # 0xcfb51
callq 0x776c0
movq %rax, 0x10(%rsp)
jmp 0x6f990
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x48(%rsp), %rax
movq 0x1c0(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x77710
movq %rax, 0x8(%rsp)
jmp 0x6f9bf
movq 0x8(%rsp), %rdi
leaq 0x6018d(%rip), %rsi     # 0xcfb58
callq 0x77770
jmp 0x6f9d2
leaq 0x38(%rsp), %rdi
callq 0x310f0
movq 0x28(%rsp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
callq 0x777c0
movq 0x28(%rsp), %rdi
addq $0x188, %rdi            # imm = 0x188
callq 0x2a910
movq 0x28(%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
callq 0xce98
movq 0x28(%rsp), %rdi
callq 0x2a920
addq $0x58, %rsp
retq
movq %rax, %rdi
callq 0x2ad70
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movb $0x0, 0x36(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x69c30
movq 0x18(%rsp), %rax
testb $0x1, 0x160(%rax)
je 0x7029d
movq 0x8(%rsp), %rdi
leaq 0x5f9df(%rip), %rsi     # 0xcfc59
callq 0xc6e0
jmp 0x70281
jmp 0x7029d
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xce98
jmp 0x702bd
movb $0x1, 0x36(%rsp)
testb $0x1, 0x36(%rsp)
jne 0x702b3
movq 0x8(%rsp), %rdi
callq 0xce98
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::ONumber::ONumber(std::ostream&, long, bool)
ONumber (ostream &o_arg,
	         streamsize precision,
	         bool scientific_arg)
	  : o (o_arg)
	  , prec_old (o. precision ())
	  , flags_old (o. flags ())
	  { if (scientific_arg)
	  	  o << scientific;
	  	else
	  		o << fixed;
      o. precision (precision);
	  }

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x78260
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x78270
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
testb $0x1, 0xf(%rsp)
je 0x7347a
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x4e0d(%rip), %rsi      # 0x78280
callq 0xc250
jmp 0x7348d
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x4e18(%rip), %rsi      # 0x782a0
callq 0xc250
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x782c0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::uchar2hex[abi:cxx11](unsigned char)
inline string uchar2hex (uchar c)
  { constexpr char hex [16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    string res ("  ");
    res [0] = hex [c / 16];
    res [1] = hex [c % 16];
    return res;
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x28(%rsp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movb %al, 0x6f(%rsp)
movaps 0x5a23c(%rip), %xmm0    # 0xcd820
movaps %xmm0, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
leaq 0x4e(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xcd00
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x5c31f(%rip), %rsi     # 0xcf92d
callq 0x29fd0
jmp 0x73615
leaq 0x4e(%rsp), %rdi
callq 0xc7a0
movq 0x28(%rsp), %rdi
movzbl 0x6f(%rsp), %eax
shrl $0x4, %eax
movb 0x50(%rsp,%rax), %al
movb %al, 0x17(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xce50
movq %rax, 0x18(%rsp)
jmp 0x73644
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movb 0x17(%rsp), %cl
movb %cl, (%rax)
movzbl 0x6f(%rsp), %eax
andl $0xf, %eax
movb 0x50(%rsp,%rax), %al
movb %al, 0x7(%rsp)
movl $0x1, %esi
callq 0xce50
movq %rax, 0x8(%rsp)
jmp 0x73675
movq 0x8(%rsp), %rax
movb 0x7(%rsp), %cl
movb %cl, (%rax)
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x736cc
jmp 0x736c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4e(%rsp), %rdi
callq 0xc7a0
jmp 0x736d6
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0xce98
jmp 0x736d6
movq 0x28(%rsp), %rdi
callq 0xce98
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xccf0
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::popBack()
T popBack ()
      { if (P::empty ())
          throw runtime_error ("popBack() empty list");
        const T t = P::back ();
        P::pop_back ();
        return t;
      }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x321f0
testb $0x1, %al
jne 0x73f70
jmp 0x73fc5
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x5c0b3(%rip), %rsi     # 0xd003f
callq 0xc2e0
jmp 0x73f93
movq 0x8(%rsp), %rdi
movq 0x92051(%rip), %rsi     # 0x105ff0
movq 0x91fca(%rip), %rdx     # 0x105f70
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xc580
jmp 0x7400b
movq 0x20(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
callq 0x7baa0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xc320
movq 0x20(%rsp), %rdi
callq 0x7bae0
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0x74001
movq 0x10(%rsp), %rdi
callq 0xce98
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x7bec0
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x10(%rsp)
jne 0x74644
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x351f0
movq 0x8(%rsp), %rdi
callq 0x2f390
movq 0x8(%rsp), %rdi
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
callq 0x7bf10
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Json const* Common_sp::findPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Common_sp::Json, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Common_sp::Json const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Common_sp::Json const*>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Value* findPtr (const map <Key, const Value* /*!nullptr*/> &m,
                        const KeyParent& key)
    { const Value* value;
      if (find (m, key, value))
        return value;
      return nullptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xa61b0
testb $0x1, %al
jne 0x75d18
jmp 0x75d24
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x75d2d
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::getDirName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline string getDirName (const string &path)  
  { const size_t pos = path. rfind ('/');
  	if (pos == string::npos)
  		return noString;
  	return path. substr (0, pos + 1);
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0xce30
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x10(%rsp)
jne 0x771af
movq (%rsp), %rdi
leaq 0x8faf0(%rip), %rsi     # 0x106c98
callq 0xc320
jmp 0x771ca
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
addq $0x1, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xc740
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ncbi[P]amr/./common.hpp
// Function: bool Common_sp::find<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool find (const map <Key, Value> &m,
             const KeyParent& key,
             Value &value)
    // Return: success
    // Output: value, if Return
    { const auto& it = m. find (key);
    	if (it == m. end ())
    		return false;
    	value = it->second; 
    	return true;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xab680
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xab6d0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0xab6b0
testb $0x1, %al
jne 0x779cf
jmp 0x779d6
movb $0x0, 0x47(%rsp)
jmp 0x779f6
movq 0x20(%rsp), %rdi
callq 0xab700
movq %rax, %rsi
addq $0x20, %rsi
movq 0x28(%rsp), %rdi
callq 0xc080
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl 0x8(%rax), %esi
callq 0xc9d0
movq %rax, %rdi
movl $0x2d, %esi
callq 0xc870
movq %rax, (%rsp)
movl $0x30, %edi
callq 0xabc90
movq (%rsp), %rdi
movb %al, 0x37(%rsp)
movzbl 0x37(%rsp), %esi
callq 0xcb60
movq %rax, 0x8(%rsp)
movl $0x2, %edi
callq 0xabcb0
movq 0x8(%rsp), %rdi
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %esi
callq 0xc840
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0xc(%rax), %esi
callq 0xc9d0
movq %rax, %rdi
movl $0x2d, %esi
callq 0xc870
movq %rax, 0x10(%rsp)
movl $0x30, %edi
callq 0xabc90
movq 0x10(%rsp), %rdi
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %esi
callq 0xcb60
movq %rax, 0x18(%rsp)
movl $0x2, %edi
callq 0xabcb0
movq 0x18(%rsp), %rdi
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
callq 0xc840
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x10(%rax), %esi
callq 0xc9d0
movq %rax, %rdi
movl $0x2e, %esi
callq 0xc870
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x14(%rax), %esi
callq 0xc9d0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
movq 0x10(%rax), %rdx
movzbl 0x18(%rax), %ecx
andl $0x1, %ecx
leaq 0x20(%rsp), %rdi
callq 0x73400
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
callq 0x79a70
movb %al, 0x13(%rsp)
jmp 0x799a7
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x799b1
jmp 0x799e3
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rdi
movsd 0x8(%rax), %xmm0
callq 0xcdd0
jmp 0x799c7
jmp 0x799f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x734b0
jmp 0x79a07
movq 0x38(%rsp), %rdi
leaq 0x582f5(%rip), %rsi     # 0xd1ce4
callq 0xc6f0
jmp 0x799f6
jmp 0x799f8
leaq 0x20(%rsp), %rdi
callq 0x734b0
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: unsigned long const* Common_sp::findPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, unsigned long>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Value* findPtr (const unordered_map <Key, Value> &m,
                        const KeyParent& key)
    { const auto& it = m. find (key);
    	if (it == m. end ())
    		return nullptr;
    	return & it->second; 
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7bfc0
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x7c010
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x7bff0
testb $0x1, %al
jne 0x7bf98
jmp 0x7bfa3
movq $0x0, 0x30(%rsp)
jmp 0x7bfb6
movq 0x18(%rsp), %rdi
callq 0x7c040
addq $0x20, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::findDuplicate(bool) const
size_t findDuplicate (bool checkSortedP = true) const
      { if (P::size () <= 1)
          return no_index;
        if (checkSortedP)
          checkSorted ();
        for (size_t i = 1; i < P::size (); i++)
          if ((*this) [i] == (*this) [i - 1])
            return i;
        return no_index;
      }

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2f390
cmpq $0x1, %rax
ja 0xa6985
movq $-0x1, 0x30(%rsp)
jmp 0xa6a1f
testb $0x1, 0x27(%rsp)
je 0xa6996
movq 0x10(%rsp), %rdi
callq 0xa6a30
movq $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2f390
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xa6a16
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f4e0
movq 0x10(%rsp), %rdi
movq %rax, (%rsp)
movq 0x18(%rsp), %rsi
subq $0x1, %rsi
callq 0x2f4e0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x30100
testb $0x1, %al
jne 0xa69f8
jmp 0xa6a04
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xa6a1f
jmp 0xa6a06
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xa699f
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
callq 0x2c7d0
testb $0x1, %al
jne 0xac790
jmp 0xac79a
movb $0x1, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x2c7d0
testb $0x1, %al
jne 0xac7b7
jmp 0xac7c1
movb $0x0, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xac7df
movb $0x1, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
cmpq 0x28(%rcx), %rax
jae 0xac7fd
movb $0x0, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jae 0xac81b
movb $0x1, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
cmpq 0x30(%rcx), %rax
jae 0xac839
movb $0x0, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rax
movb 0x38(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movb 0x38(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xac85f
movb $0x1, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movb 0x38(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x38(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xac885
movb $0x0, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rax
movb 0x48(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movb 0x48(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xac8ab
movb $0x1, 0x27(%rsp)
jmp 0xac8d6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movb 0x48(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x48(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xac8d1
movb $0x0, 0x27(%rsp)
jmp 0xac8d6
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Set<GFF_sp::Locus> const* Common_sp::findPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Common_sp::Set<GFF_sp::Locus>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Common_sp::Set<GFF_sp::Locus>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Common_sp::Set<GFF_sp::Locus>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Value* findPtr (const map <Key, Value> &m,
                        const KeyParent& key)
    { const auto& it = m. find (key);
    	if (it == m. end ())
    		return nullptr;
    	return & it->second; 
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb5cf0
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xb5d40
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0xb5d20
testb $0x1, %al
jne 0xb3b38
jmp 0xb3b43
movq $0x0, 0x30(%rsp)
jmp 0xb3b56
movq 0x18(%rsp), %rdi
callq 0xb5d70
addq $0x20, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: ncbi[P]amr/tsv.cpp
// Function: Common_sp::Date::less(Common_sp::Date const&, bool) const
bool Date::less (const Date &other,
                 bool equal) const
{
  LESS_PART (*this, other, year);
  LESS_PART (*this, other, month);
  LESS_PART (*this, other, day);
  return equal;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
andb $0x1, %al
movb %al, -0x19(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movswl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xb6407
movb $0x1, -0x1(%rsp)
jmp 0xb64a2
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movswl 0x8(%rax), %eax
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xb6424
movb $0x0, -0x1(%rsp)
jmp 0xb64a2
movq -0x28(%rsp), %rax
movsbl 0xa(%rax), %eax
movq -0x18(%rsp), %rcx
movsbl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jge 0xb6441
movb $0x1, -0x1(%rsp)
jmp 0xb64a2
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movsbl 0xa(%rax), %eax
movsbl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jge 0xb645e
movb $0x0, -0x1(%rsp)
jmp 0xb64a2
movq -0x28(%rsp), %rax
movsbl 0xb(%rax), %eax
movq -0x18(%rsp), %rcx
movsbl 0xb(%rcx), %ecx
cmpl %ecx, %eax
jge 0xb647b
movb $0x1, -0x1(%rsp)
jmp 0xb64a2
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movsbl 0xb(%rax), %eax
movsbl 0xb(%rcx), %ecx
cmpl %ecx, %eax
jge 0xb6498
movb $0x0, -0x1(%rsp)
jmp 0xb64a2
movb -0x19(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movb $0x0, 0x1f(%rsp)
movswl 0x8(%rax), %ecx
movq 0x20(%rsp), %rdx
movswl 0x8(%rdx), %edx
subl %edx, %ecx
movw %cx, %dx
movsbl 0xa(%rax), %ecx
movq 0x20(%rsp), %rsi
movsbl 0xa(%rsi), %esi
subl %esi, %ecx
movsbl 0xb(%rax), %eax
movq 0x20(%rsp), %rsi
movsbl 0xb(%rsi), %esi
subl %esi, %eax
movswl %dx, %esi
movsbl %cl, %edx
movsbl %al, %ecx
callq 0xbfc20
movq 0x8(%rsp), %rax
movsbl 0xa(%rax), %eax
cmpl $0x0, %eax
jge 0xb6543
movq 0x8(%rsp), %rax
movsbl 0xa(%rax), %ecx
addl $0xc, %ecx
movb %cl, 0xa(%rax)
movw 0x8(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x8(%rax)
jmp 0xb6518
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0xb6559
movq 0x8(%rsp), %rdi
callq 0xbfd00
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::col2num_(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
TextTable::ColNum TextTable::col2num_ (const string &columnName) const
{ 
  FFOR (size_t, i, header. size ())
    if (header [i]. name == columnName)
      return i;
  return no_index;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
addq $0x30, %rdi
callq 0xbfec0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0xb7c33
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x18(%rsp), %rsi
callq 0xc01f0
movq %rax, %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
callq 0x30100
testb $0x1, %al
jne 0xb7c15
jmp 0xb7c21
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xb7c3c
jmp 0xb7c23
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xb7bdf
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x29(%rax)
je 0xb941c
movq 0x8(%rsp), %rax
testb $0x1, 0x28(%rax)
je 0xb937c
movq 0x58(%rsp), %rdi
movl $0x23, %esi
callq 0xc870
movq 0x8(%rsp), %rax
movb $0x1, 0x57(%rsp)
addq $0x30, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xc0370
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xc03a0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xc03d0
testb $0x1, %al
jne 0xb93c2
jmp 0xb940b
leaq 0x40(%rsp), %rdi
callq 0xc0410
movq %rax, 0x30(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xb93e7
movq 0x58(%rsp), %rdi
movl $0x9, %esi
callq 0xc870
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x8, %rsi
callq 0xc660
movb $0x0, 0x57(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xc0420
jmp 0xb93ad
movq 0x58(%rsp), %rdi
movq 0x4cb29(%rip), %rsi     # 0x105f40
callq 0xc760
movq 0x8(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc0440
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc0470
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc04a0
testb $0x1, %al
jne 0xb945d
jmp 0xb949d
leaq 0x20(%rsp), %rdi
callq 0xc04e0
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x9, %edx
callq 0xc04f0
movq 0x58(%rsp), %rdi
movq 0x4cab4(%rip), %rsi     # 0x105f40
callq 0xc760
leaq 0x20(%rsp), %rdi
callq 0xc0590
jmp 0xb9448
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::printHeader(std::ostream&) const
void TextTable::printHeader (ostream &os) const
{
  FFOR (size_t, i, header. size ())
  {
    os << i + 1 << '\t';
    header [i]. saveText (os);
    os << endl;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x10(%rsp)
addq $0x30, %rdi
callq 0xbfec0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0xb954b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0xc160
movq %rax, %rdi
movl $0x9, %esi
callq 0xc870
movq (%rsp), %rdi
addq $0x30, %rdi
movq 0x10(%rsp), %rsi
callq 0xc01f0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x18(%rsp), %rdi
movq 0x4ca0a(%rip), %rsi     # 0x105f40
callq 0xc760
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xb94de
addq $0x28, %rsp
retq
// File: ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::findDate(Common_sp::Date::Format&) const
TextTable::ColNum TextTable::findDate (Date::Format &fmt) const
{
  FFOR (ColNum, dateCol, header. size ())
  {
    const Header& h = header [dateCol];
    if (   h. null
        || h. scientific
       )
      continue;
    size_t fmt_ = 0;
    while (fmt_ < Date::fmt_None)
    {
      fmt = Date::Format (fmt_);
      bool isDate = true;
      for (const StringVector& row : rows)
        if (Date::parse (row [dateCol], fmt). empty ())
        {
          isDate = false;
          break;
        }
      if (isDate)
        return dateCol;
      fmt_++;
    }
  }
  return no_index;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq $0x0, 0x78(%rsp)
addq $0x30, %rdi
callq 0xbfec0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x70(%rsp), %rax
jae 0xb9c09
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movq 0x78(%rsp), %rsi
callq 0xc01f0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
testb $0x1, 0x40(%rax)
jne 0xb9ac9
movq 0x68(%rsp), %rax
testb $0x1, 0x31(%rax)
je 0xb9ace
jmp 0xb9bf6
movq $0x0, 0x60(%rsp)
cmpq $0x2, 0x60(%rsp)
jae 0xb9bf4
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rcx
movl %ecx, %edx
movq 0x80(%rsp), %rcx
movl %edx, (%rcx)
movb $0x1, 0x5f(%rsp)
addq $0x50, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc0440
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc0470
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xc04a0
testb $0x1, %al
jne 0xb9b3d
jmp 0xb9bcb
leaq 0x48(%rsp), %rdi
callq 0xc04e0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x2f4e0
movq %rax, %rsi
movq 0x80(%rsp), %rax
movl (%rax), %edx
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xb5f90
movq (%rsp), %rdi
callq 0xc0630
movb %al, 0xf(%rsp)
jmp 0xb9b85
leaq 0x28(%rsp), %rdi
callq 0xbfd00
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xb9b99
jmp 0xb9bba
movb $0x0, 0x5f(%rsp)
jmp 0xb9bcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xbfd00
jmp 0xb9c25
jmp 0xb9bbc
leaq 0x48(%rsp), %rdi
callq 0xc0590
jmp 0xb9b25
testb $0x1, 0x5f(%rsp)
je 0xb9be1
movq 0x78(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0xb9c15
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0xb9ad7
jmp 0xb9bf6
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xb9a8b
movq $-0x1, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2f4e0
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2f4e0
movq 0x18(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x30, %rdi
movq 0x40(%rsp), %rsi
callq 0xc01f0
testb $0x1, 0x30(%rax)
je 0xba4fb
movq 0x38(%rsp), %rdi
callq 0xc00a0
testb $0x1, %al
jne 0xba457
jmp 0xba462
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0xba476
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc0720
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc00a0
testb $0x1, %al
jne 0xba492
jmp 0xba49d
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0xba4b1
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc0720
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xba4d9
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0xba541
movsd 0x28(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0xba4f1
movl $0x1, 0x64(%rsp)
jmp 0xba541
movl $0x0, 0x64(%rsp)
jmp 0xba541
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2c7d0
testb $0x1, %al
jne 0xba510
jmp 0xba51a
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0xba541
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x75740
testb $0x1, %al
jne 0xba52f
jmp 0xba539
movl $0x1, 0x64(%rsp)
jmp 0xba541
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x32820
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x82260
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x32840
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
movq 0x40(%rsp), %rsi
callq 0xc02b0
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x82260
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0xbcdb4
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xc0cc0
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0x2f4e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2f170
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xbcd5d
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xc0760
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x18(%rsp)
callq 0xc0f40
movq 0x68(%rsp), %rdi
addq $0x50, %rdi
callq 0x380d0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xc0f50
jmp 0xbe214
leaq 0x30(%rsp), %rdi
callq 0x2ef00
movq $0x0, 0x28(%rsp)
movq 0x68(%rsp), %rdi
addq $0x50, %rdi
callq 0x380d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0xbe2ca
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0xbcce0
jmp 0xbe265
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x30(%rsp), %rsi
callq 0xc0f80
movq %rax, (%rsp)
jmp 0xbe27e
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc0fb0
jmp 0xbe28e
jmp 0xbe290
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xbe23a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xbe2d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2eef0
jmp 0xbe2d9
leaq 0x30(%rsp), %rdi
callq 0x2eef0
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xc0ff0
movq 0x10(%rsp), %rdi
callq 0xc09d0
movq 0x58(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x415e0
testb $0x1, %al
jne 0xc00b9
jmp 0xc00c3
movb $0x1, 0x57(%rsp)
jmp 0xc0190
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc320
movq 0x10(%rsp), %rdi
callq 0x73800
jmp 0xc00e3
leaq 0x28(%rsp), %rdi
callq 0x41a40
jmp 0xc00ef
leaq 0x11bb8(%rip), %rsi     # 0xd1cae
leaq 0x28(%rsp), %rdi
callq 0x2e1b0
movb %al, 0xf(%rsp)
jmp 0xc0106
movb 0xf(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0xc0160
jmp 0xc0117
leaq 0xcfd9(%rip), %rsi      # 0xcd0f7
leaq 0x28(%rsp), %rdi
callq 0x2e1b0
movb %al, 0xd(%rsp)
jmp 0xc012e
movb 0xd(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0xc0160
jmp 0xc013f
leaq 0x11b6d(%rip), %rsi     # 0xd1cb3
leaq 0x28(%rsp), %rdi
callq 0x2e1b0
movb %al, 0xc(%rsp)
jmp 0xc0156
movb 0xc(%rsp), %al
movb %al, 0xe(%rsp)
jmp 0xc0160
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xce98
jmp 0xc0190
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xce98
jmp 0xc019b
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
nop
// File: ncbi[P]amr/./common.hpp
// Function: void Common_sp::save<Common_sp::StringVector>(std::ostream&, Common_sp::StringVector const&, char)
void save (ostream &os,
             const T &container,
             char sep)
    { bool first = true;
      for (const auto& t : container)
      { if (! first)
          os << sep;
        os << t;
        first = false;
      }
    }

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movb $0x1, 0x26(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x35930
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x358f0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x35820
testb $0x1, %al
jne 0xc0546
jmp 0xc0589
leaq 0x10(%rsp), %rdi
callq 0x35960
movq %rax, (%rsp)
testb $0x1, 0x26(%rsp)
jne 0xc056a
movq 0x30(%rsp), %rdi
movsbl 0x27(%rsp), %esi
callq 0xc870
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
callq 0xc660
movb $0x0, 0x26(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x38e20
jmp 0xc0531
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x5f(%rsp)
callq 0xc2220
movq 0x60(%rsp), %rdi
callq 0x2f390
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xc2250
jmp 0xc07ad
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x35930
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x358f0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x35820
testb $0x1, %al
jne 0xc07ea
jmp 0xc0850
leaq 0x38(%rsp), %rdi
callq 0x35960
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x303c0
movq %rax, (%rsp)
jmp 0xc080e
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xc2360
jmp 0xc0828
jmp 0xc082a
leaq 0x38(%rsp), %rdi
callq 0x38e20
jmp 0xc07d5
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0xc09d0
jmp 0xc0870
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0xc0866
movq 0x18(%rsp), %rdi
callq 0xc09d0
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<Common_sp::StringVector>::pop_back()
void pop_back ()
      { 
      #ifndef NDEBUG
        if (P::empty ())
          throw runtime_error ("Empty vector pop_back");
      #endif
        P::pop_back ();
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xc09e0
testb $0x1, %al
jne 0xc0a4e
jmp 0xc0aa0
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x11298(%rip), %rsi     # 0xd1d01
callq 0xc2e0
jmp 0xc0a70
movq (%rsp), %rdi
movq 0x45575(%rip), %rsi     # 0x105ff0
movq 0x454ee(%rip), %rdx     # 0x105f70
callq 0xcc80
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0xc580
jmp 0xc0aaf
movq 0x8(%rsp), %rdi
callq 0x3a840
addq $0x28, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2f390
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x32780
movq 0x8(%rsp), %rdi
callq 0x2f020
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x361c0
movq 0x38(%rsp), %rdi
callq 0x35930
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x358f0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xc7fb0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x327f0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)