LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x20, %rsp
movq %rdi, %rbx
leaq 0x489cf(%rip), %rax     # 0x82c58
movq %rax, (%rdi)
leaq 0x168(%rdi), %r14
cmpq $0x0, 0x170(%rdi)
je 0x3a2af
cmpq $0x0, 0x4a833(%rip)     # 0x84ad8
jne 0x3a2af
movq %r14, %rdi
callq 0x3d654
cmpq $0x0, 0x1c0(%rbx)
je 0x3a337
xorl %edi, %edi
callq 0xb570
movq %rax, %r15
movzbl 0x1b8(%rbx), %r8d
xorl $0x1, %r8d
movq 0x49d0a(%rip), %rsi     # 0x83fe0
leaq 0x10(%rsp), %rdi
pushq $0x23
popq %rdx
xorl %ecx, %ecx
callq 0x1e0c2
leaq 0x1b8(%rbx), %rdi
leaq 0x4a7c5(%rip), %rsi     # 0x84ab8
callq 0x1c8e0
leaq 0x23729(%rip), %rsi     # 0x5da28
movq %rax, %rdi
callq 0x3d69a
subq 0x1c0(%rbx), %r15
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rax, %rdi
callq 0x3d6b4
leaq 0x2370a(%rip), %rsi     # 0x5da2f
movq %rax, %rdi
callq 0x3d6d2
leaq 0x10(%rsp), %rdi
callq 0x1e15c
movb $0x0, 0x4a753(%rip)     # 0x84a91
leaq 0x188(%rbx), %rdi
callq 0x1be2a
movq %r14, %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0x1bcce
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1bdcd
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, (%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %r8
movq 0x8(%rsi,%r8), %r8
movq %r8, 0x8(%rdi)
movq -0x18(%rax), %r8
movl 0x18(%rsi,%r8), %r8d
movl %r8d, 0x10(%rdi)
movq -0x18(%rax), %rdi
movl $0xfffffefb, %r8d       # imm = 0xFFFFFEFB
andl 0x18(%rsi,%rdi), %r8d
testl %ecx, %ecx
movl $0x100, %ecx            # imm = 0x100
pushq $0x4
popq %r9
cmovnel %ecx, %r9d
orl %r8d, %r9d
movl %r9d, 0x18(%rsi,%rdi)
movq -0x18(%rax), %rax
movq %rdx, 0x8(%rsi,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x21569(%rip), %rsi     # 0x5d804
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
movl %ebx, %eax
shrl $0x4, %eax
leaq 0x1f54f(%rip), %rcx     # 0x5b800
movb (%rax,%rcx), %al
movq (%r14), %rdx
movb %al, (%rdx)
andl $0xf, %ebx
movb (%rbx,%rcx), %al
movq (%r14), %rcx
movb %al, 0x1(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3e834
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x3c79e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f42e
movq 0x8(%r14), %r15
subq (%r14), %r15
sarq $0x5, %r15
decq %r15
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e94c
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
cmpl $0x5, %esi
ja 0x3c911
movq %rdi, %rbx
movl %esi, %eax
leaq 0x1eef6(%rip), %rcx     # 0x5b7b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x22984(%rip), %rsi     # 0x5f252
jmp 0x3c8fb
leaq 0x215ff(%rip), %rsi     # 0x5ded6
jmp 0x3c8fb
leaq 0x2006b(%rip), %rsi     # 0x5c94b
jmp 0x3c8fb
leaq 0x215e5(%rip), %rsi     # 0x5dece
jmp 0x3c8fb
leaq 0x20411(%rip), %rsi     # 0x5cd03
jmp 0x3c8fb
leaq 0x215e2(%rip), %rsi     # 0x5dedd
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1b7b6
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x215ce(%rip), %rsi     # 0x5dee6
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1b7b6
movq %rbx, %rdi
callq 0x224fc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2f
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0xbb20
cmpq $-0x1, %rax
je 0x3d586
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb5e0
jmp 0x3d595
leaq 0x4756b(%rip), %rsi     # 0x84af8
movq %rbx, %rdi
callq 0xb7b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x4bae4
movq %rax, %r15
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x3d79a
leaq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0xb350
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0xb410
pushq $0x2d
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0xb680
pushq $0x30
popq %r14
movq %rax, %rdi
movl %r14d, %esi
callq 0xb8d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x2
popq %r15
movq %r15, 0x10(%rax,%rcx)
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0xb410
movq %rax, %rdi
movl %ebp, %esi
callq 0xb680
movq %rax, %rdi
movl %r14d, %esi
callq 0xb8d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x10(%rax,%rcx)
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0xb410
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0xb680
movl 0x14(%rbx), %esi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdx
movzbl 0x18(%rdi), %ecx
movq %rsp, %rdi
callq 0x3c1e4
movq 0x8(%r14), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x3e15d
leaq 0x21a1b(%rip), %rsi     # 0x5fb6e
movq %rbx, %rdi
callq 0xb590
jmp 0x3e165
movq %rbx, %rdi
callq 0xb920
movq (%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x10(%rsp), %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq 0x8(%rsp), %rdx
movq %rdx, 0x8(%rax,%rcx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq (%rsp), %rcx
movq (%rcx), %rdx
movq -0x18(%rdx), %rsi
movl 0x10(%rsp), %edi
movl %edi, 0x18(%rcx,%rsi)
movq -0x18(%rdx), %rdx
movq 0x8(%rsp), %rsi
movq %rsi, 0x8(%rcx,%rdx)
movq %rax, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
callq 0x3e860
leaq 0x28(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c260
movb $0x1, %bl
testb %al, %al
jne 0x4c1a6
movq %r13, %rdi
movq %r12, %rsi
callq 0x1c260
testb %al, %al
je 0x4c199
xorl %ebx, %ebx
jmp 0x4c1a6
movq 0x28(%r15), %rax
movq 0x28(%r14), %rcx
cmpq %rcx, %rax
jae 0x4c1b2
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
ja 0x4c195
movq 0x30(%r15), %rax
movq 0x30(%r14), %rcx
cmpq %rcx, %rax
jb 0x4c1a6
ja 0x4c195
movb 0x38(%r15), %al
movb 0x38(%r14), %cl
cmpb %cl, %al
jb 0x4c1a6
ja 0x4c195
movb 0x48(%r15), %al
cmpb 0x48(%r14), %al
setb %bl
jmp 0x4c1a6
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
leaq 0x12d83(%rip), %rsi     # 0x5ef73
callq 0x1cba2
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x4c2d8
leaq 0xd03e(%rip), %rsi      # 0x59246
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c21b
pushq $0x1
jmp 0x4c2d7
leaq 0x12d57(%rip), %rsi     # 0x5ef79
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c235
pushq $0x2
jmp 0x4c2d7
leaq 0x12d48(%rip), %rsi     # 0x5ef84
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c24f
pushq $0x3
jmp 0x4c2d7
leaq 0x12e13(%rip), %rsi     # 0x5f069
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c266
pushq $0x4
jmp 0x4c2d7
leaq 0x12dd9(%rip), %rsi     # 0x5f046
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c27d
pushq $0x5
jmp 0x4c2d7
leaq 0x12d07(%rip), %rsi     # 0x5ef8b
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c294
pushq $0x6
jmp 0x4c2d7
leaq 0x12cf7(%rip), %rsi     # 0x5ef92
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c2ab
pushq $0x7
jmp 0x4c2d7
leaq 0x12cee(%rip), %rsi     # 0x5efa0
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c2c2
pushq $0x8
jmp 0x4c2d7
leaq 0x12cdc(%rip), %rsi     # 0x5efa5
movq %rbx, %rdi
callq 0x1cba2
testb %al, %al
je 0x4c2e1
pushq $0x9
popq %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
movq %rsp, %rdi
pushq $0x22
popq %rdx
movq %rbx, %rsi
callq 0x243b1
leaq 0x12cad(%rip), %rsi     # 0x5efae
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x1b94c
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x37cc1(%rip), %rsi     # 0x83fe8
movq 0x37c32(%rip), %rdx     # 0x83f60
movq %r14, %rdi
callq 0xb9d0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbb68
jmp 0x4c34b
movq %rax, %rbx
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x4c35d
jmp 0x4c365
movq %rax, %rbx
movq %r14, %rdi
callq 0xb470
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
callq 0x50898
addq $0x8, %rbx
leaq 0x40(%rax), %rdx
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovneq %rdx, %rcx
movq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movl 0x8(%rsi), %ecx
movb 0xa(%rsi), %r9b
movb 0xa(%rdx), %r8b
movl %r9d, %eax
subb %r8b, %al
movb 0xb(%rsi), %sil
subb 0xb(%rdx), %sil
movzbl %al, %eax
xorl %r10d, %r10d
testb %al, %al
cmovgl %eax, %r10d
leaq 0x330e7(%rip), %r11     # 0x83cb0
addb %r8b, %r10b
cmpb %r9b, %r10b
setne %bl
leal (%r9,%rbx), %eax
subb %al, %r10b
movzbl %r10b, %eax
movb $0xc, %r10b
divb %r10b
addb %bl, %al
movzbl %al, %eax
movzwl 0x8(%rdx), %edx
addw %ax, %dx
movq %r11, (%rdi)
movb %sil, 0xb(%rdi)
imull $0xc, %eax, %eax
addb %r9b, %al
subl %edx, %ecx
subb %r8b, %al
movb %al, 0xa(%rdi)
movw %cx, 0x8(%rdi)
movq %rdi, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::Header::qc() const
void TextTable::Header::qc () const
{
  if (! qc_on)
    return;

  Named::qc ();
    
  QC_IMPLY (scientific, numeric);
  QC_IMPLY (decimals, numeric);
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq 0x33ec3(%rip), %rax     # 0x84ae0
cmpb $0x1, (%rax)
jne 0x50c57
movq %rdi, %rbx
callq 0x29978
cmpb $0x1, 0x31(%rbx)
jne 0x50c42
callq 0xb060
andl $0x0, (%rax)
cmpb $0x0, 0x30(%rbx)
je 0x50d34
cmpq $0x0, 0x38(%rbx)
je 0x50c57
callq 0xb060
andl $0x0, (%rax)
cmpb $0x0, 0x30(%rbx)
je 0x50c60
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xb6c0
testl %eax, %eax
jne 0x50e08
leaq 0xe935(%rip), %rsi      # 0x5f5a9
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x81, %esi
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x8f33(%rip), %rdx      # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0xe8ee(%rip), %rsi      # 0x5f5ba
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0xac5c(%rip), %rdx      # 0x5b93e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b92d
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1ca3c
leaq 0xecaa(%rip), %rdx      # 0x5f9bc
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1b92d
leaq 0xf0(%rsp), %rdi
callq 0x224fc
callq 0xb6c0
testl %eax, %eax
jne 0x50e08
leaq 0xe861(%rip), %rsi      # 0x5f5a9
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x50(%rsp), %rdi
movl $0x80, %esi
callq 0x1caa3
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1ca3c
leaq 0x8e5f(%rip), %rdx      # 0x59be3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b92d
leaq 0xe81a(%rip), %rsi      # 0x5f5ba
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1b7b6
leaq 0xab88(%rip), %rdx      # 0x5b93e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b92d
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1ca3c
leaq 0xebd6(%rip), %rdx      # 0x5f9bc
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1b92d
leaq 0xf0(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
jmp 0x50e14
jmp 0x50e26
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xbb68
jmp 0x50e29
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb68
jmp 0x50e3d
jmp 0x50e3a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x50e4e
jmp 0x50e4b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x50e5f
jmp 0x50e5c
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb68
jmp 0x50e73
jmp 0x50e70
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x50e87
jmp 0x50e84
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x50e98
jmp 0x50e95
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb68
jmp 0x50ea9
jmp 0x50ea6
movq %rax, %rbx
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x38(%rdi), %r13
subq 0x30(%rdi), %r13
leaq 0x30(%rdi), %r15
sarq $0x7, %r13
xorl %r12d, %r12d
pushq $-0x1
popq %r14
cmpq %r12, %r13
je 0x51875
movq %r15, %rdi
movq %r12, %rsi
callq 0x55468
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x1d9db
testb %al, %al
jne 0x51872
incq %r12
jmp 0x5184d
movq %r12, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x29(%rdi)
jne 0x52526
cmpb $0x1, 0x28(%r14)
jne 0x524ea
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xb680
movq 0x30(%r14), %r15
movq 0x38(%r14), %r12
movb $0x1, %al
pushq $0x9
popq %rbp
cmpq %r12, %r15
je 0x5251e
testb $0x1, %al
jne 0x5250a
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb680
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xb510
subq $-0x80, %r15
xorl %eax, %eax
jmp 0x524f7
movq %rbx, %rdi
callq 0xb2f0
movq 0x50(%r14), %r15
movq 0x58(%r14), %r14
pushq $0x9
popq %rbp
cmpq %r14, %r15
je 0x52551
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5553b
movq %rbx, %rdi
callq 0xb2f0
addq $0x20, %r15
jmp 0x52531
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rdi), %r12
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
sarq $0x7, %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0x18(%rsp), %rbp
cmpq 0x10(%rsp), %r13
je 0x5294c
movq %r12, %rdi
movq %r13, %rsi
callq 0x55468
cmpb $0x0, 0x40(%rax)
jne 0x528d1
cmpb $0x0, 0x31(%rax)
je 0x528d6
incq %r13
jmp 0x528af
xorl %r15d, %r15d
movq %r14, 0x8(%rsp)
movq %r12, (%rsp)
cmpq $0x2, %r15
je 0x528d1
movl %r15d, (%rbx)
movq 0x50(%r14), %r12
movq 0x58(%r14), %r14
cmpq %r14, %r12
je 0x5293a
movq %r12, %rdi
movq %r13, %rsi
callq 0x1d398
movl (%rbx), %edx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x50910
cmpw $0x0, 0x20(%rsp)
jne 0x52926
cmpb $0x0, 0x22(%rsp)
jne 0x52926
cmpb $0x0, 0x23(%rsp)
je 0x5292c
addq $0x20, %r12
jmp 0x528f3
incq %r15
movq 0x8(%rsp), %r14
movq (%rsp), %r12
jmp 0x528e2
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
jmp 0x5293d
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x1d398
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1d398
movq %rax, %rbx
addq $0x30, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x55468
cmpb $0x1, 0x30(%rax)
jne 0x52de1
movq %r14, %rdi
callq 0x553c9
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x52da8
movq %r14, %rdi
xorl %esi, %esi
callq 0x555bb
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x553c9
testb %al, %al
xorpd %xmm0, %xmm0
jne 0x52dc7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x555bb
xorl %ecx, %ecx
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %cl
ucomisd %xmm1, %xmm0
pushq $-0x1
popq %rax
cmovbel %ecx, %eax
jmp 0x52e03
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c260
testb %al, %al
je 0x52df5
pushq $-0x1
popq %rax
jmp 0x52e03
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ce25
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::filterColumns(Common_sp::StringVector const&)
void TextTable::filterColumns (const StringVector &newColumnNames)
{
  const Vector<ColNum> colNums (columns2nums (newColumnNames));

  {  
    Vector<Header> newHeader;  newHeader. reserve (colNums. size ());
    for (const ColNum i : colNums)
      newHeader << header [i];
    header = std::move (newHeader);
  }

  for (StringVector& row : rows)
  {
    StringVector newRow;  newRow. reserve (colNums. size ());
    for (const ColNum i : colNums)
      newRow << row [i];
    row = std::move (newRow);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rdx
movq %rdi, %r15
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x555d4
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movups %xmm0, 0x9(%rdi)
movaps %xmm0, (%rdi)
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x3, %rsi
callq 0x5565e
movq (%rsp), %r12
movq 0x8(%rsp), %r13
leaq 0x30(%r15), %r14
leaq 0x20(%rsp), %rbx
cmpq %r13, %r12
je 0x52e84
movq (%r12), %rsi
movq %r14, %rdi
callq 0x55318
movq %rbx, %rdi
movq %rax, %rsi
callq 0x55582
addq $0x8, %r12
jmp 0x52e62
leaq 0x20(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x556f2
movq %rbx, %rdi
callq 0x20a26
movq 0x50(%r15), %r14
movq 0x58(%r15), %r15
cmpq %r15, %r14
je 0x52f0f
xorps %xmm0, %xmm0
movups %xmm0, 0x29(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rsi
subq (%rsp), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x1e7ce
movq (%rsp), %r12
movq 0x8(%rsp), %r13
cmpq %r13, %r12
je 0x52ef6
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1d5ec
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1d1d0
addq $0x8, %r12
jmp 0x52ed4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20b7a
movq %rbx, %rdi
callq 0x20bee
addq $0x20, %r14
jmp 0x52ea4
movq %rsp, %rdi
callq 0x40424
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x52f29
jmp 0x52f38
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20a26
jmp 0x52f45
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20bee
movq %rsp, %rdi
callq 0x40424
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x555d4
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r14
cmpq %r14, %r15
je 0x53006
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 0x54bff
cmpq $0x201, %r12            # imm = 0x201
jl 0x52ff3
leaq 0x200(%r15), %r12
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x55121
leaq 0x8(%rsp), %r15
cmpq %r14, %r12
je 0x53006
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x551ed
addq $0x20, %r12
jmp 0x52fda
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x55121
leaq 0x8(%rsp), %rdi
callq 0x40424
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5301e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40424
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/tsv.cpp
// Function: Common_sp::(anonymous namespace)::ColumnPartitionQC::add(Common_sp::StringVector const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void add (const StringVector &cols,
              const string &oper)
      {
        for (const string& s : cols)
          if (name2oper [s]. empty ())
            name2oper [s] = oper;
          else
            throw runtime_error ("Column " + strQuote (s) + " is used for operations " + strQuote (name2oper [s]) + " and " + strQuote (oper)); 
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %r14
movq %rdi, %r12
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
cmpq %rbx, %r15
je 0x5381b
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d7a6
cmpq $0x0, 0x8(%rax)
jne 0x5382b
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d7a6
movq %rax, %rdi
movq %r14, %rsi
callq 0xb350
addq $0x20, %r15
jmp 0x537e8
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
pushq $0x22
popq %rdx
movq %r15, %rsi
callq 0x243b1
leaq 0xbe36(%rip), %rsi      # 0x5f683
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x1b94c
leaq 0xc2e3(%rip), %rdx      # 0x5fb46
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x1b92d
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d7a6
leaq 0x20(%rsp), %rdi
pushq $0x22
popq %rdx
movq %rax, %rsi
callq 0x243b1
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1ca3c
leaq 0x5ab3(%rip), %rdx      # 0x59364
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x1b92d
movq %rsp, %rdi
pushq $0x22
popq %rdx
movq %r14, %rsi
callq 0x243b1
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movq %rsp, %rdx
callq 0x1ca3c
movb $0x1, %bpl
leaq 0xe0(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x306e0(%rip), %rsi     # 0x83fe8
movq 0x30651(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0xe0(%rsp), %rdi
callq 0xbb68
jmp 0x5392f
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xbb68
jmp 0x5393f
movq %rax, %r14
movb $0x1, %bpl
leaq 0xc0(%rsp), %rdi
callq 0xbb68
jmp 0x53954
movq %rax, %r14
movb $0x1, %bpl
leaq 0xa0(%rsp), %rdi
callq 0xbb68
jmp 0x53969
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xbb68
jmp 0x5397b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x80(%rsp), %rdi
callq 0xbb68
jmp 0x53990
movq %rax, %r14
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0xbb68
jmp 0x539a2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x539b6
jmp 0x539be
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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, %rdi
callq 0x1e7c6
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x1e7ce
addq $0x50, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x554d2
movq %rax, %r15
movq 0x8(%r14), %r13
subq (%r14), %r13
sarq $0x3, %r13
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x54255
movq %r14, %rdi
movq %r12, %rsi
callq 0x55888
movq (%rax), %rsi
movq %r15, %rdi
callq 0x1d398
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1d1d0
incq %r12
jmp 0x5422a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/tsv.cpp
// Function: Common_sp::TextTable::col2values(unsigned long) const
StringVector TextTable::col2values (ColNum col) const
{
  QC_ASSERT (col < header. size ());
  
  Set<string> s;
  for (const StringVector& row : rows)
    if (! row [col]. empty ())
      s << row [col];
            
  StringVector vec;  vec. reserve (s. size ());
  insertAll (vec, s);
  
  return vec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0xb060
andl $0x0, (%rax)
movq 0x38(%r12), %rax
subq 0x30(%r12), %rax
sarq $0x7, %rax
cmpq %rbx, %rax
jbe 0x54654
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq 0x50(%r12), %r15
movq 0x58(%r12), %r13
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
je 0x54610
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d398
cmpq $0x0, 0x8(%rax)
je 0x5460a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d398
movq %r12, %rdi
movq %rax, %rsi
callq 0x553b2
addq $0x20, %r15
jmp 0x545dd
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%r14)
movups %xmm0, (%r14)
movq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x1e7ce
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x558f1
leaq 0x8(%rsp), %rdi
callq 0x560a4
movq %r14, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xb6c0
testl %eax, %eax
jne 0x5472e
leaq 0xaf41(%rip), %rsi      # 0x5f5a9
leaq 0xa0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x80(%rsp), %rdi
movl $0x2bf, %esi            # imm = 0x2BF
callq 0x1caa3
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x1ca3c
leaq 0x5533(%rip), %rdx      # 0x59be3
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x1b92d
leaq 0xb3de(%rip), %rsi      # 0x5faaa
leaq 0x40(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1b7b6
leaq 0x725c(%rip), %rdx      # 0x5b93e
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1b92d
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x1ca3c
leaq 0xb3d4(%rip), %rdx      # 0x5fae6
leaq 0x8(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x1b92d
leaq 0x8(%rsp), %rdi
callq 0x224fc
pushq $0x1
popq %rdi
callq 0xb6d0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x54748
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0xbb68
jmp 0x5475a
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xbb68
jmp 0x54769
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xbb68
jmp 0x54778
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0xbb68
jmp 0x5478a
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0xbb68
jmp 0x5479c
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xbb68
jmp 0x547ae
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xbb68
jmp 0x547dc
movq %rax, %rbx
jmp 0x547dc
movq %rax, %rbx
movq %r14, %rdi
callq 0x20bee
jmp 0x547d2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x560a4
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x555d4
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 0x57e5c
leaq 0x10(%rsp), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%r12)
movaps %xmm0, (%r12)
leaq 0x8(%rsp), %r13
andq $0x0, (%r13)
movq 0x58(%r15), %rbp
subq 0x50(%r15), %rbp
sarq $0x5, %rbp
xorl %edx, %edx
cmpq %rbp, %rdx
jae 0x54bbc
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0x541da
movq %r14, %rdi
movq %r12, %rsi
callq 0x5800e
movq %rax, %rdi
movq %r13, %rsi
callq 0x55904
movq 0x8(%rsp), %rdx
incq %rdx
movq %rdx, 0x8(%rsp)
jmp 0x54b84
leaq 0x10(%rsp), %rdi
callq 0x20bee
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x54be7
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x20bee
movq %r14, %rdi
callq 0x561c6
movq %rbx, %rdi
callq 0x40424
movq %r15, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
callq 0x23cd3
movb $0x1, %bl
testb %al, %al
jne 0x55449
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb7b0
movq %rbx, %rdi
callq 0x3c32f
leaq 0x8(%rsp), %rdi
callq 0x23f17
leaq 0xa731(%rip), %rsi      # 0x5fb38
leaq 0x8(%rsp), %rdi
callq 0x1cba2
movb $0x1, %bl
testb %al, %al
jne 0x5543f
leaq 0x5d1b(%rip), %rsi      # 0x5b139
leaq 0x8(%rsp), %rdi
callq 0x1cba2
testb %al, %al
jne 0x5543f
leaq 0xa70a(%rip), %rsi      # 0x5fb3d
leaq 0x8(%rsp), %rdi
callq 0x1cba2
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xbb68
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r15
movb $0x1, %al
movsbl %dl, %ebp
cmpq %r15, %r14
je 0x55577
testb $0x1, %al
jne 0x55564
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb680
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb510
addq $0x20, %r14
xorl %eax, %eax
jmp 0x55551
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55ea2
movq (%r12), %r15
movq 0x8(%r12), %r13
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
je 0x55638
movq %r14, %rdi
movq %r15, %rsi
callq 0x1daec
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x55f38
addq $0x20, %r15
jmp 0x55612
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5564b
movq %rax, %r14
movq %rbx, %rdi
callq 0x40424
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
subq (%r14), %rsi
sarq $0x5, %rsi
callq 0x1e7b2
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %rdi
callq 0x57594
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x557ae
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::aggregate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
inline void aggregate (string& aggregation,
                       const string &addition,
                       char aggr_sep)
  { StringVector vec (aggregation, aggr_sep, true);
    vec << addition;
    vec. sort ();
    vec. uniq ();
    aggregation = vec. toString (string (1, aggr_sep));
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x29cba
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d1d0
leaq 0x8(%rsp), %rdi
callq 0x1e78e
leaq 0x8(%rsp), %rdi
callq 0x1e7a4
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movsbl %bpl, %edx
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0xb670
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x2850e
leaq 0x48(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb6f0
movq %r14, %rdi
callq 0xbb68
leaq 0x28(%rsp), %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
callq 0x20bee
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x55876
jmp 0x55873
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20bee
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TextTable::Header::saveText(std::ostream&) const
void saveText (ostream& os) const override
      { os         << name 
           << '\t' << len_max 
           << '\t' << (numeric ? ((scientific ? "float" : "int") + string ("(") + to_string (decimals) + ")") : "char") 
           << '\t' << (null ? "null" : "not null"); 
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0xb510
pushq $0x9
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0xb680
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0xb410
movq %rax, %rdi
movl %ebp, %esi
callq 0xb680
movq %rax, %r14
movb 0x30(%rbx), %bpl
cmpb $0x1, %bpl
jne 0x55a09
movb 0x31(%rbx), %r15b
leaq 0x462b(%rip), %rsi      # 0x59fc1
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0xa1b3(%rip), %rax      # 0x5fb5f
leaq 0x8977(%rip), %rsi      # 0x5e32a
testb %r15b, %r15b
cmovneq %rax, %rsi
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x1b94c
movq 0x38(%rbx), %rsi
leaq 0x48(%rsp), %rdi
callq 0x56299
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1ca3c
leaq 0x773d(%rip), %rdx      # 0x5d135
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b92d
jmp 0x55a1f
leaq 0xa155(%rip), %rsi      # 0x5fb65
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1b7b6
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xb510
pushq $0x9
popq %rsi
movq %rax, %rdi
callq 0xb680
leaq 0xa130(%rip), %rcx      # 0x5fb6e
leaq 0xa125(%rip), %rsi      # 0x5fb6a
cmpb $0x0, 0x40(%rbx)
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0xb590
leaq 0x28(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
je 0x55a8f
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0x48(%rsp), %rdi
callq 0xbb68
leaq 0x88(%rsp), %rdi
callq 0xbb68
leaq 0x68(%rsp), %rdi
callq 0xbb68
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x55ac8
movq %rax, %rbx
jmp 0x55ad2
movq %rax, %rbx
jmp 0x55adc
movq %rax, %rbx
jmp 0x55ae9
movq %rax, %rbx
jmp 0x55af3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
je 0x55af3
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0x48(%rsp), %rdi
callq 0xbb68
leaq 0x88(%rsp), %rdi
callq 0xbb68
leaq 0x68(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::Date::toJson(Common_sp::JsonContainer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
JsonMap* toJson (JsonContainer* parent, 
                   const string& name = noString) const override
    { auto j = new JsonMap (parent, name);
      new JsonInt (year,  j, "year");
      new JsonInt (month, j, "month");
      new JsonInt (day,   j, "day");
      return j;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0xb5a0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x55cfc
pushq $0x10
popq %rdi
callq 0xb5a0
movq %rax, %r15
movswq 0x8(%r14), %r12
leaq 0x9f27(%rip), %rsi      # 0x5fb29
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3cf4e
leaq 0x8(%rsp), %rdi
callq 0xbb68
pushq $0x10
popq %rdi
callq 0xb5a0
movq %rax, %r15
movsbq 0xa(%r14), %r12
leaq 0x9ee9(%rip), %rsi      # 0x5fb2e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3cf4e
leaq 0x8(%rsp), %rdi
callq 0xbb68
pushq $0x10
popq %rdi
callq 0xb5a0
movq %rax, %r15
movsbq 0xb(%r14), %r14
leaq 0x9eac(%rip), %rsi      # 0x5fb34
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1b7b6
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cf4e
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x55ccb
jmp 0x55cda
jmp 0x55ccb
jmp 0x55cda
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x55cdd
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0xb5b0
movq %r14, %rdi
callq 0xba30
movq %rax, %r14
pushq $0x38
popq %rsi
movq %rbx, %rdi
jmp 0x55ce3
nop