LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]metaSLR/classify.cpp
// Function: getHap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>> const&)
int getHap(const std::string & barcode , const std::map<int,int> & data){
    if( barcode == "0_0_0" || barcode == "0_0" || barcode == "0" )
        return -1;
    int first = 0 , second = 0 , first_index = -1;
    for( int i = 0 ; i< (int)g_kmers.size() ; i++ ){
        if( data.find(i) == data.end() ) 
            continue;
        else if( data.at(i) > first ) {
            second = first ;
            first = data.at(i);
            first_index = i ;
        }
        else if( data.at(i) > second ){
            second = data.at(i);
        }
    }
    if( first > 0 && first_index != -1 && first > second )
        return first_index;
    else 
        return -1 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x57bb(%rip), %rsi      # 0x907b
callq 0x4dd9
pushq $-0x1
popq %r14
testb %al, %al
jne 0x39ba
leaq 0x57a5(%rip), %rsi      # 0x907d
movq %r15, %rdi
callq 0x4dd9
testb %al, %al
jne 0x39ba
leaq 0x5a55(%rip), %rsi      # 0x9344
movq %r15, %rdi
callq 0x4dd9
testb %al, %al
jne 0x39ba
leaq 0x8(%rbx), %rax
movq %rax, -0x38(%rbp)
pushq $-0x1
popq %rax
movl %eax, -0x30(%rbp)
xorl %esi, %esi
leaq -0x2c(%rbp), %r14
xorl %r15d, %r15d
xorl %r13d, %r13d
movl %esi, -0x2c(%rbp)
movq 0xaa0d(%rip), %rax      # 0xe330
subq 0xa9fe(%rip), %rax      # 0xe328
cqto
pushq $0x38
popq %rcx
idivq %rcx
cmpl %eax, %esi
jge 0x399d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8516
cmpq -0x38(%rbp), %rax
je 0x3987
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4dea
movl (%rax), %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4dea
movl (%rax), %ecx
cmpl %r15d, %r12d
jle 0x396f
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x398d
cmpl %r13d, %ecx
jle 0x3987
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4dea
movl %r15d, %ecx
movl (%rax), %r15d
jmp 0x398d
movl %r15d, %ecx
movl %r13d, %r15d
movl %r15d, %r13d
movl -0x2c(%rbp), %esi
incl %esi
movl %ecx, %r15d
jmp 0x3919
cmpl %r13d, %r15d
pushq $-0x1
popq %rax
movl %eax, %r14d
movl -0x30(%rbp), %ecx
cmovgl %ecx, %r14d
cmpl %eax, %ecx
cmovel %ecx, %r14d
testl %r15d, %r15d
cmovlel %eax, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]metaSLR/classify.cpp
// Function: getSpeciesName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string getSpeciesName(const std::string & file){
    int start  = 0 ;
    for( int i = 0 ; i < (int)file.size() ; i ++){
        if( file.at(i)== '/')
            start = i ;
    }
    return file.substr(start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jge 0x3a3c
movq %r14, %rdi
movq %r15, %rsi
callq 0x32b0
cmpb $0x2f, (%rax)
cmovel %r15d, %r12d
incq %r15
jmp 0x3a1c
movslq %r12d, %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3270
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]metaSLR/classify.cpp
// Function: printBarcodeInfos(BarcodeCache const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void printBarcodeInfos(const BarcodeCache& g_barcode_haps , 
        const std::vector<std::string> & haps){
    std::cout<<"barcode_str\thap_result";
    for( int i = 0 ; i < (int)g_kmers.size() ; i ++ ){
        std::cout<<'\t'<<getSpeciesName(haps.at(i));
    }
    std::cout<<'\n';
    for(const auto & pair : g_barcode_haps.barcode_haps){
        std::cout<<pair.first;
        const auto & data=pair.second;
        std::cout<<'\t'<<getHap(pair.first,data);
        for( int i = 0 ; i < (int)g_kmers.size() ; i ++ )
            std::cout<<'\t'<<getHapCount(data,i);
        std::cout<<'\n';
        //std::cout<<'\t'<<getHapCount(data,-1)<<'\n';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
movq 0xa558(%rip), %rdi      # 0xdfd0
leaq 0x5602(%rip), %rsi      # 0x9081
callq 0x3240
xorl %r12d, %r12d
pushq $0x9
popq %r13
leaq -0x58(%rbp), %r15
movq 0xa89a(%rip), %rax      # 0xe330
subq 0xa88b(%rip), %rax      # 0xe328
cqto
pushq $0x38
popq %rcx
idivq %rcx
cltq
cmpq %rax, %r12
jge 0x3aec
movq 0xa51d(%rip), %rdi      # 0xdfd0
movl %r13d, %esi
callq 0x32a0
movq %rax, %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4e22
movq %r15, %rdi
movq %rax, %rsi
callq 0x3a05
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3200
movq %r15, %rdi
callq 0x3130
incq %r12
jmp 0x3a8f
movq 0xa4dd(%rip), %r14      # 0xdfd0
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x32a0
movq -0x30(%rbp), %rax
movq 0x18(%rax), %r15
addq $0x8, %rax
movq %rax, -0x30(%rbp)
pushq $0x9
popq %r13
cmpq -0x30(%rbp), %r15
je 0x3bb1
leaq 0x20(%r15), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3200
movq %r15, -0x38(%rbp)
addq $0x40, %r15
movq %r14, %rdi
movl %r13d, %esi
callq 0x32a0
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38a2
movq %r12, %rdi
movl %eax, %esi
callq 0x3420
xorl %ebx, %ebx
movq 0xa7d1(%rip), %rax      # 0xe330
subq 0xa7c2(%rip), %rax      # 0xe328
cqto
pushq $0x38
popq %rcx
idivq %rcx
movq %r14, %rdi
cmpl %eax, %ebx
jge 0x3b98
movl %r13d, %esi
callq 0x32a0
movq %rax, %r12
movq %r15, %rdi
movl %ebx, %esi
callq 0x39cc
movq %r12, %rdi
movl %eax, %esi
callq 0x3420
incl %ebx
jmp 0x3b58
pushq $0xa
popq %rsi
callq 0x32a0
movq -0x38(%rbp), %rdi
callq 0x3290
movq %rax, %r15
jmp 0x3b12
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]metaSLR/classify.cpp
// Function: parseName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string parseName(const std::string & head){
    int s=-1, e=-1;
    for( int i = 0 ; i< (int)head.size(); i++ ){
        if( head[i] == '#' ) s=i;
        if( head[i] == '/' ) e=i;
    }
    return head.substr(s+1,e-s-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rsi), %ecx
movq (%rsi), %rdx
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
pushq $-0x1
popq %rax
movl %eax, %r8d
cmpq %rdi, %rcx
je 0x3c0d
movb (%rdx,%rdi), %r9b
cmpb $0x23, %r9b
cmovel %edi, %eax
cmpb $0x2f, %r9b
cmovel %edi, %r8d
incq %rdi
jmp 0x3bf0
leal 0x1(%rax), %ecx
movslq %ecx, %rdx
notl %eax
addl %eax, %r8d
movslq %r8d, %rcx
movq %rbx, %rdi
callq 0x3270
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: Kmer::str2Kmer(std::vector<char, std::allocator<char>> const&)
static Kmer str2Kmer(const std::vector<char> & str){
        assert(str.size() == overlap);
        Kmer word; word.Init();
        for (int index = 0; index < overlap; index++ )
        {
            word.LeftBitMoveBy2();
            word.low |= str.at(index);
        }
        Kmer bal_word = word.reverseComplement();
        if( word < bal_word ) 
            return word ;
        else
            return bal_word;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rcx
subq (%rdi), %rcx
movslq 0x9669(%rip), %rax      # 0xe314
cmpq %rax, %rcx
jne 0x4d36
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
cltq
cmpq %rax, %r14
jge 0x4cfc
shldq $0x2, %r15, %r12
movq %r12, -0x30(%rbp)
shlq $0x2, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x575e
movsbq (%rax), %rax
orq %rax, %r15
movq %r15, -0x28(%rbp)
incq %r14
movl 0x961a(%rip), %eax      # 0xe314
jmp 0x4cc7
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x577c
movq (%rbx), %rcx
cmpq %rax, %rcx
jae 0x4d16
movq -0x28(%rbp), %rdx
jmp 0x4d26
jne 0x4d23
movq -0x28(%rbp), %rcx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq %rax, %rcx
movq %rcx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4778(%rip), %rdi      # 0x94b5
leaq 0x4787(%rip), %rsi      # 0x94cb
leaq 0x478e(%rip), %rcx      # 0x94d9
movl $0x9a, %edx
callq 0x3190
nop
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]metaSLR/./kmer/kmer.h
// Function: BaseStr::str2BaseStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<char> str2BaseStr(const std::string & read ){
        int len = read.size();
        std::vector<char> ret ;
        if ( len < 1 )
        {
            return ret ;
        }
        ret.resize(len);
        for( int i = 0 ; i < len ; i++ )
            ret[i] = base2int(read.at(i));
        return ret ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
testl %r12d, %r12d
jle 0x4db8
movq %rsi, %r14
movl %r12d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x588e
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x4db8
movq %r14, %rdi
movq %r15, %rsi
callq 0x32b0
movb (%rax), %al
shrb %al
andb $0x3, %al
movq (%rbx), %rcx
movb %al, (%rcx,%r15)
incq %r15
jmp 0x4d96
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dc6
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e2e
movq %r14, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]metaSLR/classify.cpp
// Function: MultiThread::MultiThread(int)
MultiThread(int t_num){
        t_nums = t_num ;
        barcode_caches = new BarcodeCache[t_num];
        locks = new std::mutex[t_num];
        threads = new std::thread*[t_num];
        busy = false;
        end=false;
        for(int i = 0 ; i< t_num ; i++){
            caches.push_back(std::stack<Buffer>());
            threads[i] = new std::thread([this,i](){int index=i ;Worker(index); });
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movslq %esi, %r12
pushq $0x30
popq %rcx
movq %r12, %rax
mulq %rcx
movq %rdi, %rbx
seto %cl
orq $0x8, %rax
pushq $-0x1
popq %rdx
testb %cl, %cl
cmovneq %rdx, %rax
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movl %r12d, (%rdi)
andl $0x0, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, -0x30(%rbp)
andq $0x0, 0x60(%rdi)
movq %rax, %rdi
callq 0x3030
movq %r12, (%rax)
leaq 0x8(%rax), %rcx
testl %r12d, %r12d
je 0x4ee3
addq $0x10, %rax
imulq $0x30, %r12, %rdx
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
addq $0x30, %rax
addq $-0x30, %rdx
jne 0x4ec4
movq %rcx, 0x30(%rbx)
pushq $0x28
popq %r15
movq %r12, %rax
mulq %r15
movq %rax, %r13
movq %rax, %rdi
pushq $-0x1
popq %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, %rcx
testl %r14d, %r14d
je 0x4f31
addq $-0x28, %r13
movq %r13, %rax
xorl %edx, %edx
divq %r15
subq %rdx, %r13
addq $0x28, %r13
movq %rcx, %r15
movq %rcx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x3180
movq %r15, %rcx
movq %rcx, 0x20(%rbx)
shlq $0x3, %r12
testl %r14d, %r14d
pushq $-0x1
popq %rax
cmovsq %rax, %r12
movq %r12, %rdi
callq 0x3030
movq %rax, 0x28(%rbx)
andw $0x0, 0x4(%rbx)
xorl %r15d, %r15d
movq %r14, %r13
testl %r13d, %r13d
cmovlel %r15d, %r13d
leaq -0x80(%rbp), %r12
cmpq %r15, %r13
je 0x4fb1
movq %r12, %rdi
callq 0x5a14
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x5ad2
movq %r12, %rdi
callq 0x65a8
pushq $0x8
popq %rdi
callq 0x3250
movq %rax, %r14
movq %rbx, -0x80(%rbp)
movl %r15d, -0x78(%rbp)
movq %rax, %rdi
movq %r12, %rsi
callq 0x5a34
movq 0x28(%rbx), %rax
movq %r14, (%rax,%r15,8)
incq %r15
jmp 0x4f65
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4fd2
jmp 0x4fd2
movq %rax, %r15
leaq -0x80(%rbp), %rdi
callq 0x65a8
jmp 0x4fe2
movq %rax, %r15
jmp 0x4fe2
movq %rax, %r15
movq %r14, %rdi
callq 0x3230
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x7dd6
movq -0x30(%rbp), %rdi
callq 0x5aa6
movq %r15, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]metaSLR/classify.cpp
// Function: MultiThread::submit(Buffer const&)
void submit(const Buffer & buffer ){
        static long index = 0;
        while( busy ) { std::this_thread::sleep_for(std::chrono::seconds(1));}
        index ++ ;
        int id = index % t_nums;
        locks[id].lock();
        caches[id].push(buffer);
        locks[id].unlock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
cmpb $0x1, 0x5(%rbx)
jne 0x5141
movq $0x1, -0x28(%rbp)
movq %r15, %rdi
callq 0x78e7
jmp 0x5129
movq 0x9200(%rip), %rax      # 0xe348
incq %rax
movq %rax, 0x91f6(%rip)      # 0xe348
movslq (%rbx), %rcx
cqto
idivq %rcx
movq %rdx, %r15
imulq $0x28, %rdx, %r12
movq 0x20(%rbx), %rdi
addq %r12, %rdi
callq 0x68f2
imulq $0x50, %r15, %rdi
addq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x7926
addq 0x20(%rbx), %r12
movq %r12, %rdi
callq 0x31c0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r12
subq (%rsi), %r12
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %r12d, %r12d
jle 0x55aa
movq %rsi, %r14
movl %r12d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x3320
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
leaq 0x408f(%rip), %r13      # 0x9615
cmpq %r15, %r12
je 0x55aa
movq %r14, %rdi
movq %r15, %rsi
callq 0x575e
movsbq (%rax), %rax
movb (%rax,%r13), %al
movq (%rbx), %rcx
movb %al, (%rcx,%r15)
incq %r15
jmp 0x5586
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55be
movq %rax, %r14
movq %rbx, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movslq 0x8d1c(%rip), %rsi      # 0xe314
callq 0x588e
xorl %eax, %eax
pushq $-0x1
popq %rcx
movl 0x8d0c(%rip), %edx      # 0xe314
cmpl %edx, %eax
jge 0x562e
movl %r14d, %esi
andb $0x3, %sil
addl %ecx, %edx
movslq %edx, %rdx
movq (%rbx), %rdi
movb %sil, (%rdi,%rdx)
shrdq $0x2, %r15, %r14
shrq $0x2, %r15
incl %eax
decl %ecx
jmp 0x5602
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e2e
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r15
subq (%rsi), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
testl %r15d, %r15d
jle 0x7be6
movq %rsi, %r14
movl %r15d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x588e
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
decq %r15
xorl %r12d, %r12d
cmpq $-0x1, %r15
je 0x7be6
movq %r14, %rdi
movq %r15, %rsi
callq 0x575e
movb (%rax), %al
xorb $0x2, %al
movq (%rbx), %rcx
movb %al, (%rcx,%r12)
incq %r12
decq %r15
jmp 0x7bc2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7bf4
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e2e
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
shrdq $0x2, %rcx, %rax
shrq $0x2, %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movl 0x66c7(%rip), %edx      # 0xe314
leal -0x2(,%rdx,2), %r8d
addl %edx, %edx
addb $-0x42, %dl
xorl %r9d, %r9d
cmpl $0x40, %r8d
setl %r9b
cmovgeq %rcx, %rax
movslq %esi, %rsi
movzbl %dl, %ecx
cmovll %r8d, %ecx
shlq %cl, %rsi
orq %rax, %rsi
movq %rsi, (%rdi,%r9,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc41(%rip), %rsi       # 0x51d9
movq %rbx, %rdi
callq 0x2130
xorl %ebp, %ebp
leaq 0xc32(%rip), %r15       # 0x51db
cmpl 0x1c(%r14), %ebp
jge 0x45be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2130
incl %ebp
jmp 0x45a9
leaq 0xc14(%rip), %rsi       # 0x51d9
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2080
xorl %ebp, %ebp
leaq 0xbff(%rip), %r15       # 0x51dd
pushq $0x6f
popq %r12
pushq $0x20
popq %r13
cmpl 0x18(%r14), %ebp
jge 0x4645
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2130
xorl %r15d, %r15d
movl 0x1c(%r14), %eax
cmpl %eax, %r15d
jge 0x4627
imull %ebp, %eax
addl %r15d, %eax
cltq
movq (%r14), %rcx
cmpb $0x0, (%rcx,%rax)
movl %r12d, %esi
jne 0x461a
movl %r13d, %esi
movq %rbx, %rdi
callq 0x2160
incl %r15d
jmp 0x45fa
movq %rbx, %rdi
leaq 0xbac(%rip), %r15       # 0x51dd
movq %r15, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x2080
incl %ebp
jmp 0x45e6
leaq 0xb8d(%rip), %rsi       # 0x51d9
movq %rbx, %rdi
callq 0x2130
xorl %ebp, %ebp
leaq 0xb7e(%rip), %r15       # 0x51db
cmpl 0x1c(%r14), %ebp
jge 0x4672
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2130
incl %ebp
jmp 0x465d
leaq 0xb60(%rip), %rsi       # 0x51d9
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2080
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/amrfinder.cpp
// Function: (anonymous namespace)::ThisApplication::db2organisms() const
StringVector db2organisms () const
  {
    const TextTable taxgroup            (tmp + "/db/taxgroup.tsv");
    const TextTable AMRProt_mutation    (tmp + "/db/AMRProt-mutation.tsv");
    const TextTable AMRProt_susceptible (tmp + "/db/AMRProt-susceptible.tsv");
    taxgroup. qc ();
    AMRProt_mutation. qc ();
    AMRProt_susceptible. qc ();
    StringVector vec (taxgroup. col2values (0));
    vec << AMRProt_mutation. col2values (0);
    vec << AMRProt_susceptible. col2values (0);
    vec. sort ();
    vec. uniq ();
    return vec;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rsi, %r14
movq %rdi, %rbx
addq $0x168, %r14            # imm = 0x168
leaq 0x4088e(%rip), %rdx     # 0x5af54
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c88d
leaq 0x6a418(%rip), %rdx     # 0x84af8
leaq 0x100(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x50eb2
leaq 0x90(%rsp), %rdi
callq 0xbb68
leaq 0x4085b(%rip), %rdx     # 0x5af65
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x1c88d
leaq 0x6a3da(%rip), %rdx     # 0x84af8
leaq 0x90(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x1
popq %rcx
xorl %r8d, %r8d
callq 0x50eb2
leaq 0x20(%rsp), %rdi
callq 0xbb68
leaq 0x40837(%rip), %rdx     # 0x5af7e
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1c88d
leaq 0x6a39f(%rip), %rdx     # 0x84af8
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
pushq $0x1
popq %rcx
xorl %r8d, %r8d
callq 0x50eb2
movq %rsp, %rdi
callq 0xbb68
leaq 0x100(%rsp), %rdi
callq 0x51d42
leaq 0x90(%rsp), %rdi
callq 0x51d42
leaq 0x20(%rsp), %rdi
callq 0x51d42
leaq 0x100(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x54578
movq %rsp, %rdi
leaq 0x90(%rsp), %rsi
xorl %edx, %edx
callq 0x54578
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1e72a
movq %rsp, %rdi
callq 0x20bee
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x54578
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1e72a
movq %rsp, %rdi
callq 0x20bee
movq %rbx, %rdi
callq 0x1e78e
movq %rbx, %rdi
callq 0x1e7a4
leaq 0x20(%rsp), %rdi
callq 0x1dabe
leaq 0x90(%rsp), %rdi
callq 0x1dabe
leaq 0x100(%rsp), %rdi
callq 0x1dabe
movq %rbx, %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1a839
jmp 0x1a880
movq %rax, %r14
movq %rsp, %rdi
callq 0x20bee
jmp 0x1a883
jmp 0x1a880
movq %rax, %r14
movq %rsp, %rdi
callq 0xbb68
jmp 0x1a89a
movq %rax, %r14
jmp 0x1a89a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xbb68
jmp 0x1a8a7
movq %rax, %r14
jmp 0x1a8a7
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0xbb68
jmp 0x1a8b4
movq %rax, %r14
movq %rbx, %rdi
callq 0x20bee
jmp 0x1a890
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1dabe
leaq 0x90(%rsp), %rdi
callq 0x1dabe
leaq 0x100(%rsp), %rdi
callq 0x1dabe
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq $0x168, %r12            # imm = 0x168
leaq 0x3f80a(%rip), %rdx     # 0x5adf6
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1c88d
leaq 0x694f5(%rip), %rdx     # 0x84af8
leaq 0x58(%rsp), %rdi
pushq $0x1
popq %rcx
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x50eb2
movq %r14, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xbb68
leaq 0x58(%rsp), %rdi
callq 0x51d42
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x52e10
movl %ebp, 0x4(%rsp)
movq %r12, 0x10(%rsp)
leaq 0xa8(%rsp), %r15
movq 0x8(%r15), %r13
subq (%r15), %r13
sarq $0x5, %r13
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpq %rbx, %r13
je 0x1b6c0
movq %rbx, %r12
subq %r14, %r12
testq %r14, %r14
je 0x1b691
movq %r15, %rdi
movq %rbx, %rsi
callq 0x201be
movq %rax, %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0x201be
movq %rax, %rdi
movq %rbp, %rsi
callq 0x20b7a
movq %r15, %rdi
movq %r12, %rsi
callq 0x201be
movq %rax, %rdi
xorl %esi, %esi
callq 0x1d398
movq %rax, %rdi
leaq 0x3fa89(%rip), %rsi     # 0x5b139
callq 0x1cba2
movzbl %al, %eax
addq %rax, %r14
incq %rbx
jmp 0x1b65d
movq 0x10(%rsp), %rbx
movl 0x4(%rsp), %ebp
subq $0x1, %r14
jb 0x1b6ea
movq 0xb0(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0xb0(%rsp)
callq 0x20bee
jmp 0x1b6c9
movq %r15, %rdi
callq 0x20b64
movq %r15, %rdi
callq 0x1da24
leaq 0x58(%rsp), %rdi
movb %bpl, 0x29(%rdi)
callq 0x51d42
leaq 0x40bcc(%rip), %rdx     # 0x5c2db
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x1c88d
movq 0x8(%rsp), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1cbaf
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x29920
leaq 0x18(%rsp), %rdi
callq 0xbb68
leaq 0x38(%rsp), %rdi
callq 0xbb68
leaq 0x58(%rsp), %rdi
callq 0x1dabe
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xbb68
jmp 0x1b781
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xbb68
jmp 0x1b7a3
jmp 0x1b7a0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xbb68
jmp 0x1b7ad
jmp 0x1b7a0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1dabe
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %rbx
andq $0x0, (%rbx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x365ec
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1dbfb
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xbb68
testb %bl, %bl
je 0x1c6a8
movsd (%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
pushq $0x22
popq %rdx
movq %r14, %rsi
callq 0x243b1
leaq 0x3e7f0(%rip), %rsi     # 0x5aeba
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1b94c
leaq 0x3e7ea(%rip), %rdx     # 0x5aeca
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1b92d
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x678e0(%rip), %rsi     # 0x83fe8
movq 0x67851(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x1c72c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x1c73e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x1c752
jmp 0x1c769
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
jmp 0x1c769
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %r14, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x4(%rsp), %rbx
andl $0x0, (%rbx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x365ec
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1dd5e
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xbb68
testb %bl, %bl
je 0x1c7c4
movl 0x4(%rsp), %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
pushq $0x22
popq %rdx
movq %r14, %rsi
callq 0x243b1
leaq 0x3e6d4(%rip), %rsi     # 0x5aeba
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1b94c
leaq 0x3e6e9(%rip), %rdx     # 0x5aee5
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1b92d
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x677c4(%rip), %rsi     # 0x83fe8
movq 0x67735(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x1c848
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x1c85a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x1c86e
jmp 0x1c885
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
jmp 0x1c885
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xbb68
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rsi, %rax
je 0x1cc45
cmpq $0x1, 0x10(%rsi)
jne 0x1cbee
cmpq $0x0, 0x18(%rax)
je 0x1cc64
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x1cee8
leaq 0x3e33a(%rip), %rdx     # 0x5af3c
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x1b92d
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2632c
leaq 0x18(%rsp), %rdi
callq 0xbb68
leaq 0x38(%rsp), %rdi
callq 0xbb68
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1cee8
movq %rsp, %rdi
callq 0x1e654
jmp 0x1cc59
leaq 0x3e2f1(%rip), %rsi     # 0x5af3d
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x1b7b6
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
leaq 0x3e29a(%rip), %rsi     # 0x5af10
movq %rax, %rdi
callq 0xb260
movq 0x67363(%rip), %rsi     # 0x83fe8
movq 0x672d4(%rip), %rdx     # 0x83f60
movq %r14, %rdi
callq 0xb9d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xb470
jmp 0x1ccca
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1e654
jmp 0x1ccca
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xbb68
jmp 0x1ccc0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
xorl %esi, %esi
callq 0xb1f0
testq %rax, %rax
je 0x1d033
movq %rax, %r15
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b7b6
movq %r15, %rdi
callq 0xb6a0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xb7b0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1c554
leaq 0x3dee3(%rip), %rsi     # 0x5af44
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x1b94c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x66f5f(%rip), %rsi     # 0x83fe8
movq 0x66ed0(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x1d0ad
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x1d0bf
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x1d0d3
jmp 0x1d0db
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
movq %r14, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdx
testq %rbx, %rbx
je 0x1d7c2
movq %rdi, %r14
leaq 0x6737b(%rip), %r12     # 0x84b20
movq (%r12), %rax
movq 0x8(%rdi), %rcx
subq (%rdi), %rcx
sarq $0x3, %rcx
xorl %esi, %esi
subq %rcx, %rax
cmovaeq %rax, %rsi
cmpq %rbx, %rsi
jae 0x1d7d5
leaq 0x6732f(%rip), %rsi     # 0x84af8
movq %rdx, %rdi
callq 0x2812e
xorl %eax, %eax
jmp 0x1d811
leaq 0xa952(%rip), %rsi      # 0x2812e
leaq 0x67315(%rip), %rcx     # 0x84af8
movq %rsp, %r15
movq %r15, %rdi
callq 0x1fd7e
movq %r14, %rdi
movq %r15, %rsi
callq 0x1fc50
movq %rsp, %rdi
callq 0x1fe12
movq (%r12), %rax
subq %rbx, %rax
incq %rax
movq %rax, (%r12)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1fe12
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x5182a
cmpq $-0x1, %rax
je 0x1db12
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x22
popq %rdx
movq %r15, %rsi
callq 0x243b1
leaq 0x3d6c8(%rip), %rsi     # 0x5b1fc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1b94c
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20ac0
xorl %ebp, %ebp
leaq 0x64e39(%rip), %rsi     # 0x82998
movq 0x6640a(%rip), %rdx     # 0x83f70
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x1db83
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x1db97
jmp 0x1db9f
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, %r14
leaq 0x70(%rsp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb9a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb3f0
movq %r14, %rdi
callq 0x23cd3
testb %al, %al
jne 0x1dc95
movq 0x70(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x90(%rsp,%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
jne 0x1dc95
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x70(%rsp), %rdi
callq 0xb2d0
movsd (%rsp), %xmm0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
pushq $0x22
popq %rdx
movq %r14, %rsi
callq 0x243b1
leaq 0x3d203(%rip), %rsi     # 0x5aeba
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1b94c
leaq 0x3d20d(%rip), %rdx     # 0x5aeda
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1b92d
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xb940
xorl %ebp, %ebp
movq 0x662f3(%rip), %rsi     # 0x83fe8
movq 0x66264(%rip), %rdx     # 0x83f60
movq %rbx, %rdi
callq 0xb9d0
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xbb68
jmp 0x1dd19
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0xbb68
jmp 0x1dd2b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xbb68
testb %bpl, %bpl
jne 0x1dd3f
jmp 0x1dd4c
movq %rax, %r14
movq %rbx, %rdi
callq 0xb470
jmp 0x1dd4c
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0xb2d0
movq %r14, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x3cf71(%rip), %rsi     # 0x5aefd
leaq 0x68(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x1b7b6
leaq 0x3cf5b(%rip), %rax     # 0x5af00
leaq 0x3f949(%rip), %rdx     # 0x5d8f5
testl %r14d, %r14d
cmovneq %rax, %rdx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x1b92d
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x1caa3
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1ca3c
leaq 0x3e601(%rip), %rdx     # 0x5c5e8
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b92d
leaq 0x48(%rsp), %rdi
callq 0xbb68
leaq 0x8(%rsp), %rdi
callq 0xbb68
leaq 0x28(%rsp), %rdi
callq 0xbb68
leaq 0x68(%rsp), %rdi
callq 0xbb68
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb68
jmp 0x1e03f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb68
jmp 0x1e04e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb68
jmp 0x1e05d
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb68
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x5, %rsi
callq 0x1e7b2
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1e765
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e906
addq $0x20, %r15
jmp 0x1e74f
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x21, %rax
jb 0x1e776
movb $0x0, 0x18(%rbx)
movq %r14, %rdi
callq 0x1e7c6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
cmpq 0x8(%r15), %r14
je 0x1f6bd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d9db
testb %al, %al
jne 0x1f6bd
addq $0x20, %r14
jmp 0x1f6a2
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpq %rsi, %rdx
jb 0x1fa0f
je 0x1fa05
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3b7ed(%rip), %rsi     # 0x5b1a9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq -0x1(%rbx), %rdx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x1f6c6
leaq 0x10(%rsp), %rdi
callq 0xbb68
movq (%r15), %rax
shlq $0x5, %r14
addq %rax, %r14
shlq $0x5, %rbx
addq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1fa66
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0xb300
movq %rax, %r14
leaq 0x3b769(%rip), %rsi     # 0x5b18a
movq %rax, %rdi
callq 0xb260
movq 0x645b8(%rip), %rsi     # 0x83fe8
movq 0x64529(%rip), %rdx     # 0x83f60
movq %r14, %rdi
callq 0xb9d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x1fa5e
movq %rax, %rbx
jmp 0x1fa5e
movq %rax, %rbx
movq %r14, %rdi
callq 0xb470
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::section(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline void section (const string &title,
                     bool useAlsoCout)
  { const Color::Type color = Color::cyan;
    const bool bright = false;
    if (useAlsoCout)
    {
      { const OColor oc1 (cout, color, bright, true);
        const OColor oc2 (cerr, color, bright, true);
        couterr << title /*<< " ..."*/;
      }
      couterr << endl;
    }
    else
    {
      { const OColor oc (cerr, color, bright, true);
        cerr << title /*<< " ..."*/;
      }
      cerr << endl;
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x1fb73
movq 0x6447b(%rip), %rsi     # 0x83f88
movq %rsp, %rdi
pushq $0x24
popq %rbp
pushq $0x1
popq %r14
movl %ebp, %edx
xorl %ecx, %ecx
movl %r14d, %r8d
callq 0x1e0c2
movq 0x644b6(%rip), %rsi     # 0x83fe0
leaq 0x10(%rsp), %rdi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r14d, %r8d
callq 0x1e0c2
leaq 0x64fa0(%rip), %r14     # 0x84ae2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fbda
leaq 0x10(%rsp), %rdi
callq 0x1e15c
movq %rsp, %rdi
callq 0x1e15c
movq 0x64422(%rip), %rdi     # 0x83f88
callq 0xb2f0
cmpb $0x0, (%r14)
je 0x1fba1
jmp 0x1fbad
movq 0x64466(%rip), %r14     # 0x83fe0
movq %rsp, %rdi
pushq $0x24
popq %rdx
pushq $0x1
popq %r8
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1e0c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb510
movq %rsp, %rdi
callq 0x1e15c
movq 0x64438(%rip), %rdi     # 0x83fe0
callq 0xb2f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1e15c
jmp 0x1fbca
jmp 0x1fbc7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1e15c
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::COutErr const& Common_sp::COutErr::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const COutErr& operator<< (const T &val) const
      { cout << val;
        if (! both)
          cerr << val;
        return *this;
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x6439d(%rip), %rdi     # 0x83f88
callq 0xb510
cmpb $0x0, (%rbx)
jne 0x1fc04
movq 0x643e4(%rip), %rdi     # 0x83fe0
movq %r14, %rsi
callq 0xb510
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator<(Common_sp::Vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) const
bool operator< (const Vector<T> &other) const
      // Lexicographic comparison
      { const size_t n = std::min (P::size (), other. size ());
        for (size_t i = 0; i < n; i++)
      	{ if ((*this) [i] < other [i]) return true;
      		if (other [i] < (*this) [i]) return false;
        }
        return P::size () < other. size ();
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x5, %rax
movq 0x8(%rsi), %r13
subq (%rsi), %r13
sarq $0x5, %r13
cmpq %rax, %r13
cmovaeq %rax, %r13
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x211c3
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d398
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1d398
movq %r12, %rdi
movq %rax, %rsi
callq 0x1c260
movl %eax, %ebp
testb %al, %al
jne 0x211d8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1d398
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d398
movq %r12, %rdi
movq %rax, %rsi
callq 0x1c260
incq %r15
testb %al, %al
je 0x21167
jmp 0x211d8
movq 0x8(%r14), %rax
subq (%r14), %rax
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
cmpq %rcx, %rax
setb %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/common.cpp
// Function: Common_sp::get_threads_max_max()
size_t get_threads_max_max () 
{
#ifdef __APPLE__
//stderr << "Compiled for MacOS" << "\n";
  int count = 0;
  /*const*/ size_t count_len = sizeof(count);
  sysctlbyname ("hw.logicalcpu", &count, &count_len, nullptr, 0);
//fprintf(stderr,"you have %i cpu cores", count);
  ASSERT (count >= 0);
  return (size_t) count;
#else
  LineInput f ("/proc/cpuinfo");
  size_t n = 0;
  while (f. nextLine ())
    if (isLeft (f. line, "processor"))
      n++;
  return n;
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
leaq 0x39fcc(%rip), %rsi     # 0x5b8c8
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b7b6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x1d20a
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xbb68
xorl %ebx, %ebx
leaq 0x30(%rsp), %r12
leaq 0x39f9f(%rip), %r13     # 0x5b8d6
leaq 0xf(%rsp), %rbp
movq %r12, %rdi
callq 0x219d4
testb %al, %al
je 0x2197a
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1b7b6
leaq 0x298(%rsp), %rdi
movq %r14, %rsi
callq 0x1d2b2
movl %eax, %r15d
movq %r14, %rdi
callq 0xbb68
movzbl %r15b, %eax
addq %rax, %rbx
jmp 0x2193c
leaq 0x30(%rsp), %rdi
callq 0x1d368
movq %rbx, %rax
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x219cb
movq %rax, %rbx
jmp 0x219cb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb68
jmp 0x219c1
jmp 0x219be
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1d368
movq %rbx, %rdi
callq 0xba30
nop