LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Token::saveText(std::ostream&) const
void Token::saveText (ostream &os) const 
{ 
  if (empty ())
    return;
    
  switch (type)
	{ 
	  case eName:      
	  case eDateTime:  os << name; 
	                   break;
		case eText:      if (quote)
		                   os << quote;
		                 os << name;
		                 if (quote)
		                   os << quote; 
		                 break;
		case eInteger:   os << n;             
		                 break;
		case eDouble:    { 
		                   const ONumber on (os, decimals, scientific); 
		                   os << d; 
		                 } 
		                 break;
		case eDelimiter: os << name;          
		                 break;
 		default: throw logic_error ("Token: Unknown type");
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x53c94
jmp 0x53c99
jmp 0x53e11
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, 0x10(%rsp)
subq $0x5, %rax
ja 0x53dbc
movq 0x10(%rsp), %rax
leaq 0x79974(%rip), %rcx     # 0xcd630
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x10, %rsi
callq 0xc660
jmp 0x53e11
movq 0x18(%rsp), %rax
cmpb $0x0, 0x30(%rax)
je 0x53cfb
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rdi
movsbl 0x30(%rax), %esi
callq 0xc870
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x10, %rsi
callq 0xc660
movq 0x18(%rsp), %rax
cmpb $0x0, 0x30(%rax)
je 0x53d2c
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rdi
movsbl 0x30(%rax), %esi
callq 0xc870
jmp 0x53e11
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rdi
movq 0x38(%rax), %rsi
callq 0xc400
jmp 0x53e11
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rsi
movq 0x48(%rax), %rdx
movzbl 0x50(%rax), %ecx
andl $0x1, %ecx
leaq 0x30(%rsp), %rdi
callq 0x73400
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rdi
movsd 0x40(%rax), %xmm0
callq 0xcdd0
jmp 0x53d7e
leaq 0x30(%rsp), %rdi
callq 0x734b0
jmp 0x53e11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x734b0
jmp 0x53e16
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x10, %rsi
callq 0xc660
jmp 0x53e11
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x7abd3(%rip), %rsi     # 0xce9ab
callq 0xca70
jmp 0x53ddf
movq 0x8(%rsp), %rdi
movq 0xb21dd(%rip), %rsi     # 0x105fc8
movq 0xb218e(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xc580
jmp 0x53e16
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Token::operator<(Common_sp::Token const&) const
bool Token::operator< (const Token &other) const
{
  LESS_PART (*this, other, type);
  switch (type)
  { 
    case eName:
    case eText:
    case eDateTime:
    case eDelimiter: LESS_PART (*this, other, name); break;
    case eInteger:   LESS_PART (*this, other, n);    break; 
    case eDouble:    LESS_PART (*this, other, d);    break;
  }  
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x53e4f
movb $0x1, 0x27(%rsp)
jmp 0x53f66
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
jge 0x53e6b
movb $0x0, 0x27(%rsp)
jmp 0x53f66
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, (%rsp)
subq $0x5, %rax
ja 0x53f61
movq (%rsp), %rax
leaq 0x797bc(%rip), %rcx     # 0xcd648
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
callq 0x2c7d0
testb $0x1, %al
jne 0x53eb2
jmp 0x53ebc
movb $0x1, 0x27(%rsp)
jmp 0x53f66
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x2c7d0
testb $0x1, %al
jne 0x53ed9
jmp 0x53ee3
movb $0x0, 0x27(%rsp)
jmp 0x53f66
jmp 0x53f61
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jge 0x53f00
movb $0x1, 0x27(%rsp)
jmp 0x53f66
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
cmpq 0x38(%rcx), %rax
jge 0x53f1b
movb $0x0, 0x27(%rsp)
jmp 0x53f66
jmp 0x53f61
movq 0x8(%rsp), %rax
movsd 0x40(%rax), %xmm1
movq 0x10(%rsp), %rax
movsd 0x40(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x53f3e
movb $0x1, 0x27(%rsp)
jmp 0x53f66
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd 0x40(%rcx), %xmm1
movsd 0x40(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x53f5f
movb $0x0, 0x27(%rsp)
jmp 0x53f66
jmp 0x53f61
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::TokenInput::get()
Token TokenInput::get ()
{ 
  const Token last_ (last);
  last = Token ();
  if (! last_. empty ())
  {
    tp = last_. tp;
    return last_;
  }
    
  for (;;)  
  { 
    Token t (ci, dashInName, consecutiveQuotesInText);
    if (t. empty ())
      break;
    tp = t. tp;
    if (! t. isDelimiter (commentStart))
      return t;
    ci. getLine ();
  }
  
  return Token ();
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq 0x148(%rsp), %rsi
movq %rsi, 0x20(%rsp)
addq $0x280, %rsi            # imm = 0x280
movq %rsi, 0x28(%rsp)
leaq 0xe8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x75120
xorps %xmm0, %xmm0
movaps %xmm0, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x751c0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x75240
movq 0x30(%rsp), %rdi
callq 0x752b0
movq 0x38(%rsp), %rdi
callq 0x752f0
movb %al, 0x47(%rsp)
jmp 0x5403d
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x5408f
jmp 0x54047
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x13c(%rsp), %rcx
movq %rcx, 0x2e0(%rax)
leaq 0xe8(%rsp), %rsi
callq 0x75120
jmp 0x5406f
movl $0x1, 0x70(%rsp)
jmp 0x541bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x541d9
jmp 0x54091
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movb $0x0, 0x6f(%rsp)
movq %rax, %rsi
addq $0x8, %rsi
movzbl 0x27a(%rax), %ecx
movzbl 0x279(%rax), %edx
andl $0x1, %edx
andl $0x1, %ecx
callq 0x75330
jmp 0x540c2
movq 0x10(%rsp), %rdi
callq 0x752f0
movb %al, 0xf(%rsp)
jmp 0x540d2
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x540dc
jmp 0x54106
movl $0x2, 0x70(%rsp)
jmp 0x5416d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x752b0
jmp 0x541d9
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x54(%rdi), %rcx
movq %rcx, 0x2e0(%rax)
movsbl 0x278(%rax), %esi
callq 0x75410
movb %al, 0xe(%rsp)
jmp 0x5412d
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x54146
jmp 0x54137
movb $0x1, 0x6f(%rsp)
movl $0x1, 0x70(%rsp)
jmp 0x5416d
movq 0x20(%rsp), %rsi
addq $0x8, %rsi
leaq 0x48(%rsp), %rdi
callq 0x50e90
jmp 0x5415b
leaq 0x48(%rsp), %rdi
callq 0xce98
movl $0x0, 0x70(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0x5417e
movq 0x10(%rsp), %rdi
callq 0x752b0
movl 0x70(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x54197
jmp 0x5418c
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x5419c
jmp 0x541bf
jmp 0x54091
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0xc410
movq 0x10(%rsp), %rdi
callq 0x751c0
movl $0x1, 0x70(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x752b0
movq 0x18(%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
retq
leaq 0xe8(%rsp), %rdi
callq 0x752b0
movq 0x78(%rsp), %rdi
callq 0xccf0
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::csvLine2vec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
StringVector csvLine2vec (const string &line)
{
  StringVector words;  words. reserve (256);  // PAR
  Csv csv (line);
  string s;
  while (csv. goodPos ())
  {
    s = csv. getWord ();
    trim (s);
    words << std::move (s);
  }
  return words;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movb $0x0, 0x97(%rsp)
callq 0x2ef00
movq 0x28(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x32840
jmp 0x5b0a2
movq 0x98(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x75840
jmp 0x5b0b6
leaq 0x50(%rsp), %rdi
callq 0xca10
leaq 0x70(%rsp), %rdi
callq 0x75780
movb %al, 0x1f(%rsp)
jmp 0x5b0d0
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x5b0dd
jmp 0x5b166
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x5aa00
jmp 0x5b0ee
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x30(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0xc8f0
movq 0x8(%rsp), %rdi
callq 0xce98
movq 0x10(%rsp), %rdi
callq 0x73800
jmp 0x5b11d
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2ef10
jmp 0x5b12e
jmp 0x5b0c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x5b199
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xce98
jmp 0x5b199
movb $0x1, 0x97(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xce98
testb $0x1, 0x97(%rsp)
jne 0x5b18c
movq 0x28(%rsp), %rdi
callq 0x2eef0
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2eef0
movq 0x88(%rsp), %rdi
callq 0xccf0
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Json::toStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string Json::toStr (const string& s)
{ 
  if (isNatural (s, false))
    return s;
    
  // https://www.json.org/json-en.html
  string res ("\"");
  for (const char c : s)
    switch (c)
    {
      case '\"': res += "\\\""; break;
      case '\\': res += "\\\\"; break;
      case '\n': res += "\\n"; break;
      case '\r': res += "\\t"; break;
      case '\t': res += "\\t"; break;
      default:   res += c;
    }
  return res + "\""; 
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0x414f0
testb $0x1, %al
jne 0x5bcf3
jmp 0x5bd07
movq 0x10(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xc320
jmp 0x5bebf
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x71d89(%rip), %rsi     # 0xcdaab
leaq 0x58(%rsp), %rdi
callq 0x29fd0
jmp 0x5bd2e
leaq 0x57(%rsp), %rdi
callq 0xc7a0
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xc6d0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0xcd90
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x5bd78
jmp 0x5be9d
leaq 0x30(%rsp), %rdi
callq 0x73720
movb (%rax), %al
movb %al, 0x27(%rsp)
movsbl 0x27(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x9, %eax
je 0x5be64
jmp 0x5bd9c
movl 0x4(%rsp), %eax
subl $0xa, %eax
je 0x5be3a
jmp 0x5bdab
movl 0x4(%rsp), %eax
subl $0xd, %eax
je 0x5be4f
jmp 0x5bdba
movl 0x4(%rsp), %eax
subl $0x22, %eax
je 0x5bdf0
jmp 0x5bdc5
movl 0x4(%rsp), %eax
subl $0x5c, %eax
je 0x5be25
jmp 0x5be79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0xc7a0
jmp 0x5becc
leaq 0x73021(%rip), %rsi     # 0xcee18
leaq 0x58(%rsp), %rdi
callq 0xc6e0
jmp 0x5be03
jmp 0x5be8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xce98
jmp 0x5becc
leaq 0x71e64(%rip), %rsi     # 0xcdc90
leaq 0x58(%rsp), %rdi
callq 0xc6e0
jmp 0x5be38
jmp 0x5be8c
leaq 0x71e52(%rip), %rsi     # 0xcdc93
leaq 0x58(%rsp), %rdi
callq 0xc6e0
jmp 0x5be4d
jmp 0x5be8c
leaq 0x72fc5(%rip), %rsi     # 0xcee1b
leaq 0x58(%rsp), %rdi
callq 0xc6e0
jmp 0x5be62
jmp 0x5be8c
leaq 0x72fb0(%rip), %rsi     # 0xcee1b
leaq 0x58(%rsp), %rdi
callq 0xc6e0
jmp 0x5be77
jmp 0x5be8c
movsbl 0x27(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0xc4c0
jmp 0x5be8a
jmp 0x5be8c
jmp 0x5be8e
leaq 0x30(%rsp), %rdi
callq 0x737b0
jmp 0x5bd60
movq 0x10(%rsp), %rdi
leaq 0x71c02(%rip), %rdx     # 0xcdaab
leaq 0x58(%rsp), %rsi
callq 0x2d9a0
jmp 0x5beb5
leaq 0x58(%rsp), %rdi
callq 0xce98
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getString[abi:cxx11]() const
string Json::getString () const
{ 
  const auto* this_ = this;
  if (! this_ || asJsonNull ())
    throw logic_error ("undefined");
  if (const JsonString* j = asJsonString ())
    return j->s;
  throw logic_error ("Not a JsonString");
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x5c573
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, %rax
je 0x5c5cb
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x728b1(%rip), %rsi     # 0xcee40
callq 0xca70
jmp 0x5c596
movq 0x8(%rsp), %rdi
movq 0xa9a26(%rip), %rsi     # 0x105fc8
movq 0xa99d7(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xc580
jmp 0x5c650
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x5c600
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
callq 0xc320
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x7282f(%rip), %rsi     # 0xcee4a
callq 0xca70
jmp 0x5c622
movq (%rsp), %rdi
movq 0xa999b(%rip), %rsi     # 0x105fc8
movq 0xa994c(%rip), %rdx     # 0x105f80
callq 0xcc80
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xc580
movq 0x38(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getInt() const
long long Json::getInt () const
{ 
  const auto* this_ = this;
  if (! this_ || asJsonNull ())
    throw logic_error ("undefined");
  if (const JsonInt* j = asJsonInt ())
    return j->n;
  throw logic_error ("Not a JsonInt");
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x5c691
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, %rax
je 0x5c6e6
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x72793(%rip), %rsi     # 0xcee40
callq 0xca70
jmp 0x5c6b4
movq 0x10(%rsp), %rdi
movq 0xa9908(%rip), %rsi     # 0x105fc8
movq 0xa98b9(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xc580
jmp 0x5c75f
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x5c70c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x48, %rsp
retq
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x72733(%rip), %rsi     # 0xcee5b
callq 0xca70
jmp 0x5c72f
movq 0x8(%rsp), %rdi
movq 0xa988d(%rip), %rsi     # 0x105fc8
movq 0xa983e(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xc580
movq 0x30(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getDouble() const
double Json::getDouble () const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return numeric_limits<double>::quiet_NaN ();
  if (const JsonDouble* j = asJsonDouble ())
    return j->n;
  throw logic_error ("Not a JsonDouble");
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x5c7e8
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x72694(%rip), %rsi     # 0xcee40
callq 0xca70
jmp 0x5c7b3
movq 0x8(%rsp), %rdi
movq 0xa9809(%rip), %rsi     # 0x105fc8
movq 0xa97ba(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xc580
jmp 0x5c88d
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, %rax
je 0x5c806
callq 0x75ce0
movsd %xmm0, 0x40(%rsp)
jmp 0x5c882
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5c830
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x5c882
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x7261e(%rip), %rsi     # 0xcee69
callq 0xca70
jmp 0x5c852
movq (%rsp), %rdi
movq 0xa976b(%rip), %rsi     # 0x105fc8
movq 0xa971c(%rip), %rdx     # 0x105f80
callq 0xcc80
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xc580
jmp 0x5c88d
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getBoolean() const
bool Json::getBoolean () const
{ 
  const auto* this_ = this;
  if (! this_ || asJsonNull ())
    throw logic_error ("undefined");
  if (const JsonBoolean* j = asJsonBoolean ())
    return j->b;
  throw logic_error ("Not a JsonBoolean");
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x5c8d1
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, %rax
je 0x5c926
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x72553(%rip), %rsi     # 0xcee40
callq 0xca70
jmp 0x5c8f4
movq 0x10(%rsp), %rdi
movq 0xa96c8(%rip), %rsi     # 0x105fc8
movq 0xa9679(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xc580
jmp 0x5c9a0
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x5c94d
movq 0x20(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
addq $0x48, %rsp
retq
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x72511(%rip), %rsi     # 0xcee7a
callq 0xca70
jmp 0x5c970
movq 0x8(%rsp), %rdi
movq 0xa964c(%rip), %rsi     # 0x105fc8
movq 0xa95fd(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xc580
movq 0x30(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Json::at(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const Json* Json::at (const string& name_arg) const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return nullptr;
  if (const JsonMap* j = asJsonMap ())
    return findPtr (j->data, name_arg);
  throw logic_error ("Not a JsonMap");
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x5ca2d
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x7244f(%rip), %rsi     # 0xcee40
callq 0xca70
jmp 0x5c9f8
movq 0x10(%rsp), %rdi
movq 0xa95c4(%rip), %rsi     # 0x105fc8
movq 0xa9575(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xc580
jmp 0x5cadd
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, %rax
je 0x5ca4c
movq $0x0, 0x50(%rsp)
jmp 0x5cad3
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x5ca7e
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x40(%rsp), %rsi
callq 0x75cf0
movq %rax, 0x50(%rsp)
jmp 0x5cad3
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x723f2(%rip), %rsi     # 0xcee8c
callq 0xca70
jmp 0x5caa1
movq 0x8(%rsp), %rdi
movq 0xa951b(%rip), %rsi     # 0x105fc8
movq 0xa94cc(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xc580
jmp 0x5cadd
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Json::at(unsigned long) const
const Json* Json::at (size_t index) const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return nullptr;
  if (const JsonArray* j = asJsonArray ())
  {
    if (index >= j->data. size ())
      throw runtime_error (FUNC "Index out of range");
    else
      return j->data [index];
  }
  throw logic_error ("Not a JsonArray");
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
jne 0x5cb85
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
leaq 0x722fd(%rip), %rsi     # 0xcee40
callq 0xca70
jmp 0x5cb4a
movq 0x28(%rsp), %rdi
movq 0xa9472(%rip), %rsi     # 0x105fc8
movq 0xa9423(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0xc580
jmp 0x5cd85
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, %rax
je 0x5cba7
movq $0x0, 0xb0(%rsp)
jmp 0x5cd75
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, 0x80(%rsp)
cmpq $0x0, 0x80(%rsp)
je 0x5cd1a
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rdi
addq $0x8, %rdi
callq 0x75d40
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jb 0x5ccf4
movb $0x1, 0x3e(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, 0x10(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xcd00
movq 0x18(%rsp), %rdx
leaq 0x72273(%rip), %rsi     # 0xcee9a
leaq 0x40(%rsp), %rdi
callq 0x29fd0
jmp 0x5cc33
leaq 0x7228e(%rip), %rdx     # 0xceec8
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2a2f0
jmp 0x5cc4b
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xcbb0
jmp 0x5cc5c
movq 0x10(%rsp), %rdi
movb $0x0, 0x3e(%rsp)
movq 0xa9383(%rip), %rsi     # 0x105ff0
movq 0xa92fc(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x5cd92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5ccd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5ccc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xce98
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x3f(%rsp), %rdi
callq 0xc7a0
testb $0x1, 0x3e(%rsp)
jne 0x5cce5
jmp 0x5ccef
movq 0x10(%rsp), %rdi
callq 0xc580
jmp 0x5cd85
movq 0x80(%rsp), %rdi
addq $0x8, %rdi
movq 0xa0(%rsp), %rsi
callq 0x75d60
movq (%rax), %rax
movq %rax, 0xb0(%rsp)
jmp 0x5cd75
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x721a7(%rip), %rsi     # 0xceedd
callq 0xca70
jmp 0x5cd3d
movq 0x8(%rsp), %rdi
movq 0xa927f(%rip), %rsi     # 0x105fc8
movq 0xa9230(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0xc580
jmp 0x5cd85
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Json::getSize() const
size_t Json::getSize () const
{ 
  const auto* this_ = this;
  if (! this_)
    throw logic_error ("undefined");
  if (asJsonNull ())
    return 0;
  if (const JsonArray* j = asJsonArray ())
    return j->data. size ();
  throw logic_error ("Not a JsonArray");
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x5ce18
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x72064(%rip), %rsi     # 0xcee40
callq 0xca70
jmp 0x5cde3
movq 0x8(%rsp), %rdi
movq 0xa91d9(%rip), %rsi     # 0x105fc8
movq 0xa918a(%rip), %rdx     # 0x105f80
callq 0xcc80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xc580
jmp 0x5cebd
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, %rax
je 0x5ce34
movq $0x0, 0x40(%rsp)
jmp 0x5ceb3
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5ce61
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x75d40
movq %rax, 0x40(%rsp)
jmp 0x5ceb3
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x72061(%rip), %rsi     # 0xceedd
callq 0xca70
jmp 0x5ce83
movq (%rsp), %rdi
movq 0xa913a(%rip), %rsi     # 0x105fc8
movq 0xa90eb(%rip), %rdx     # 0x105f80
callq 0xcc80
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xc580
jmp 0x5cebd
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::JsonArray::JsonArray(Common_sp::CharInput&, Common_sp::JsonContainer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
JsonArray::JsonArray (CharInput& in,
                      JsonContainer* parent,
                      const string& name)
: JsonContainer (parent, name)
{
  bool first = true;
  for (;;)
  {
    Token token (in, false, false);
    if (token. isDelimiter (']'))
      break;
    if (! first)
    {
      if (! token. isDelimiter (','))
        in. error ("\',\'");
      token = Token (in, false, false);
    }
    parse (in, token, this, noString);
    first = false;
  }
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
movq 0x140(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x130(%rsp), %rsi
movq 0x128(%rsp), %rdx
callq 0x75e20
movq 0x18(%rsp), %rdi
leaq 0xa7aab(%rip), %rax     # 0x1049d0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x20(%rsp)
callq 0x75e70
movb $0x1, 0x127(%rsp)
movq 0x138(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x75330
jmp 0x5cf5d
leaq 0xc0(%rsp), %rdi
movl $0x5d, %esi
callq 0x75410
movb %al, 0x17(%rsp)
jmp 0x5cf75
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x5cf7f
jmp 0x5cfc1
movl $0x2, 0xb0(%rsp)
jmp 0x5d0f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x5d131
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x5d11a
testb $0x1, 0x127(%rsp)
jne 0x5d0c3
leaq 0xc0(%rsp), %rdi
movl $0x2c, %esi
callq 0x75410
movb %al, 0x16(%rsp)
jmp 0x5cfe7
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0x5d08f
jmp 0x5cff5
movq 0x138(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x71ece(%rip), %rsi     # 0xceeed
leaq 0x90(%rsp), %rdi
callq 0x29fd0
jmp 0x5d02e
movq (%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x1, %edx
callq 0x748c0
jmp 0x5d046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x5d07d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xce98
leaq 0x8f(%rsp), %rdi
callq 0xc7a0
jmp 0x5d11a
movq 0x138(%rsp), %rsi
leaq 0x28(%rsp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x75330
jmp 0x5d0a7
leaq 0xc0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x75240
leaq 0x28(%rsp), %rdi
callq 0x752b0
movq 0x18(%rsp), %rdx
movq 0x138(%rsp), %rdi
leaq 0xa9bc1(%rip), %rcx     # 0x106c98
leaq 0xc0(%rsp), %rsi
callq 0x5bee0
jmp 0x5d0e6
movb $0x0, 0x127(%rsp)
movl $0x0, 0xb0(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x752b0
movl 0xb0(%rsp), %eax
testl %eax, %eax
je 0x5d115
jmp 0x5d113
jmp 0x5d129
jmp 0x5cf42
leaq 0xc0(%rsp), %rdi
callq 0x752b0
jmp 0x5d131
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x20(%rsp), %rdi
callq 0x75e80
movq 0x18(%rsp), %rdi
callq 0x79ab0
movq 0xb8(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::JsonMap::JsonMap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
JsonMap::JsonMap (const string &fName)
{
  CharInput in (fName);
  const Token token (in, false, false);
  if (! token. isDelimiter ('{'))
    in. error ("Json file " + shellQuote (fName) + ": text should start with '{'", false);
  parse (in);
}

// Assembly:
subq $0x388, %rsp            # imm = 0x388
movq %rdi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq 0x380(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x75f90
movq 0x8(%rsp), %rdi
leaq 0xa722b(%rip), %rax     # 0x104a70
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x75fc0
movq 0x378(%rsp), %rsi
leaq 0x108(%rsp), %rdi
xorl %edx, %edx
callq 0x76030
jmp 0x5d86f
leaq 0x98(%rsp), %rdi
leaq 0x108(%rsp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x75330
jmp 0x5d88a
leaq 0x98(%rsp), %rdi
movl $0x7b, %esi
callq 0x75410
movb %al, 0x7(%rsp)
jmp 0x5d8a2
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x5d9e6
jmp 0x5d8b0
movq 0x378(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc320
jmp 0x5d8c4
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2d3d0
jmp 0x5d8d5
leaq 0x7167c(%rip), %rsi     # 0xcef58
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x2a340
jmp 0x5d8ed
leaq 0x7166f(%rip), %rdx     # 0xcef63
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2a2f0
jmp 0x5d905
leaq 0x108(%rsp), %rdi
leaq 0x78(%rsp), %rsi
xorl %edx, %edx
callq 0x748c0
jmp 0x5d91b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x5da36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x5da29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x5da1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x5d9da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x5d9d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x5d9c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xce98
leaq 0x58(%rsp), %rdi
callq 0xce98
leaq 0x38(%rsp), %rdi
callq 0xce98
leaq 0x18(%rsp), %rdi
callq 0xce98
jmp 0x5da1c
movq 0x8(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x5da60
jmp 0x5d9fa
leaq 0x98(%rsp), %rdi
callq 0x752b0
leaq 0x108(%rsp), %rdi
callq 0x76090
addq $0x388, %rsp            # imm = 0x388
retq
leaq 0x98(%rsp), %rdi
callq 0x752b0
leaq 0x108(%rsp), %rdi
callq 0x76090
movq 0x10(%rsp), %rdi
callq 0x76020
movq 0x8(%rsp), %rdi
callq 0x79ab0
movq 0x100(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::FileItemGenerator::next(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool FileItemGenerator::next (string &item)
{ 
  if (f. eof ())
    return false;
    
	readLine (f, item);
  if (! tsv)
    trim (item);
  if (item. empty () && f. eof ())
    return false;

  prog (item);
    
	return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, %rdi
addq $0x68, %rdi
movq 0x68(%rax), %rax
addq -0x18(%rax), %rdi
callq 0xcd60
testb $0x1, %al
jne 0x5edc2
jmp 0x5edc9
movb $0x0, 0x27(%rsp)
jmp 0x5ee42
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
movq 0x10(%rsp), %rsi
callq 0x49bd0
movq 0x8(%rsp), %rax
testb $0x1, 0x270(%rax)
jne 0x5edf4
movq 0x10(%rsp), %rdi
callq 0x73800
movq 0x10(%rsp), %rdi
callq 0xcc10
testb $0x1, %al
jne 0x5ee04
jmp 0x5ee2a
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x68, %rdi
movq 0x68(%rax), %rax
addq -0x18(%rax), %rdi
callq 0xcd60
testb $0x1, %al
jne 0x5ee23
jmp 0x5ee2a
movb $0x0, 0x27(%rsp)
jmp 0x5ee42
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
callq 0x4bb30
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::SoftwareVersion::SoftwareVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SoftwareVersion::SoftwareVersion (const string &fName)
{ 
  StringVector vec (fName, (size_t) 1, true);
  if (vec. size () != 1)
    throw runtime_error ("Cannot read software version. One line is expected in the file: " + shellQuote (fName));
  init (std::move (vec [0]), false);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2aad0
movq 0x18(%rsp), %rax
leaq 0xa574b(%rip), %rcx     # 0x104fe0
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq 0xb8(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x4d940
jmp 0x5f8ce
leaq 0x98(%rsp), %rdi
callq 0x2f390
cmpq $0x1, %rax
je 0x5fa0b
movb $0x1, 0x27(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, 0x10(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xc320
jmp 0x5f90d
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2d3d0
jmp 0x5f91e
leaq 0x6f81a(%rip), %rsi     # 0xcf13f
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x2a340
jmp 0x5f936
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xcbb0
jmp 0x5f947
movq 0x10(%rsp), %rdi
movb $0x0, 0x27(%rsp)
movq 0xa6698(%rip), %rsi     # 0x105ff0
movq 0xa6611(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x5fa83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5fa6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5f9f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5f9ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5f9e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xce98
leaq 0x48(%rsp), %rdi
callq 0xce98
leaq 0x28(%rsp), %rdi
callq 0xce98
testb $0x1, 0x27(%rsp)
jne 0x5f9ff
jmp 0x5fa09
movq 0x10(%rsp), %rdi
callq 0xc580
jmp 0x5fa5f
xorl %eax, %eax
movl %eax, %esi
leaq 0x98(%rsp), %rdi
callq 0x2f970
movq %rax, 0x8(%rsp)
jmp 0x5fa23
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
xorl %edx, %edx
callq 0x5fa90
jmp 0x5fa36
leaq 0x98(%rsp), %rdi
callq 0x2eef0
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x2eef0
movq 0x18(%rsp), %rdi
callq 0x2ab40
movq 0x90(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::SoftwareVersion::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, bool)
void SoftwareVersion::init (string &&s,
                            bool minorOnly)
{ 
  try 
  { 
    major = str2<uint> (findSplit (s, '.'));
    if (minorOnly)
      minor = str2<uint> (s);
    else
    { 
      minor = str2<uint> (findSplit (s, '.'));
      patch = str2<uint> (s);
    }
  } 
  catch (...) 
  { 
    throw runtime_error ("Cannot read software version"); 
  }
}

// Assembly:
subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movl $0x2e, %edx
callq 0x42f40
jmp 0x5facf
leaq 0x50(%rsp), %rdi
callq 0x30a10
movl %eax, 0x14(%rsp)
jmp 0x5fadf
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
leaq 0x50(%rsp), %rdi
callq 0xce98
testb $0x1, 0x77(%rsp)
je 0x5fb4a
movq 0x78(%rsp), %rdi
callq 0x30a10
movl %eax, 0x10(%rsp)
jmp 0x5fb0c
movq 0x18(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, 0xc(%rax)
jmp 0x5fc01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x5fbbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xce98
jmp 0x5fbbc
movq 0x78(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x2e, %edx
callq 0x42f40
jmp 0x5fb60
leaq 0x20(%rsp), %rdi
callq 0x30a10
movl %eax, 0xc(%rsp)
jmp 0x5fb70
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0xc(%rax)
leaq 0x20(%rsp), %rdi
callq 0xce98
movq 0x78(%rsp), %rdi
callq 0x30a10
movl %eax, 0x8(%rsp)
jmp 0x5fb96
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x5fc01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xce98
movq 0x48(%rsp), %rdi
callq 0xc2f0
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x6f59f(%rip), %rsi     # 0xcf180
callq 0xc2e0
jmp 0x5fbe8
movq (%rsp), %rdi
movq 0xa63fd(%rip), %rsi     # 0x105ff0
movq 0xa6376(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x5fc4d
jmp 0x5fc33
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0xc580
jmp 0x5fc2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0xcbe0
jmp 0x5fc31
jmp 0x5fc3b
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xccf0
movq %rax, %rdi
callq 0x2ad70
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::SoftwareVersion::operator<(Common_sp::SoftwareVersion const&) const
bool SoftwareVersion::operator< (const SoftwareVersion &other) const
{ 
  LESS_PART (*this, other, major);
  LESS_PART (*this, other, minor);
  LESS_PART (*this, other, patch);
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x5fd3b
movb $0x1, -0x1(%rsp)
jmp 0x5fdbd
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
jae 0x5fd54
movb $0x0, -0x1(%rsp)
jmp 0x5fdbd
movq -0x20(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x5fd6d
movb $0x1, -0x1(%rsp)
jmp 0x5fdbd
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0xc(%rax), %eax
cmpl 0xc(%rcx), %eax
jae 0x5fd86
movb $0x0, -0x1(%rsp)
jmp 0x5fdbd
movq -0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x5fd9f
movb $0x1, -0x1(%rsp)
jmp 0x5fdbd
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0x10(%rax), %eax
cmpl 0x10(%rcx), %eax
jae 0x5fdb8
movb $0x0, -0x1(%rsp)
jmp 0x5fdbd
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::DataVersion::DataVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
DataVersion::DataVersion (const string &fName)
{ 
  StringVector vec (fName, (size_t) 1, true);
  if (vec. size () != 1)
    throw runtime_error ("Cannot read data version. One line is expected in the file: " + shellQuote (fName));
  init (std::move (vec [0]));
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2aad0
movq 0x18(%rsp), %rax
leaq 0xa5233(%rip), %rcx     # 0x105038
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movq 0xb8(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x4d940
jmp 0x5fe45
leaq 0x98(%rsp), %rdi
callq 0x2f390
cmpq $0x1, %rax
je 0x5ff82
movb $0x1, 0x27(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, 0x10(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xc320
jmp 0x5fe84
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2d3d0
jmp 0x5fe95
leaq 0x6f301(%rip), %rsi     # 0xcf19d
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x2a340
jmp 0x5fead
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xcbb0
jmp 0x5febe
movq 0x10(%rsp), %rdi
movb $0x0, 0x27(%rsp)
movq 0xa6121(%rip), %rsi     # 0x105ff0
movq 0xa609a(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x5fff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5ffe1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5ff6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5ff63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x5ff59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xce98
leaq 0x48(%rsp), %rdi
callq 0xce98
leaq 0x28(%rsp), %rdi
callq 0xce98
testb $0x1, 0x27(%rsp)
jne 0x5ff76
jmp 0x5ff80
movq 0x10(%rsp), %rdi
callq 0xc580
jmp 0x5ffd4
xorl %eax, %eax
movl %eax, %esi
leaq 0x98(%rsp), %rdi
callq 0x2f970
movq %rax, 0x8(%rsp)
jmp 0x5ff9a
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x60000
jmp 0x5ffab
leaq 0x98(%rsp), %rdi
callq 0x2eef0
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x2eef0
movq 0x18(%rsp), %rdi
callq 0x2ab40
movq 0x90(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::DataVersion::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
void DataVersion::init (string &&s)
{ 
  try
  { 
    year  = str2<uint> (findSplit (s, '-'));
    month = str2<uint> (findSplit (s, '-'));
    day   = str2<uint> (findSplit (s, '.'));
    num   = str2<uint> (s);
  } 
  catch (...) 
  { 
    throw runtime_error ("Cannot read data version"); 
  }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movl $0x2d, %edx
callq 0x42f40
jmp 0x6003d
leaq 0x78(%rsp), %rdi
callq 0x30a10
movl %eax, 0x1c(%rsp)
jmp 0x6004d
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
leaq 0x78(%rsp), %rdi
callq 0xce98
movq 0x98(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x2d, %edx
callq 0x42f40
jmp 0x6007c
leaq 0x48(%rsp), %rdi
callq 0x30a10
movl %eax, 0x18(%rsp)
jmp 0x6008c
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
movl %ecx, 0xc(%rax)
leaq 0x48(%rsp), %rdi
callq 0xce98
movq 0x98(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0x2e, %edx
callq 0x42f40
jmp 0x600bb
leaq 0x28(%rsp), %rdi
callq 0x30a10
movl %eax, 0x14(%rsp)
jmp 0x600cb
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
leaq 0x28(%rsp), %rdi
callq 0xce98
movq 0x98(%rsp), %rdi
callq 0x30a10
movl %eax, 0x10(%rsp)
jmp 0x600f4
movq 0x20(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, 0x14(%rax)
jmp 0x601d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x60161
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xce98
jmp 0x60161
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xce98
jmp 0x60161
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xce98
movq 0x70(%rsp), %rdi
callq 0xc2f0
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x6f053(%rip), %rsi     # 0xcf1da
callq 0xc2e0
jmp 0x6018e
movq 0x8(%rsp), %rdi
movq 0xa5e56(%rip), %rsi     # 0x105ff0
movq 0xa5dcf(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x601f3
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0xc580
jmp 0x601d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0xcbe0
jmp 0x601d7
jmp 0x601e1
addq $0xa8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0xccf0
movq %rax, %rdi
callq 0x2ad70
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::DataVersion::operator<(Common_sp::DataVersion const&) const
bool DataVersion::operator< (const DataVersion &other) const
{ 
  LESS_PART (*this, other, year);
  LESS_PART (*this, other, month);
  LESS_PART (*this, other, day);
  LESS_PART (*this, other, num);
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x602eb
movb $0x1, -0x1(%rsp)
jmp 0x603a5
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
jae 0x60307
movb $0x0, -0x1(%rsp)
jmp 0x603a5
movq -0x20(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x60323
movb $0x1, -0x1(%rsp)
jmp 0x603a5
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0xc(%rax), %eax
cmpl 0xc(%rcx), %eax
jae 0x6033c
movb $0x0, -0x1(%rsp)
jmp 0x603a5
movq -0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x60355
movb $0x1, -0x1(%rsp)
jmp 0x603a5
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0x10(%rax), %eax
cmpl 0x10(%rcx), %eax
jae 0x6036e
movb $0x0, -0x1(%rsp)
jmp 0x603a5
movq -0x20(%rsp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x60387
movb $0x1, -0x1(%rsp)
jmp 0x603a5
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x14(%rcx), %eax
jae 0x603a0
movb $0x0, -0x1(%rsp)
jmp 0x603a5
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: ncbi[P]amr/common.cpp
// Function: Common_sp::Application::Key::saveText(std::ostream&) const
void Application::Key::saveText (ostream &os) const
{
  os << '-';
	if (app. gnu)
	{
		os << "-" << name;
		if (! flag)
			os << ' ' << var;
	}
	else
	{
	  os << name; 
	  if (! flag)
	  {
	    os << ' ';
	    const bool quoted = defaultValue. empty () || contains (defaultValue, ' ');
	    if (quoted)
	      os << '\"';
	    os << defaultValue;
	    if (quoted)
	      os << '\"';
	  }
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2d, %esi
callq 0xc870
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rax
testb $0x1, 0xa9(%rax)
je 0x62cae
movq 0x18(%rsp), %rdi
leaq 0x6a29b(%rip), %rsi     # 0xccf00
callq 0xc6f0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0xc660
movq 0x8(%rsp), %rax
testb $0x1, 0x70(%rax)
jne 0x62ca9
movq 0x18(%rsp), %rdi
movl $0x20, %esi
callq 0xc870
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0xa0, %rsi
callq 0xc660
jmp 0x62d67
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x8, %rsi
callq 0xc660
movq 0x8(%rsp), %rax
testb $0x1, 0x70(%rax)
jne 0x62d65
movq 0x18(%rsp), %rdi
movl $0x20, %esi
callq 0xc870
movq 0x8(%rsp), %rdi
addq $0xc0, %rdi
callq 0xcc10
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x62d17
movq 0x8(%rsp), %rdi
addq $0xc0, %rdi
movl $0x20, %esi
callq 0x2dbd0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
je 0x62d37
movq 0x18(%rsp), %rdi
movl $0x22, %esi
callq 0xc870
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0xc0, %rsi
callq 0xc660
testb $0x1, 0x17(%rsp)
je 0x62d63
movq 0x18(%rsp), %rdi
movl $0x22, %esi
callq 0xc870
jmp 0x62d65
jmp 0x62d67
addq $0x28, %rsp
retq
nopl (%rax)