LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: BaseStr::BaseStr2Str[abi:cxx11](std::vector<char, std::allocator<char>> const&)
static std::string BaseStr2Str(const std::vector<char>& base) {
        int len = base.size();
        std::string ret ;
        if ( len < 1 )
        {
            return ret ;
        }
        ret.resize(len);
        for( int i = 0 ; i < len ; i++ )
            ret[i] = int2base(base.at(i));
        return ret ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8ec0
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x43d0
cmpl $0x1, -0x14(%rbp)
jge 0x81ca
movb $0x1, -0x15(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x8255
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x43c0
jmp 0x81d9
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x824a
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x8f40
movq %rax, -0x48(%rbp)
jmp 0x81fb
movq -0x48(%rbp), %rax
movsbl (%rax), %edi
callq 0x12bb0
movb %al, -0x49(%rbp)
jmp 0x820c
movq -0x38(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x45b0
movq %rax, -0x58(%rbp)
jmp 0x821f
movq -0x58(%rbp), %rax
movb -0x49(%rbp), %cl
movb %cl, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x81e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x41d0
jmp 0x826e
movb $0x1, -0x15(%rbp)
movl $0x1, -0x1c(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x8264
movq -0x38(%rbp), %rdi
callq 0x41d0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4550
nopw (%rax,%rax)
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: Kmer::ToBaseStr(Kmer const&)
static std::vector<char> ToBaseStr(const Kmer & k){
        Kmer tmp = k;
        std::vector<char> kmer;
        kmer.resize(overlap);
        for( int i = 0 ; i <overlap ; i++ ) {
            char next = tmp.low & 0x3 ;
            kmer[overlap-1-i]=next;
            tmp.RightBitMoveBy2();
        }
        return kmer;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x93b0
movq -0x48(%rbp), %rdi
movslq 0x1b10a(%rip), %rsi     # 0x233c4
callq 0x93d0
jmp 0x82c1
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl 0x1b0f3(%rip), %eax     # 0x233c4
jge 0x832c
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
andq $0x3, %rax
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
movb %al, -0x51(%rbp)
movl 0x1b0d6(%rip), %eax     # 0x233c4
subl $0x1, %eax
subl -0x38(%rbp), %eax
movslq %eax, %rsi
callq 0x83c0
movb -0x51(%rbp), %cl
movb %cl, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x12b70
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x82c8
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x72b0
jmp 0x8349
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x833f
movq -0x48(%rbp), %rdi
callq 0x72b0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: Kmer::createFilter(int)
static Kmer createFilter ( int overlaplen )
    {
        Kmer word;
        word.high = word.low = 0;

        if ( 2 * overlaplen < 64 )
        {
            word.low = ( ( ( ubyte8) 1 ) << ( 2 * overlaplen ) ) - 1;
        }
        else
        {
            word.low = ~word.low;

            if ( 2 * overlaplen > 64 )
            {
                word.high = ( ( ( ubyte8 ) 1 ) << ( 2 * overlaplen - 64 ) ) - 1;
            }
        }
        return word;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x14(%rbp)
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x14(%rbp), %eax
shll %eax
cmpl $0x40, %eax
jge 0x8e7c
movl -0x14(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x8eb0
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
shll %eax
cmpl $0x40, %eax
jle 0x8eae
movl -0x14(%rbp), %eax
shll %eax
subl $0x40, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8eb0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw (%rax,%rax)
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: Kmer::LeftBitMoveBy2()
void LeftBitMoveBy2() 
    {
        ubyte8 temp = low >> 62;
        high <<= 2;
        high |= temp;
        low <<= 2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x3e, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
shlq $0x2, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
orq (%rax), %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rcx
shlq $0x2, %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: Kmer::operator<(Kmer const&) const
bool operator < ( const Kmer & kmer1) const
    {
        if ( high < kmer1.high )
        {
            return 1;
        }
        else if ( high == kmer1.high )
        {
            if ( low < kmer1.low )
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        else
        {
            return 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x8fe6
movb $0x1, -0x1(%rbp)
jmp 0x9018
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x9014
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x900e
movb $0x1, -0x1(%rbp)
jmp 0x9018
movb $0x0, -0x1(%rbp)
jmp 0x9018
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: Kmer::RightBitMove(int)
void RightBitMove (int dis )
    {
        if ( dis < 64 )
        {
            ubyte8 mask = ( ( ( ubyte8 ) 1 ) << dis ) - 1;
            ubyte8 temp = ( high & mask ) << ( 64 - dis );
            high >>= dis;
            low >>= dis;
            low |= temp;
        }
        high >>= ( dis - 64 );
        low = high;
        high = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x937e
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdx
andq -0x18(%rbp), %rdx
movl $0x40, %ecx
subl -0xc(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq (%rax), %rdx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq 0x8(%rax), %rdx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x40, %ecx
movq (%rax), %rdx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: BaseStr::reverseComplementSeq(std::vector<char, std::allocator<char>> const&)
static std::vector<char> reverseComplementSeq ( const std::vector<char> & str  )
    {
        int len = str.size();
        std::vector<char> ret ;
        if ( len < 1 )
        {
            return ret ;
        }
        ret.resize(len);
        for ( int i = len - 1 , index = 0; i >= 0; i-- , index ++ )
        {
            ret[index] = int_comp (str.at(i));
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8ec0
movq -0x40(%rbp), %rdi
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x93b0
cmpl $0x1, -0x14(%rbp)
jge 0x1212a
movb $0x1, -0x15(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x121bb
movq -0x40(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x93d0
jmp 0x12139
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0x121b0
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x8f40
movq %rax, -0x50(%rbp)
jmp 0x12162
movq -0x50(%rbp), %rax
movsbl (%rax), %edi
callq 0x123d0
movb %al, -0x51(%rbp)
jmp 0x12173
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x83c0
movb -0x51(%rbp), %cl
movb %cl, (%rax)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12149
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x72b0
jmp 0x121d4
movb $0x1, -0x15(%rbp)
movl $0x1, -0x1c(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x121ca
movq -0x40(%rbp), %rdi
callq 0x72b0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4550
nopl (%rax)
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: Kmer::prevKmer(char)
void prevKmer ( char ch )
    {
        RightBitMoveBy2();
        if ( 2 * ( overlap - 1 ) < 64 )
        {
            low |= ( ( ( ubyte8 ) ch ) << 2 * ( overlap - 1 ) );
        }
        else
        {
            high |= ( ( ubyte8 ) ch ) << ( 2 * ( overlap - 1 ) - 64 );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x12b70
movl 0x110ff(%rip), %eax     # 0x233c4
subl $0x1, %eax
shll %eax
cmpl $0x40, %eax
jge 0x122f5
movq -0x18(%rbp), %rax
movsbq -0x9(%rbp), %rdx
movl 0x110e6(%rip), %ecx     # 0x233c4
subl $0x1, %ecx
shll %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1231a
movq -0x18(%rbp), %rax
movsbq -0x9(%rbp), %rdx
movl 0x110c0(%rip), %ecx     # 0x233c4
subl $0x1, %ecx
shll %ecx
subl $0x40, %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
orq (%rax), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: Kmer::RightBitMoveBy2()
void RightBitMoveBy2()
    {
      ubyte8 temp = ( high & 0x3 ) << 62;
      high >>= 2;
      low >>= 2;
      low |= temp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
andq $0x3, %rcx
shlq $0x3e, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
shrq $0x2, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nop
// File: sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::print(std::ostream&)
void print(std::ostream &os) {
		os << "+";
		for(int j = 0; j < width; ++j) {
			os << "-";
		}
		os << "+" << std::endl;
		for(int i = 0; i < height; ++i) {
			os << "|";
			for(int j = 0; j < width; ++j) {
				os << field[i * width + j].getChar();
			}
			os << "|" << std::endl;
		}
		os << "+";
		for(int j = 0; j < width; ++j) {
			os << "-";
		}
		os << "+" << std::endl << std::endl;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3cf6(%rip), %rsi      # 0xb1d9
callq 0x2140
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x7516
movq -0x10(%rbp), %rdi
leaq 0x3cd5(%rip), %rsi      # 0xb1db
callq 0x2140
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x74ef
movq -0x10(%rbp), %rdi
leaq 0x3cb8(%rip), %rsi      # 0xb1d9
callq 0x2140
movq %rax, %rdi
movq 0x8a80(%rip), %rsi      # 0xffb0
callq 0x2170
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x75d9
movq -0x10(%rbp), %rdi
leaq 0x3c86(%rip), %rsi      # 0xb1dd
callq 0x2140
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x75ac
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
imull 0x1c(%rdi), %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rsi
callq 0x8870
movq %rax, %rdi
callq 0x8890
movq -0x30(%rbp), %rdi
movsbl %al, %esi
callq 0x2180
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7563
movq -0x10(%rbp), %rdi
leaq 0x3c26(%rip), %rsi      # 0xb1dd
callq 0x2140
movq %rax, %rdi
movq 0x89ea(%rip), %rsi      # 0xffb0
callq 0x2170
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x753c
movq -0x10(%rbp), %rdi
leaq 0x3bf5(%rip), %rsi      # 0xb1d9
callq 0x2140
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x7617
movq -0x10(%rbp), %rdi
leaq 0x3bd4(%rip), %rsi      # 0xb1db
callq 0x2140
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x75f0
movq -0x10(%rbp), %rdi
leaq 0x3bb7(%rip), %rsi      # 0xb1d9
callq 0x2140
movq %rax, %rdi
movq 0x897f(%rip), %rsi      # 0xffb0
callq 0x2170
movq %rax, %rdi
movq 0x8970(%rip), %rsi      # 0xffb0
callq 0x2170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ncbi[P]amr/amrfinder.cpp
// Function: (anonymous namespace)::ThisApplication::prepare_fasta_extract(Common_sp::StringVector const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const
void prepare_fasta_extract (const StringVector &columns,
                              const string &tmpSuf,
                              bool saveHeader) const
  // Input: tmp + "/amr"
  {
    TextTable t (tmp + "/amr");
    t. qc ();
    t. filterColumns (columns);
    t. rows. filterValue ([] (const StringVector& row) { return row [0] == "NA"; });
    t. rows. sort ();
    t. rows. uniq ();
    t. saveHeader = saveHeader;
    t. qc ();
    t. saveFile (tmp + "/" + tmpSuf);
  }

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movb %cl, %al
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
andb $0x1, %al
movb %al, 0xff(%rsp)
movq 0x110(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x168, %rsi            # imm = 0x168
leaq 0xa30bf(%rip), %rdx     # 0xccdb4
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2d9a0
movq 0x10(%rsp), %rsi
leaq 0xdcf88(%rip), %rdx     # 0x106c98
leaq 0x88(%rsp), %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xb6b10
jmp 0x29d27
leaq 0x68(%rsp), %rdi
callq 0xce98
leaq 0x88(%rsp), %rdi
callq 0xb85f0
jmp 0x29d40
movq 0x108(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0xba550
jmp 0x29d57
leaq 0xd8(%rsp), %rdi
callq 0x29e90
jmp 0x29d66
leaq 0xd8(%rsp), %rdi
callq 0x3a7d0
jmp 0x29d75
leaq 0xd8(%rsp), %rdi
callq 0x30200
jmp 0x29d84
movb 0xff(%rsp), %al
andb $0x1, %al
movb %al, 0xb1(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xb85f0
jmp 0x29da3
movq 0x8(%rsp), %rsi
addq $0x168, %rsi            # imm = 0x168
leaq 0xa4648(%rip), %rdx     # 0xce3fe
leaq 0x18(%rsp), %rdi
callq 0x2d9a0
jmp 0x29dc2
movq 0x100(%rsp), %rdx
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2e220
jmp 0x29ddb
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4d6e0
jmp 0x29def
leaq 0x38(%rsp), %rdi
callq 0xce98
leaq 0x18(%rsp), %rdi
callq 0xce98
leaq 0x88(%rsp), %rdi
callq 0x30370
addq $0x118, %rsp            # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xce98
jmp 0x29e81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x29e74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x29e6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xce98
leaq 0x18(%rsp), %rdi
callq 0xce98
leaq 0x88(%rsp), %rdi
callq 0x30370
movq 0x60(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: void Common_sp::Vector<Common_sp::StringVector>::filterValue<(anonymous namespace)::ThisApplication::prepare_fasta_extract(Common_sp::StringVector const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const::'lambda'(Common_sp::StringVector const&)>((anonymous namespace)::ThisApplication::prepare_fasta_extract(Common_sp::StringVector const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const::'lambda'(Common_sp::StringVector const&))
void filterValue (const Condition cond)
        { size_t toDelete = 0;
          for (size_t i = 0, end_ = P::size (); i < end_; i++)
          { const size_t j = i - toDelete;
            if (j != i)
              (*this) [j] = std::move ((*this) [i]);
            if (cond ((*this) [j]))
              toDelete++;
          }
          while (toDelete)
          { P::pop_back ();
            toDelete--;
          }
        }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
callq 0x380d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x29f5f
movq 0x28(%rsp), %rax
subq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x29f1a
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x38120
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x38120
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3a810
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x38120
movq %rax, %rsi
leaq 0x47(%rsp), %rdi
callq 0x29f90
testb $0x1, %al
jne 0x29f3c
jmp 0x29f4a
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x29f4c
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x29ebf
jmp 0x29f61
cmpq $0x0, 0x30(%rsp)
je 0x29f83
movq 0x10(%rsp), %rdi
callq 0x3a840
movq 0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x29f61
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Application::arg2double(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
double arg2double (const string &name) const
    { double d = 0.0;
    	if (! str2<double> (getArg (name), d))
    	  throw runtime_error ("Cannot convert " + strQuote (name) + " to real number"); 
    	return d;
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rsi
movq $0x0, 0xb0(%rsp)
movq 0xb8(%rsp), %rdx
leaq 0x90(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x68600
movq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x30710
movb %al, 0x1e(%rsp)
jmp 0x2d63d
movb 0x1e(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xce98
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2d661
jmp 0x2d79c
movb $0x1, 0x1f(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, (%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x22, %edx
callq 0x424f0
jmp 0x2d68d
leaq 0x9f7e4(%rip), %rsi     # 0xcce78
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2a340
jmp 0x2d6a5
leaq 0x9f7dc(%rip), %rdx     # 0xcce88
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2a2f0
jmp 0x2d6bd
movq (%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xcbb0
jmp 0x2d6cd
movq (%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0xd8913(%rip), %rsi     # 0x105ff0
movq 0xd888c(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x2d7ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xce98
jmp 0x2d7ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2d788
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2d77e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2d774
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xce98
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
testb $0x1, 0x1f(%rsp)
jne 0x2d791
jmp 0x2d79a
movq (%rsp), %rdi
callq 0xc580
jmp 0x2d7ad
movsd 0xb0(%rsp), %xmm0
addq $0xc8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Application::arg2uint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
uint arg2uint (const string &name) const
    { uint n = 0;
    	if (! str2<uint> (getArg (name), n))
    	  throw runtime_error ("Cannot convert " + strQuote (name) + " to non-negative number"); 
    	return n;
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rsi
movl $0x0, 0xb4(%rsp)
movq 0xb8(%rsp), %rdx
leaq 0x90(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x68600
movq 0x10(%rsp), %rdi
leaq 0xb4(%rsp), %rsi
callq 0x309b0
movb %al, 0x1e(%rsp)
jmp 0x2d81c
movb 0x1e(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xce98
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2d840
jmp 0x2d97b
movb $0x1, 0x1f(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, (%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x22, %edx
callq 0x424f0
jmp 0x2d86c
leaq 0x9f605(%rip), %rsi     # 0xcce78
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2a340
jmp 0x2d884
leaq 0x9f618(%rip), %rdx     # 0xccea3
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2a2f0
jmp 0x2d89c
movq (%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xcbb0
jmp 0x2d8ac
movq (%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0xd8734(%rip), %rsi     # 0x105ff0
movq 0xd86ad(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x2d997
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xce98
jmp 0x2d98a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2d967
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2d95d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2d953
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xce98
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
testb $0x1, 0x1f(%rsp)
jne 0x2d970
jmp 0x2d979
movq (%rsp), %rdi
callq 0xc580
jmp 0x2d98a
movl 0xb4(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0xccf0
nopw (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Stderr& Common_sp::Stderr::operator<<<char [21]>(char const (&) [21])
Stderr& operator<< (const T& t) 
      { if (quiet)
          return *this;
        cerr << t;
        return *this;
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, (%rax)
je 0x2da59
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2da74
movq 0x10(%rsp), %rsi
movq 0xd8583(%rip), %rdi     # 0x105fe8
callq 0xc6f0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Dir::getParent[abi:cxx11]() const
string getParent () const
    { if (items. empty ())
        return "..";
      if (items. size () == 1 && items. front (). empty ())
        throw runtime_error ("Cannot get the parent directory of the root");
      const Dir parent (get () + "/..");
      return parent. get ();
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x2e190
testb $0x1, %al
jne 0x2e2ac
jmp 0x2e30e
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xcd00
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x9ec2c(%rip), %rsi     # 0xccefb
callq 0x29fd0
jmp 0x2e2d6
leaq 0xa7(%rsp), %rdi
callq 0xc7a0
jmp 0x2e462
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa7(%rsp), %rdi
callq 0xc7a0
jmp 0x2e46f
movq 0x30(%rsp), %rdi
callq 0x322f0
cmpq $0x1, %rax
jne 0x2e394
movq 0x30(%rsp), %rdi
callq 0x32300
movq %rax, %rdi
callq 0xcc10
testb $0x1, %al
jne 0x2e336
jmp 0x2e394
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x9eb7c(%rip), %rsi     # 0xccece
callq 0xc2e0
jmp 0x2e359
movq 0x10(%rsp), %rdi
movq 0xd7c8b(%rip), %rsi     # 0x105ff0
movq 0xd7c04(%rip), %rdx     # 0x105f70
callq 0xcc80
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0xc580
jmp 0x2e46f
movq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2e8c0
movq 0x8(%rsp), %rsi
leaq 0x9eb46(%rip), %rdx     # 0xccefa
leaq 0x58(%rsp), %rdi
callq 0x2a2f0
jmp 0x2e3c0
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x46b00
jmp 0x2e3d1
leaq 0x58(%rsp), %rdi
callq 0xce98
leaq 0x38(%rsp), %rdi
callq 0xce98
movq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x2e8c0
jmp 0x2e3f6
leaq 0x78(%rsp), %rdi
callq 0x2ebe0
jmp 0x2e462
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x2e436
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xce98
leaq 0x38(%rsp), %rdi
callq 0xce98
jmp 0x2e46f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2ebe0
jmp 0x2e46f
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0xccf0
nopl (%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::path2canonical(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline string path2canonical (const string &path)
    { if (char* p = realpath (path. c_str (), nullptr))
      { const string s (p);
        free (p);
        return s;
      }
      throw runtime_error ("path2canonical " + shellQuote (path));
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0xc300
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc260
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0x2ed0c
movb $0x0, 0xaf(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xae(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xcd00
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x29fd0
jmp 0x2eca1
leaq 0xae(%rsp), %rdi
callq 0xc7a0
movq 0xb0(%rsp), %rdi
callq 0xc8a0
movb $0x1, 0xaf(%rsp)
testb $0x1, 0xaf(%rsp)
jne 0x2ecff
jmp 0x2ecf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xae(%rsp), %rdi
callq 0xc7a0
jmp 0x2ee19
movq 0x20(%rsp), %rdi
callq 0xce98
movq 0x28(%rsp), %rax
addq $0xc8, %rsp
retq
movb $0x1, 0x37(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xc320
jmp 0x2ed34
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2d3d0
jmp 0x2ed45
leaq 0x9e1b6(%rip), %rsi     # 0xccf02
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x2a340
jmp 0x2ed5d
movq 0x8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xcbb0
jmp 0x2ed6e
movq 0x8(%rsp), %rdi
movb $0x0, 0x37(%rsp)
movq 0xd7271(%rip), %rsi     # 0x105ff0
movq 0xd71ea(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x2ee26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x2ee04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x2edfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x2edf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xce98
leaq 0x58(%rsp), %rdi
callq 0xce98
leaq 0x38(%rsp), %rdi
callq 0xce98
testb $0x1, 0x37(%rsp)
jne 0x2ee0d
jmp 0x2ee17
movq 0x8(%rsp), %rdi
callq 0xc580
jmp 0x2ee19
movq 0xa0(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::DirItemGenerator::next(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool next (string &item) final
    { if (index == vec. size ())
        return false;
      item = vec [index];
      prog (item);
      index++;      
      return true;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x68(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x48, %rdi
callq 0x2f390
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jne 0x2fc8d
movb $0x0, 0x27(%rsp)
jmp 0x2fcd5
movq (%rsp), %rax
movq %rax, %rdi
addq $0x48, %rdi
movq 0x68(%rax), %rsi
callq 0x2f970
movq %rax, %rsi
movq 0x10(%rsp), %rdi
callq 0xc080
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
callq 0x4bb30
movq (%rsp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Threads::exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
bool exec (const string cmd,
	           size_t cmdThreads = 1)
	  { if (cmdThreads && getAvailable () >= cmdThreads)
	    { *this << thread (Common_sp::exec, cmd, noString);
	      threadsToStart -= cmdThreads - 1;
	      return true;
	    }
      Common_sp::exec (cmd);
	    return false;
	  }

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x2fd9d
movq 0x18(%rsp), %rdi
callq 0x36860
cmpq 0x38(%rsp), %rax
jb 0x2fd9d
movq 0x10(%rsp), %rdx
leaq 0x1ac35(%rip), %rsi     # 0x4a960
leaq 0xd6f66(%rip), %rcx     # 0x106c98
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x36ae0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x368d0
jmp 0x2fd52
leaq 0x30(%rsp), %rdi
callq 0x36bc0
movq 0x38(%rsp), %rax
subq $0x1, %rax
leaq 0xd6f54(%rip), %rcx     # 0x106cc0
movq (%rcx), %rcx
subq %rax, %rcx
leaq 0xd6f47(%rip), %rax     # 0x106cc0
movq %rcx, (%rax)
movb $0x1, 0x57(%rsp)
jmp 0x2fdb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x36bc0
jmp 0x2fdbe
movq 0x10(%rsp), %rdi
leaq 0xd6eef(%rip), %rsi     # 0x106c98
callq 0x4a960
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TextTable::col2num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
ColNum col2num (const string &columnName) const
    { const ColNum i = col2num_ (columnName);
      if (i == no_index)
        throw Error (*this, "Table has no column " + strQuote (columnName));
      return i;
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x68(%rsp), %rsi
callq 0xb7bb0
movq %rax, 0x60(%rsp)
cmpq $-0x1, 0x60(%rsp)
jne 0x304bd
movb $0x1, 0x13(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, (%rsp)
movq 0x68(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x22, %edx
callq 0x424f0
jmp 0x3041c
leaq 0x9cd97(%rip), %rsi     # 0xcd1ba
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2a340
jmp 0x30434
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x3a690
jmp 0x30449
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
leaq 0xd44a7(%rip), %rsi     # 0x104900
leaq 0xa300(%rip), %rdx      # 0x3a760
callq 0xcc80
jmp 0x304d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x304a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x3049f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
testb $0x1, 0x13(%rsp)
jne 0x304b2
jmp 0x304bb
movq (%rsp), %rdi
callq 0xc580
jmp 0x304c7
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: double Common_sp::str2<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T str2 (const string &s)
    { static_assert (numeric_limits<T>::max() > 256, "str2 does not work on chars");
    	T i;
    	istringstream iss (s);
      iss >> i;
      if (   Common_sp::strBlank (s)
          || ! iss. eof ()
          || iss. fail ()
         )
        throw runtime_error ("Cannot convert " + strQuote (s) + " to number");
      return i;
    }

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
movq 0x220(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x8, %edx
callq 0xcc40
movq 0x18(%rsp), %rdi
leaq 0x218(%rsp), %rsi
callq 0xc5e0
jmp 0x307c2
movq 0x220(%rsp), %rdi
callq 0x415e0
movb %al, 0x17(%rsp)
jmp 0x307d5
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x30834
jmp 0x307df
movq 0x98(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x98(%rsp,%rax), %rdi
callq 0xcd60
movb %al, 0x16(%rsp)
jmp 0x307fe
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0x30808
jmp 0x30834
movq 0x98(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x98(%rsp,%rax), %rdi
callq 0xc030
movb %al, 0x15(%rsp)
jmp 0x30827
movb 0x15(%rsp), %al
testb $0x1, %al
jne 0x30834
jmp 0x30966
movb $0x1, 0x27(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, 0x8(%rsp)
movq 0x220(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0x22, %edx
callq 0x424f0
jmp 0x30861
leaq 0x9c610(%rip), %rsi     # 0xcce78
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2a340
jmp 0x30879
leaq 0x9c618(%rip), %rdx     # 0xcce98
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2a2f0
jmp 0x30891
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xcbb0
jmp 0x308a2
movq 0x8(%rsp), %rdi
movb $0x0, 0x27(%rsp)
movq 0xd573d(%rip), %rsi     # 0x105ff0
movq 0xd56b6(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x309a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x3098e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x30951
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x30947
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x3093d
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 0x3095a
jmp 0x30964
movq 0x8(%rsp), %rdi
callq 0xc580
jmp 0x3098e
movsd 0x218(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x98(%rsp), %rdi
callq 0xc390
movsd (%rsp), %xmm0
addq $0x228, %rsp            # imm = 0x228
retq
leaq 0x98(%rsp), %rdi
callq 0xc390
movq 0x90(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Color::code[abi:cxx11](Common_sp::Color::Type, bool)
static string code (Type color = none, 
                      bool bright = false)
    { 
		#ifdef _MSC_VER
		  return noString
		#else
    	return string ("\033[") + (bright ? "1;" : "") + to_string ((int) color) + "m"; 
		#endif
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x8(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
andb $0x1, %al
movb %al, 0xbb(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xcd00
movq 0x18(%rsp), %rdx
leaq 0x9c0e2(%rip), %rsi     # 0xccebb
leaq 0x58(%rsp), %rdi
callq 0x29fd0
jmp 0x30de5
movb 0xbb(%rsp), %cl
leaq 0x9c0cb(%rip), %rax     # 0xccebe
leaq 0x9ec24(%rip), %rdx     # 0xcfa1e
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2a2f0
jmp 0x30e12
movl 0xbc(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x2ded0
jmp 0x30e25
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x2dde0
jmp 0x30e3e
movq 0x8(%rsp), %rdi
leaq 0x9d8c1(%rip), %rdx     # 0xce70b
leaq 0x98(%rsp), %rsi
callq 0x2a2f0
jmp 0x30e59
leaq 0x98(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
leaq 0x78(%rsp), %rdi
callq 0xce98
leaq 0x58(%rsp), %rdi
callq 0xce98
leaq 0x57(%rsp), %rdi
callq 0xc7a0
movq 0x10(%rsp), %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x30f14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x30f0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x30f00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x30ef6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
leaq 0x78(%rsp), %rdi
callq 0xce98
leaq 0x58(%rsp), %rdi
callq 0xce98
leaq 0x57(%rsp), %rdi
callq 0xc7a0
movq 0x48(%rsp), %rdi
callq 0xccf0
nopl (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>& Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&)
Vector<T>& operator<< (vector<U> &&other)
        { reserveInc (other. size ());
          for (U& t : other)
            P::push_back (std::move (t));
          unsetSearchSorted ();
          other. clear ();
        	return *this;
        }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x2f390
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x32780
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2eff0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2f020
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2f050
testb $0x1, %al
jne 0x326da
jmp 0x32703
leaq 0x18(%rsp), %rdi
callq 0x2f090
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x327c0
leaq 0x18(%rsp), %rdi
callq 0x2f0f0
jmp 0x326c5
movq (%rsp), %rdi
callq 0x327f0
movq 0x28(%rsp), %rdi
callq 0x32820
movq (%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::sort()
void sort ()
      { if (searchSorted)
          return;
        Common_sp::sort (*this); 
        searchSorted = true;
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x18(%rax)
je 0x3273b
jmp 0x3274e
movq 0x8(%rsp), %rdi
callq 0x333d0
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ncbi[P]amr/./common.hpp
// Function: void Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::uniq<Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::uniq()::'lambda'(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&)>(Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::uniq()::'lambda'(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&) const&)
void uniq (const Equal &equal)
  	    { if (P::size () <= 1)
  	        return;
  	      size_t j = 1;  
  	      for (size_t i = 1; i < P::size (); i++)
  	        if (! equal ((*this) [i], (*this) [i - 1]))
  	        { if (j != i)
  	            (*this) [j] = (*this) [i];
  	          j++;
  	        }
  	      P::resize (j);
  	    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2f390
cmpq $0x1, %rax
ja 0x34b88
jmp 0x34c72
movq $0x1, 0x30(%rsp)
movq $0x1, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x2f390
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x34c63
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x2f970
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rsi
subq $0x1, %rsi
callq 0x2f970
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x34c80
testb $0x1, %al
jne 0x34c4e
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x34c40
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2f970
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
movq 0x30(%rsp), %rsi
callq 0x2f970
movq (%rsp), %rsi
movq %rax, %rdi
callq 0xc080
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x34c50
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x34b9a
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x34cb0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::constFind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
typename Vector<T>::const_iterator constFind (const T &value) const
  	  { typename Vector<T>::const_iterator it = P::begin (); 
  	    while (it != P::end ()) 
  	      if (*it == value)
  	        break;
  	      else
  	        it++;
  	    return it;
  	  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35930
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rdi
callq 0x358f0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x35820
testb $0x1, %al
jne 0x358a6
jmp 0x358d8
leaq 0x30(%rsp), %rdi
callq 0x35960
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x30100
testb $0x1, %al
jne 0x358c3
jmp 0x358c5
jmp 0x358d8
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x35970
movq %rax, 0x10(%rsp)
jmp 0x35882
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::checkIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) const
void checkIndex (const string &operation,
  	                 size_t index) const
  	  {
  	  #ifndef NDEBUG
  	    if (index >= P::size ())
  	      throw runtime_error ("Vector " + operation + " operation: index = " + to_string (index) + ", but size = " + to_string (P::size ()));
  	  #endif
  	  }

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x2f390
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0x35c3c
movb $0x1, 0x1f(%rsp)
movl $0x10, %edi
callq 0xc3b0
movq %rax, (%rsp)
movq 0x118(%rsp), %rdx
leaq 0x9752f(%rip), %rsi     # 0xccfa0
leaq 0x70(%rsp), %rdi
callq 0x2a1c0
jmp 0x35a7d
leaq 0x97524(%rip), %rdx     # 0xccfa8
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2a2f0
jmp 0x35a98
movq 0x110(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2bf10
jmp 0x35aac
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2dde0
jmp 0x35ac8
leaq 0x974ee(%rip), %rdx     # 0xccfbd
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x2a2f0
jmp 0x35ae6
movq 0x8(%rsp), %rdi
callq 0x2f390
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x2bf10
jmp 0x35aff
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x2dde0
jmp 0x35b1b
movq (%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xcbb0
jmp 0x35b2e
movq (%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0xd04b2(%rip), %rsi     # 0x105ff0
movq 0xd042b(%rip), %rdx     # 0x105f70
callq 0xcc80
jmp 0x35c4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x35c28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x35c1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x35c11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x35c07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x35bfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x35bed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x35be3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0xce98
leaq 0x20(%rsp), %rdi
callq 0xce98
leaq 0xd0(%rsp), %rdi
callq 0xce98
leaq 0xb0(%rsp), %rdi
callq 0xce98
leaq 0x40(%rsp), %rdi
callq 0xce98
leaq 0x90(%rsp), %rdi
callq 0xce98
leaq 0x70(%rsp), %rdi
callq 0xce98
testb $0x1, 0x1f(%rsp)
jne 0x35c31
jmp 0x35c3a
movq (%rsp), %rdi
callq 0xc580
jmp 0x35c44
addq $0x128, %rsp            # imm = 0x128
retq
movq 0x68(%rsp), %rdi
callq 0xccf0
nop
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::eraseMany(unsigned long, unsigned long)
void eraseMany (size_t from,
                    size_t to)
      { if (to < from)
          throw runtime_error ("Vector::eraseMany(): to < from");
        if (to == from)
          return;
        checkIndex ("eraseMany", to - 1);
        auto it1 = P::begin ();
        std::advance (it1, from);
        auto it2 = it1;
        std::advance (it2, to - from);
        P::erase (it1, it2);
      }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rax
cmpq 0x88(%rsp), %rax
jae 0x35f96
movl $0x10, %edi
callq 0xc3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x971ee(%rip), %rsi     # 0xcd148
callq 0xc2e0
jmp 0x35f61
movq 0x10(%rsp), %rdi
movq 0xd0083(%rip), %rsi     # 0x105ff0
movq 0xcfffc(%rip), %rdx     # 0x105f70
callq 0xcc80
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0xc580
jmp 0x360ba
movq 0x80(%rsp), %rax
cmpq 0x88(%rsp), %rax
jne 0x35fad
jmp 0x36080
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcd00
movq 0x8(%rsp), %rdx
leaq 0x9719f(%rip), %rsi     # 0xcd167
leaq 0x50(%rsp), %rdi
callq 0x29fd0
jmp 0x35fd4
movq 0x18(%rsp), %rdi
movq 0x80(%rsp), %rdx
decq %rdx
leaq 0x50(%rsp), %rsi
callq 0x35a00
jmp 0x35ff0
leaq 0x50(%rsp), %rdi
callq 0xce98
leaq 0x4f(%rsp), %rdi
callq 0xc7a0
movq 0x18(%rsp), %rdi
callq 0x2eff0
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x360d0
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rsi
subq 0x88(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x360d0
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x361c0
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x361c0
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x36120
movq %rax, 0x20(%rsp)
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x360b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xce98
leaq 0x4f(%rsp), %rdi
callq 0xc7a0
movq 0x78(%rsp), %rdi
callq 0xccf0
nopw %cs:(%rax,%rax)
nop