LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::PathNeedDecision(SequencePath&, std::multimap<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>**, int)
int WholeGenome::PathNeedDecision(SequencePath& sp, multimap<int, int> * choices_by_pos[], int pos){
    for(int i = 0; i < 2; i++){
        if(choices_by_pos[i]->find(pos) != choices_by_pos[i]->end()){
            pair<multimap<int, int>::iterator, multimap<int, int>::iterator> var_range;
            var_range = choices_by_pos[i]->equal_range(pos);

            for(auto it = var_range.first; it != var_range.second; ++it){
                int var_index = (*it).second;
                if(sp.choice_vector[var_index] <= MEANING_CHOICE_BOUND) return var_index;
            }
            // you need to make choices now
            // if(sp.choice_made[i].find(pos) == sp.choice_made[i].end()){
            //     // no choice made at current pos
            //     return true;
            // }
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
leaq 0x4(%rsp), %r12
movl %ecx, (%r12)
xorl %ebp, %ebp
cmpq $0x2, %rbp
je 0x10d06
movq (%r14,%rbp,8), %rdi
movq %r12, %rsi
callq 0x1e11c
movq (%r14,%rbp,8), %rdi
leaq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x10cf0
movq %r12, %rsi
callq 0x1f2e8
movq %rdx, %r13
movq 0x168(%r15), %rbx
cmpq %r13, %rax
je 0x10cf0
movslq 0x24(%rax), %rcx
cmpl $-0x9, (%rbx,%rcx,4)
jl 0x10cf5
movq %rax, %rdi
callq 0x5240
jmp 0x10cd7
incq %rbp
jmp 0x10ca6
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
jmp 0x10cf7
nop
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::CalculateScore(DiploidVariant&, int, int, int, int)
int WholeGenome::CalculateScore(DiploidVariant & dv,
                                int choice,
                                int score_unit,
                                int match_mode,
                                int score_scheme){
    int score = 0;
    if(choice <= NOT_USE) return score;
    if(score_unit == 0){
        score = 1;
    }else if(score_unit == 1){
        if(match_mode == 0){
            if(choice == -1){
                score += ScoreEditDistance(dv, 0);
            }else if(choice == -2){
                score += ScoreEditDistance(dv, 1);
            }else if(choice == 0){
                score += ScoreEditDistance(dv, 0);
                if(dv.multi_alts && !dv.zero_one_var){
                    score += ScoreEditDistance(dv, 1);
                }
            }else{
                score += ScoreEditDistance(dv, 0);
                score += ScoreEditDistance(dv, 1);
            }
        }else{
            score += ScoreEditDistance(dv, choice);
        }
    }

    if(score_scheme == 0){
        return score;
    }else if(score_scheme == 1 || score_scheme == 2){
        if(dv.flag == false && score_scheme == 1){
            return score;
        }else if(dv.flag && score_scheme == 2){
            return score;
        }else{
            return 0;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
cmpl $-0x8, %edx
jl 0x110ca
movl %r9d, %ebx
movq %rsi, %r14
testl %ecx, %ecx
je 0x1109f
cmpl $0x1, %ecx
jne 0x110a4
movq %rdi, %r15
testl %r8d, %r8d
je 0x110d5
movq %r15, %rdi
movq %r14, %rsi
callq 0xea6a
movl %eax, %ebp
jmp 0x110a6
pushq $0x1
popq %rbp
jmp 0x110a6
xorl %ebp, %ebp
testl %ebx, %ebx
je 0x110ca
cmpl $0x1, %ebx
sete %cl
movb 0x4c(%r14), %al
testb %al, %al
sete %dl
testb %dl, %cl
jne 0x110ca
xorl %ecx, %ecx
testb %al, %al
cmovel %ecx, %ebp
cmpl $0x2, %ebx
cmovnel %ecx, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x2, %edx
je 0x1111c
testl %edx, %edx
je 0x110ed
cmpl $-0x1, %edx
jne 0x11124
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
jmp 0x11096
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xea6a
movl %eax, %ebp
cmpb $0x1, 0x41(%r14)
jne 0x110a6
cmpb $0x0, 0x42(%r14)
jne 0x110a6
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xea6a
addl %eax, %ebp
jmp 0x110a6
pushq $0x1
popq %rdx
jmp 0x11090
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xea6a
movl %eax, %r12d
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xea6a
movl %eax, %ebp
addl %r12d, %ebp
jmp 0x110a6
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::PrintPath(SequencePath&)
void WholeGenome::PrintPath(SequencePath & sp){
    cout << "- Sequence Path:" << endl;
    cout << "@ String Sequences:" << endl;
    for(int i = 0; i < 4; i++){
        for(int j = 0; j < sp.string_sequences[i].size(); j++){
            cout << sp.string_sequences[i][j] << " ";
        }
        cout << endl;
    }
    cout << "@ Donor Sequences:" << endl;
    for(int i = 0; i < 4; i++){
        cout << sp.donor_sequences[i] << endl;
    }
    cout << "@ Removable: " << sp.removable << endl;

    for(int i = 0; i < sp.choice_vector.size(); i++){
        cout << sp.choice_vector[i] << ",";
    }
    cout << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x1c71e(%rip), %r14     # 0x2ffc0
leaq 0xef44(%rip), %rsi      # 0x227ed
movq %r14, %rdi
callq 0x52f0
movq %rax, %rdi
callq 0x5190
leaq 0xef3e(%rip), %rsi      # 0x227fe
movq %r14, %rdi
callq 0x52f0
movq %rax, %rdi
callq 0x5190
movq %rbx, 0x8(%rsp)
leaq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0xe57f(%rip), %r15      # 0x21e67
cmpq $0x4, %r13
je 0x1393c
imulq $0x18, %r13, %rbp
addq 0x10(%rsp), %rbp
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%rbp), %rsi
movq 0x8(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x1392f
addq %rbx, %rsi
movq %r14, %rdi
callq 0x52c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x52f0
incq %r12
addq $0x20, %rbx
jmp 0x138fc
movq %r14, %rdi
callq 0x5190
incq %r13
jmp 0x138e8
movq 0x1c67d(%rip), %r14     # 0x2ffc0
leaq 0xeec8(%rip), %rsi      # 0x22812
movq %r14, %rdi
callq 0x52f0
movq %rax, %rdi
callq 0x5190
movq 0x8(%rsp), %r12
leaq 0xd0(%r12), %rbx
xorl %r15d, %r15d
cmpq $0x80, %r15
je 0x1398d
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x52c0
movq %rax, %rdi
callq 0x5190
addq $0x20, %r15
jmp 0x1396a
movq 0x1c62c(%rip), %r14     # 0x2ffc0
leaq 0xee8a(%rip), %rsi      # 0x22825
movq %r14, %rdi
callq 0x52f0
movzbl 0x15c(%r12), %esi
movq %rax, %rdi
callq 0x54f0
movq %rax, %rdi
callq 0x5190
xorl %ebx, %ebx
leaq 0xeb84(%rip), %r15      # 0x22549
movq 0x168(%r12), %rax
movq 0x170(%r12), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbx, %rcx
jbe 0x139fc
movl (%rax,%rbx,4), %esi
movq %r14, %rdi
callq 0x5530
movq %rax, %rdi
movq %r15, %rsi
callq 0x52f0
incq %rbx
jmp 0x139c5
movq 0x1c5bd(%rip), %rdi     # 0x2ffc0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5190
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::ConvergePaths(std::__cxx11::list<SequencePath, std::allocator<SequencePath>>&)
void WholeGenome::ConvergePaths(list<SequencePath> & path_list){
    //dout << "===========start converge===================" << endl;
    int path_num = path_list.size();
    if(path_num <= 1) return;
    for(list<SequencePath>::iterator i = path_list.begin(); i!= path_list.end(); ++i){
        SequencePath  ref_path = *i;
        if(ref_path.removable) continue;
        if(!ref_path.same_donor_len) continue;
        list<SequencePath>::iterator j = i;
        ++j;
        for(; j != path_list.end(); ++j){
            SequencePath que_path = *j;
            if(que_path.removable) continue;
            if(!que_path.same_donor_len) continue;
            //dout << "Comparing following paths: " << endl;
            //PrintPath(ref_path);
            //PrintPath(que_path);
            if(DonorLengthEqual(ref_path, que_path)){
                if(ref_path.score >= que_path.score){
                    (*j).removable = true;
                    //dout << "delete path: " << endl;
                    //PrintPath((*j));
                }else{
                    (*i).removable = true;
                    //dout << "delete path: " << endl;
                    //PrintPath((*i));
                    break;
                }
            }
            //dout << "-    -     -   -   -   -   -  - - -" << endl;
        }
    }

    path_list.remove_if(IsRemovable);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
cmpl $0x2, 0x10(%rsi)
jl 0x14185
movq %rsi, %rbx
movq %rsp, %r14
leaq 0x180(%rsp), %r15
movq %rsi, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x14176
leaq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0x1a3e8
cmpb $0x0, 0x15c(%rsp)
jne 0x14169
cmpb $0x1, 0x15d(%rsp)
jne 0x14169
movq %r12, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x14169
leaq 0x10(%r13), %rsi
movq %r15, %rdi
callq 0x1a3e8
cmpb $0x0, 0x2dc(%rsp)
jne 0x1414e
cmpb $0x1, 0x2dd(%rsp)
jne 0x1414e
movq %r14, %rsi
movq %r15, %rdx
callq 0x16860
testb %al, %al
je 0x1414e
movl 0x158(%rsp), %eax
cmpl 0x2d8(%rsp), %eax
jl 0x14158
movb $0x1, 0x16c(%r13)
movq %r15, %rdi
callq 0x1a5b0
jmp 0x140fe
movb $0x1, 0x16c(%r12)
movq %r15, %rdi
callq 0x1a5b0
movq %r14, %rdi
callq 0x1a5b0
jmp 0x140cd
leaq 0x2766(%rip), %rsi      # 0x168e3
movq %rbx, %rdi
callq 0x1a9b4
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a5b0
movq %rbx, %rdi
callq 0x5540
nop
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::ReadDirectRef(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void WholeGenome::ReadDirectRef(string genome_seq, string ref_vcf){

    for(int i = 0; i < 22; i++){
        chrid_by_chrname[to_string(i+1)] = i;
        chrname_by_chrid[i] = to_string(i+1);
    }
    chrid_by_chrname["X"] = 22;
    chrname_by_chrid[22] = "X";
    chrid_by_chrname["Y"] = 23;
    chrname_by_chrid[23]="Y";
    baseline_variant_total_num = ReadReferenceVariants(ref_vcf);
    ref_vcf_filename = ref_vcf;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x30(%rsp)
movq %rdi, %r14
leaq 0x88(%rdi), %r12
leaq 0xb8(%rdi), %r15
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
leaq 0xc(%rsp), %rbp
movl %ebx, 0xc(%rsp)
cmpl $0x16, %ebx
jge 0x18e21
leal 0x1(%rbx), %esi
movq %r13, %rdi
callq 0x8011
movq %r12, %rdi
movq %r13, %rsi
callq 0x199a8
movl %ebx, (%rax)
movq %r13, %rdi
callq 0x55e8
movl 0xc(%rsp), %esi
incl %esi
movq %r13, %rdi
callq 0x8011
movq %r15, %rdi
movq %rbp, %rsi
callq 0x19a5a
movq %rax, %rdi
movq %r13, %rsi
callq 0x5390
movq %r13, %rdi
callq 0x55e8
movl 0xc(%rsp), %ebx
incl %ebx
jmp 0x18dc4
leaq 0x949f(%rip), %rsi      # 0x222c7
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x72ee
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x199a8
pushq $0x16
popq %rbx
movl %ebx, (%rax)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x55e8
movl %ebx, (%r13)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x1aa34
leaq 0x9459(%rip), %rsi      # 0x222c7
movq %rax, %rdi
callq 0x55b0
leaq 0x944f(%rip), %rsi      # 0x222cc
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x72ee
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x199a8
pushq $0x17
popq %rbx
movl %ebx, (%rax)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x55e8
movl %ebx, (%r12)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x1aa34
leaq 0x9409(%rip), %rsi      # 0x222cc
movq %rax, %rdi
callq 0x55b0
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x53f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x18c70
movl %eax, 0x48(%r14)
leaq 0x38(%rsp), %rdi
callq 0x55e8
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x18f36
jmp 0x18f2e
jmp 0x18f27
jmp 0x18f2e
movq %rax, %rbx
jmp 0x18f3b
jmp 0x18f2e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x55e8
movq %rbx, %rdi
callq 0x5540
nop
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/./diploidvariant.h
// Function: DiploidVariant::DiploidVariant(int, 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>>>>, bool, bool, int, int, bool, double, bool)
DiploidVariant(int pos_ = -1,
        string ref_ = "",
        vector<string> alts_ = {"",""},
        bool heterozygous_ = false,
        bool multi_alts_ = false,
        int mdl_ = 0,
        int mil_ = 0,
        bool flag_ = false,
        double qual_ = 0.0,
        bool zero_one_var_ = false) :
        pos(pos_),
        ref(ref_),
        alts(alts_),
        heterozygous(heterozygous_),
        multi_alts(multi_alts_),
        mdl(mdl_),
        mil(mil_),
        flag(flag_),
        qual(qual_),
        zero_one_var(zero_one_var_){}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %r9d, %ebp
movl %r8d, %r14d
movq %rcx, %r12
movq %rdi, %rbx
movl %esi, (%rdi)
leaq 0x8(%rdi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x53f0
leaq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x19af0
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movl 0x48(%rsp), %edx
movl 0x40(%rsp), %esi
movb %r14b, 0x40(%rbx)
movb %bpl, 0x41(%rbx)
movb %al, 0x42(%rbx)
movl %esi, 0x44(%rbx)
movl %edx, 0x48(%rbx)
movb %cl, 0x4c(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x50(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x55e8
movq %rbx, %rdi
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::EditDistance(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&)
inline int WholeGenome::EditDistance(const std::string& s1, const std::string& s2)
{
	const std::size_t len1 = s1.size(), len2 = s2.size();
	std::vector<unsigned int> col(len2+1), prevCol(len2+1);

	for (unsigned int i = 0; i < prevCol.size(); i++)
		prevCol[i] = i;
	for (unsigned int i = 0; i < len1; i++) {
		col[0] = i+1;
		for (unsigned int j = 0; j < len2; j++)
                        // note that std::min({arg1, arg2, arg3}) works only in C++11,
                        // for C++98 use std::min(std::min(arg1, arg2), arg3)
			col[j+1] = std::min({ prevCol[1 + j] + 1, col[j] + 1, prevCol[j] + (s1[i]==s2[j] ? 0 : 1) });
		col.swap(prevCol);
	}
	return prevCol[len2];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x60(%rsp)
movq 0x8(%rdx), %r13
leaq 0x1(%r13), %r15
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
callq 0x1af42
leaq 0x10(%rsp), %rdi
leaq 0x34(%rsp), %rdx
movq %r15, %rsi
callq 0x1af42
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
subq %rcx, %rax
sarq $0x2, %rax
xorl %edx, %edx
movl %edx, %esi
cmpq %rsi, %rax
jbe 0x19d86
movl %edx, (%rcx,%rsi,4)
incl %edx
jmp 0x19d78
xorl %eax, %eax
movl %eax, %ebp
cmpq %rbp, 0x60(%rsp)
jbe 0x19e2d
leal 0x1(%rbp), %eax
movq 0x40(%rsp), %rcx
movl %eax, 0xc(%rsp)
movl %eax, (%rcx)
pushq $0x1
popq %rax
movl %eax, %r15d
leal -0x1(%r15), %eax
cmpq %rax, %r13
jbe 0x19e01
movl %r15d, %r12d
movq 0x10(%rsp), %rdx
movl (%rdx,%r12,4), %esi
incl %esi
movl %esi, 0x34(%rsp)
movl (%rcx,%rax,4), %ecx
incl %ecx
movl %ecx, 0x38(%rsp)
movq (%r14), %rcx
movb (%rcx,%rbp), %cl
movq (%rbx), %rsi
xorl %edi, %edi
cmpb (%rsi,%rax), %cl
setne %dil
addl (%rdx,%rax,4), %edi
movl %edi, 0x3c(%rsp)
leaq 0x34(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x1af93
movq 0x40(%rsp), %rcx
movl %eax, (%rcx,%r12,4)
incl %r15d
jmp 0x19da9
movaps 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rsp)
movups 0x48(%rsp), %xmm1
movaps %xmm0, 0x40(%rsp)
movq %rax, 0x50(%rsp)
movups %xmm1, 0x18(%rsp)
movl 0xc(%rsp), %eax
jmp 0x19d88
movl (%rcx,%r13,4), %ebx
leaq 0x10(%rsp), %rdi
callq 0x1afce
leaq 0x40(%rsp), %rdi
callq 0x1afce
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x19e68
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1afce
leaq 0x40(%rsp), %rdi
callq 0x1afce
movq %rbx, %rdi
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::initialize_score_matrix(int**, char**, int, int)
inline void WholeGenome::initialize_score_matrix(int **score, char **trackBack, int M, int N)
{
    for (int i = 0; i < M+1; i++)
    {
        score[0][i] = i * -1;
        trackBack[0][i] = '-';
    }

    for (int i = 0; i < N+1; i++)
    {
        score[i][0] = i * -1;
        trackBack[i][0] = '|';
    }

    trackBack[0][0] = '*';
}

// Assembly:
movslq %ecx, %rax
xorl %ecx, %ecx
xorl %edi, %edi
cmpq %rax, %rdi
jg 0x19e9c
movq (%rsi), %r9
movl %ecx, (%r9,%rdi,4)
movq (%rdx), %r9
movb $0x2d, (%r9,%rdi)
incq %rdi
decl %ecx
jmp 0x19e81
movslq %r8d, %rax
xorl %ecx, %ecx
xorl %edi, %edi
cmpq %rax, %rdi
jg 0x19ebe
movq (%rsi,%rdi,8), %r8
movl %ecx, (%r8)
movq (%rdx,%rdi,8), %r8
movb $0x7c, (%r8)
incq %rdi
decl %ecx
jmp 0x19ea3
movq (%rdx), %rax
movb $0x2a, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/./diploidvariant.h
// Function: DiploidVariant::operator==(DiploidVariant const&)
bool operator ==(const DiploidVariant& y) {
        if (pos == y.pos && ref == y.ref) {
            if(heterozygous == y.heterozygous && multi_alts == y.multi_alts){
                if (multi_alts && heterozygous) {
                    int match_times = 0;
                    for (int i = 0; i < 2; i++) {
                        for (int j = 0; j < 2; j++) {
                            if (alts[i] == y.alts[j])
                                match_times++;
                        }
                    }
                    if (match_times >= 2)
                        return true;
                }
                else if(alts[0] == y.alts[0]){
                    return true;
                }
            }
            if(multi_alts && zero_one_var && y.multi_alts && y.zero_one_var){
                int match_times = 0;
                for (int i = 0; i < 2; i++) {
                    for (int j = 0; j < 2; j++) {
                        if (alts[i] == y.alts[j])
                            match_times++;
                    }
                }
                if(match_times > 1) return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x1a162
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x93ce
testb %al, %al
je 0x1a162
movb 0x40(%r14), %al
cmpb 0x40(%rbx), %al
jne 0x1a103
movb 0x41(%r14), %cl
cmpb 0x41(%rbx), %cl
jne 0x1a103
andb %al, %cl
cmpb $0x1, %cl
jne 0x1a0e5
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq $0x2, %r15
je 0x1a0fc
movq %r15, %r12
shlq $0x5, %r12
xorl %r13d, %r13d
cmpq $0x40, %r13
je 0x1a0e0
movq 0x28(%r14), %rdi
addq %r12, %rdi
movq 0x28(%rbx), %rsi
addq %r13, %rsi
callq 0x93ce
movzbl %al, %eax
addl %eax, %ebp
addq $0x20, %r13
jmp 0x1a0bc
incq %r15
jmp 0x1a0ac
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
callq 0x93ce
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0x1a103
jmp 0x1a164
movb $0x1, %al
cmpl $0x2, %ebp
jge 0x1a164
cmpb $0x1, 0x41(%r14)
jne 0x1a162
cmpb $0x1, 0x42(%r14)
jne 0x1a162
cmpb $0x1, 0x41(%rbx)
jne 0x1a162
cmpb $0x1, 0x42(%rbx)
jne 0x1a162
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq $0x2, %r15
je 0x1a15b
movq %r15, %r12
shlq $0x5, %r12
xorl %r13d, %r13d
cmpq $0x40, %r13
je 0x1a156
movq 0x28(%r14), %rdi
addq %r12, %rdi
movq 0x28(%rbx), %rsi
addq %r13, %rsi
callq 0x93ce
movzbl %al, %eax
addl %eax, %ebp
addq $0x20, %r13
jmp 0x1a132
incq %r15
jmp 0x1a122
movb $0x1, %al
cmpl $0x2, %ebp
jge 0x1a164
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/./wholegenome.h
// Function: WholeGenome::merge(std::vector<Interval, std::allocator<Interval>>&)
vector<Interval> merge(vector<Interval> &intervals) {
        sort(intervals.begin(),intervals.end(),compInterval());
        vector<Interval> results;
        for(int i=0; i<intervals.size(); i++) {
            if(results.empty() || results.back().end < intervals[i].start)  // no overlap
                results.push_back(intervals[i]);
            else   // overlap
                results.back().end = max(results.back().end, intervals[i].end);
        }
        return results;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
movq 0x8(%rdx), %rsi
callq 0x1b141
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x1a2bb
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
je 0x1a298
movl -0x4(%rax), %ecx
cmpl (%rsi,%r12,8), %ecx
jge 0x1a2a5
addq %r15, %rsi
movq %rbx, %rdi
callq 0x1b124
jmp 0x1a2b2
movl 0x4(%rsi,%r12,8), %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
movl %edx, -0x4(%rax)
incq %r12
addq $0x8, %r15
jmp 0x1a273
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c30e
movq %r14, %rdi
callq 0x5540
nop
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/./wholegenome.h
// Function: SequencePath::SequencePath(int, int)
SequencePath(int n, int v)
    {
        reference_length = n;
        for(int i = 0; i < 4; i++){
            string_sequences[i].resize(n, ".");
            // default value is "."
            donor_sequences[i] = "";
        }
        current_genome_pos = -1;
        score = 0;
        removable = false;
        same_donor_len = false;
        current_equal_donor_pos[0] = -1;
        current_equal_donor_pos[1] = -1;
        reached_sync_num = 0;

        for(int i = 0; i < v; i++){
            choice_vector.push_back(-89);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x4(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
pushq $0x70
popq %rax
leaq (%rbx,%rax), %rcx
andl $0x0, (%rbx,%rax)
andq $0x0, 0x8(%rbx,%rax)
movq %rcx, 0x10(%rbx,%rax)
movq %rcx, 0x18(%rbx,%rax)
andq $0x0, 0x20(%rbx,%rax)
addq $0x30, %rax
cmpq $0xd0, %rax
jne 0x1a64b
movl $0xe0, %eax
leaq (%rbx,%rax), %rcx
movq %rcx, -0x10(%rbx,%rax)
andq $0x0, -0x8(%rbx,%rax)
movb $0x0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x160, %rax            # imm = 0x160
jne 0x1a67a
leaq 0xd0(%rbx), %r15
leaq 0x168(%rbx), %r14
xorps %xmm0, %xmm0
andq $0x0, 0x178(%rbx)
movups %xmm0, 0x168(%rbx)
movl %esi, (%rbx)
movslq %esi, %r12
pushq $0x8
popq %r13
leaq 0x8(%rsp), %rbp
cmpq $0x68, %r13
je 0x1a711
movq %rbp, %rdi
leaq 0x8367(%rip), %rsi      # 0x22a3e
leaq 0x3(%rsp), %rdx
callq 0x72ee
leaq (%rbx,%r13), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1b934
movq %rbp, %rdi
callq 0x55e8
movq %r15, %rdi
leaq 0x7ea8(%rip), %rsi      # 0x225aa
callq 0x55b0
addq $0x18, %r13
addq $0x20, %r15
jmp 0x1a6c7
orl $-0x1, 0xc8(%rbx)
andl $0x0, 0x158(%rbx)
andw $0x0, 0x15c(%rbx)
orq $-0x1, 0x150(%rbx)
andl $0x0, 0x160(%rbx)
xorl %ebp, %ebp
movl 0x4(%rsp), %eax
testl %eax, %eax
cmovgl %eax, %ebp
leaq 0x8(%rsp), %r15
subl $0x1, %ebp
jb 0x1a760
movl $0xffffffa7, 0x8(%rsp)  # imm = 0xFFFFFFA7
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c1d4
jmp 0x1a746
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a782
jmp 0x1a782
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x55e8
jmp 0x1a785
movq %rax, %r15
movq %r14, %rdi
callq 0xce14
movl $0x130, %r14d           # imm = 0x130
leaq (%rbx,%r14), %rdi
callq 0x55e8
addq $-0x20, %r14
cmpq $0xb0, %r14
jne 0x1a793
movl $0x98, %r14d
leaq (%rbx,%r14), %rdi
callq 0x1b920
addq $-0x30, %r14
cmpq $0x38, %r14
jne 0x1a7af
pushq $0x50
popq %r14
leaq (%rbx,%r14), %rdi
callq 0xadcc
addq $-0x18, %r14
cmpq $-0x10, %r14
jne 0x1a7c6
movq %r15, %rdi
callq 0x5540
nop
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/./diploidvariant.h
// Function: DiploidVariant::CompareNoGenotype(DiploidVariant const&)
bool CompareNoGenotype(const DiploidVariant & y){
        if(pos == y.pos && ref == y.ref){
            if(alts[0] == y.alts[0]) return true;
            if(multi_alts){
                if(alts[1] == y.alts[0]) return true;
                if(y.multi_alts && alts[1] == y.alts[1]){
                    return true;
                }
            }
            if(y.multi_alts && alts[0] == y.alts[1]){
                return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x1acfb
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x93ce
testb %al, %al
je 0x1acfb
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
callq 0x93ce
movb $0x1, %bpl
testb %al, %al
jne 0x1acfd
cmpb $0x1, 0x41(%r14)
jne 0x1ace0
movq 0x28(%r14), %rdi
addq $0x20, %rdi
movq 0x28(%rbx), %rsi
callq 0x93ce
testb %al, %al
jne 0x1acfd
cmpb $0x1, 0x41(%rbx)
jne 0x1ace0
movq 0x28(%r14), %rdi
addq $0x20, %rdi
movq 0x28(%rbx), %rsi
addq $0x20, %rsi
callq 0x93ce
testb %al, %al
jne 0x1acfd
cmpb $0x1, 0x41(%rbx)
jne 0x1acfb
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
addq $0x20, %rsi
callq 0x93ce
testb %al, %al
jne 0x1acfd
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/medvedevgroup[P]varmatch/src/util.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>&)
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
	std::stringstream ss(s);
	std::string item;
	while (std::getline(ss, item, delim)) {
		if (!item.empty()) {
			elems.push_back(item);
		}
	}
	return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x5490
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5580
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x205dd
cmpq $0x0, 0x8(%rsp)
je 0x205ad
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc896
jmp 0x205ad
movq %rsp, %rdi
callq 0x55e8
leaq 0x20(%rsp), %rdi
callq 0x5270
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x55e8
leaq 0x20(%rsp), %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: makeMaximal(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
vector<PII> makeMaximal(vector<PII> &maximal)
{
    sort(maximal.begin(), maximal.end(), bySecond);
    maximal.erase(unique(maximal.begin(), maximal.end()), maximal.end());
    vector<PII> ret;
    int maxi = -1;
    for (size_t i = 0; i < maximal.size(); ++ i) {
        if (maximal[i].first <= maxi) {
            continue;
        }
        ret.push_back(maximal[i]);
        maxi = maximal[i].second;
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
leaq -0x35(%rip), %rdx       # 0x266c
callq 0x6c23
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x7233
movq 0x8(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4840
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq (%r14), %rsi
pushq $-0x1
popq %rax
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rcx
subq %rsi, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x270a
cmpl %eax, (%rsi,%r15)
jle 0x2701
addq %r15, %rsi
movq %rbx, %rdi
callq 0x4846
movq (%r14), %rsi
movl 0x4(%rsi,%r15), %eax
incq %r12
addq $0x8, %r15
jmp 0x26d8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x733a
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: writeBinary(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void writeBinary(FILE* out, const string &s)
{
	int n = s.size();
	fwrite(&n, sizeof(n), 1, out);
	if (n > 0) {
		fwrite(&s[0], sizeof(s[0]), n, out);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2350
movslq (%r15), %rdx
testq %rdx, %rdx
jle 0x27d4
movq (%r14), %rdi
pushq $0x1
popq %rsi
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2350
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: readBinary(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void readBinary(FILE* in, string &s)
{
	int n;
	fread(&n, sizeof(n), 1, in);
	s.resize(n);
	if (n > 0) {
		fread(&s[0], sizeof(s[0]), n, in);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2290
movslq (%r15), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2250
testq %r15, %r15
jle 0x2830
movq (%r14), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2290
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: getLine(_IO_FILE*)
bool getLine(FILE* in)
{
	bool ret = fgets(line, maxlength, in);
	int len = strlen(line);
	while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r')) {
		line[len - 1] = 0;
		-- len;
	}
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rdx
leaq 0xb9b8(%rip), %rbx      # 0xe200
movq %rbx, %rdi
movl $0x5f5e100, %esi        # imm = 0x5F5E100
callq 0x22c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20a0
movl %eax, %eax
testl %eax, %eax
jle 0x287f
movzbl -0x1(%rax,%rbx), %ecx
cmpl $0xd, %ecx
je 0x2875
cmpl $0xa, %ecx
jne 0x287f
movb $0x0, -0x1(%rax,%rbx)
decq %rax
jmp 0x2862
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: tryOpen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FILE* tryOpen(string filename, string param)
{
	FILE* ret = fopen(filename.c_str(), param.c_str());
	if (ret == NULL) {
		fprintf(stderr, "error while opening %s\n", filename.c_str());
	}
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x21e0
movq %rax, %rbx
testq %rax, %rax
je 0x28b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xb717(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0x6759(%rip), %rsi      # 0x901f
xorl %eax, %eax
callq 0x2260
jmp 0x28a7
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: splitBy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> splitBy(const string &line, char comma)
{
	vector<string> tokens;
	string token = "";
	bool inside = false;
	for (size_t i = 0; i < line.size(); ++ i) {
		if (line[i] == '"') {
			inside ^= 1;
		} else if (line[i] == comma && !inside) {
			tokens.push_back(token);
			token = "";
		} else {
			token += line[i];
		}
	}
	tokens.push_back(token);
	return tokens;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x6897(%rip), %rsi      # 0x918e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x48da
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
cmpq 0x8(%r14), %r13
jae 0x2965
movq (%r14), %rax
movb (%rax,%r13), %al
cmpb $0x22, %al
jne 0x2928
xorb $0x1, %r12b
jmp 0x2960
cmpb %bpl, %al
setne %cl
orb %r12b, %cl
testb $0x1, %cl
je 0x2943
movsbl %al, %esi
movq %r15, %rdi
callq 0x2150
jmp 0x2960
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4916
movq %r15, %rdi
leaq 0x6836(%rip), %rsi      # 0x918e
callq 0x2340
xorl %r12d, %r12d
incq %r13
jmp 0x2911
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4916
leaq 0x8(%rsp), %rdi
callq 0x2378
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2995
movq %rax, %r14
jmp 0x29a2
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2378
movq %rbx, %rdi
callq 0x4942
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../config/dna.h
// Function: loadConfiguration(int, char**)
void loadConfiguration(int argc, char *argv[])
{
    for (int i = 1; i + 1 < argc; ++ i) {
        string op = argv[i];
        if (op == "-no_exp") {
            EFFICIENT_EXPAND = false;
        } else if (op == "-no_chunk") {
            CHUNK_INDEX = false;
        } else if (op == "-no_prune") {
            PRUNE = false;
        } else if (op == "-o") {
            OUTPUT_FILENAME = argv[i + 1];
            ++ i;
        } else if (op == "-data") {
            DNA_FILENAME = argv[i + 1];
            ++ i;
        } else if (op == "-min_sup") {
            sscanf(argv[i + 1], "%d", &MIN_SUP);
            ++ i;
        } else if (op == "-edit") {
            sscanf(argv[i + 1], "%d", &EDIT_DIS_THRES);
            ++ i;
        } else if (op == "-length") {
            sscanf(argv[i + 1], "%d", &LEN_THRES);
            ++ i;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x1
popq %r13
leaq 0x8(%rsp), %r14
leal 0x1(%r13), %r15d
cmpl %ebp, %r15d
jge 0x2b31
movslq %r13d, %rax
movq (%rbx,%rax,8), %rsi
movq %r14, %rdi
leaq 0x7(%rsp), %rdx
callq 0x48da
movq %r14, %rdi
leaq 0x665f(%rip), %rsi      # 0x906b
callq 0x4963
testb %al, %al
je 0x2a21
movb $0x0, 0xb7ac(%rip)      # 0xe1c8
jmp 0x2b21
movq %r14, %rdi
leaq 0x6648(%rip), %rsi      # 0x9073
callq 0x4963
testb %al, %al
je 0x2a40
movb $0x0, 0xb78e(%rip)      # 0xe1c9
jmp 0x2b21
movq %r14, %rdi
leaq 0x6633(%rip), %rsi      # 0x907d
callq 0x4963
testb %al, %al
je 0x2a5f
movb $0x0, 0xb770(%rip)      # 0xe1ca
jmp 0x2b21
movq %r14, %rdi
leaq 0x661e(%rip), %rsi      # 0x9087
callq 0x4963
movslq %r15d, %r12
leaq 0x5f698b0(%rip), %rdi   # 0x5f6c328
testb %al, %al
jne 0x2a96
movq %r14, %rdi
leaq 0x6604(%rip), %rsi      # 0x908a
callq 0x4963
leaq 0x5f69876(%rip), %rdi   # 0x5f6c308
testb %al, %al
je 0x2aa4
movq (%rbx,%r12,8), %rsi
callq 0x2340
movl %r15d, %r13d
jmp 0x2b21
movq %r14, %rdi
leaq 0x65e2(%rip), %rsi      # 0x9090
callq 0x4963
testb %al, %al
je 0x2acb
movq (%rbx,%r12,8), %rdi
leaq 0x65d7(%rip), %rsi      # 0x9099
leaq 0xb703(%rip), %rdx      # 0xe1cc
jmp 0x2b17
movq %r14, %rdi
leaq 0x65c7(%rip), %rsi      # 0x909c
callq 0x4963
testb %al, %al
je 0x2af2
movq (%rbx,%r12,8), %rdi
leaq 0x65b0(%rip), %rsi      # 0x9099
leaq 0xb6e0(%rip), %rdx      # 0xe1d0
jmp 0x2b17
movq %r14, %rdi
leaq 0x65a6(%rip), %rsi      # 0x90a2
callq 0x4963
testb %al, %al
je 0x2b21
movq (%rbx,%r12,8), %rdi
leaq 0x6589(%rip), %rsi      # 0x9099
leaq 0xb6bd(%rip), %rdx      # 0xe1d4
xorl %eax, %eax
callq 0x2180
movl %r15d, %r13d
movq %r14, %rdi
callq 0x2378
incl %r13d
jmp 0x29e1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2378
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../config/dna.h
// Function: loadDNASequence[abi:cxx11]()
string loadDNASequence()
{
    FILE* in = tryOpen(DNA_FILENAME, "r");
    string dna = "";
    while (getLine(in)) {
        for (size_t i = 0; line[i]; ++ i) {
            line[i] = tolower(line[i]);
            myAssert(alphabet.find(line[i]) != -1, "Unknown Character: " + line[i]);
        }
        dna += line;
    }
    fclose(in);
    return dna;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r12
leaq 0x5f6979b(%rip), %rsi   # 0x5f6c308
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x2240
leaq 0x656d(%rip), %rsi      # 0x90ee
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x48da
leaq 0x58(%rsp), %rbx
leaq 0x38(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x288d
movq %rax, 0x10(%rsp)
movq %r15, %rdi
callq 0x2378
movq %rbx, %rdi
callq 0x2378
leaq 0x65cd(%rip), %rsi      # 0x918e
leaq 0x7(%rsp), %r15
movq %r12, %rdi
movq %r15, %rdx
callq 0x48da
leaq 0x5f69770(%rip), %r13   # 0x5f6c348
leaq 0x64cb(%rip), %r14      # 0x90aa
leaq 0x18(%rsp), %rbp
movq %r12, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x283a
testb %al, %al
je 0x2c68
leaq 0xb602(%rip), %r12      # 0xe200
movsbl (%r12), %edi
testl %edi, %edi
je 0x2c52
callq 0x2270
movb %al, (%r12)
movsbl %al, %esi
movq %r13, %rdi
xorl %edx, %edx
callq 0x2220
movq %rax, %rbx
movsbq (%r12), %rsi
addq %r14, %rsi
movq %rbp, %rdi
movq %r15, %rdx
callq 0x48da
xorl %edi, %edi
cmpq $-0x1, %rbx
setne %dil
movq %rbp, %rsi
callq 0x272c
movq %rbp, %rdi
callq 0x2378
incq %r12
jmp 0x2bfe
movq 0x8(%rsp), %r12
movq %r12, %rdi
leaq 0xb59f(%rip), %rsi      # 0xe200
callq 0x2330
jmp 0x2be9
movq 0x10(%rsp), %rdi
callq 0x21a0
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x2ca8
movq %rax, %r15
movq %r12, %r14
jmp 0x2ca8
movq %rax, %r15
jmp 0x2ca3
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x2378
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2378
movq %r15, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/MACFP.cpp
// Function: getOccurrence(int, int)
vector<int> getOccurrence(int i, int j)
{
    vector<int> ret(1, i);
    int ptr = s->sa->rank[i];
    myAssert(s->sa->sa[ptr] == i, "Wrong SA rank");
    int length = j - i + 1;
    while (ptr > 0 && s->sa->height[ptr] >= length) {
        -- ptr;
        ret.push_back(s->sa->sa[ptr]);
    }
    ptr = s->sa->rank[i];
    while (ptr + 1 < s->size() && s->sa->height[ptr + 1] >= length) {
        ++ ptr;
        ret.push_back(s->sa->sa[ptr]);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl %esi, (%r14)
pushq $0x1
popq %rsi
leaq 0xb(%rsp), %rcx
movq %r14, %rdx
callq 0x4970
movq 0x5f69680(%rip), %rax   # 0x5f6c368
movq 0x20(%rax), %rax
movslq (%r14), %r15
movq 0x28(%rax), %rcx
movq 0xa0(%rax), %rax
movq (%rax,%r15,8), %r14
movslq %r14d, %rax
movl (%rcx,%rax,4), %r12d
leaq 0x63b2(%rip), %rsi      # 0x90be
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x48da
xorl %edi, %edi
cmpl %r15d, %r12d
sete %dil
leaq 0x10(%rsp), %rsi
callq 0x272c
leaq 0x10(%rsp), %rdi
callq 0x2378
movslq 0xc(%rsp), %rax
movslq %ebp, %r15
subq %rax, %r15
incq %r15
movq 0x5f6961b(%rip), %rax   # 0x5f6c368
movq 0x20(%rax), %rax
testl %r14d, %r14d
jle 0x2d7f
movl %r14d, %ecx
movq 0xb8(%rax), %rdx
cmpq %r15, (%rdx,%rcx,8)
jl 0x2d7f
decl %r14d
leaq (,%r14,4), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x49c6
jmp 0x2d46
movslq 0xc(%rsp), %rcx
movq 0xa0(%rax), %rax
movslq (%rax,%rcx,8), %r14
leaq 0x4(,%r14,4), %rsi
incq %r14
movq 0x5f695c7(%rip), %rax   # 0x5f6c368
cmpq %r14, 0x8(%rax)
jbe 0x2dd0
movq 0x20(%rax), %rax
movq 0xb8(%rax), %rcx
cmpq %r15, (%rcx,%r14,8)
jl 0x2dd0
incq %r14
leaq 0x4(%rsi), %r12
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x49c6
movq %r12, %rsi
jmp 0x2d9a
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2378
jmp 0x2df6
jmp 0x2df3
jmp 0x2df3
movq %rax, %r14
movq %rbx, %rdi
callq 0x66a2
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/MACFP.cpp
// Function: checkSmallPatch(int, int)
vector<PII> checkSmallPatch(int l, int r)
{
    int length = r - l + 1;
    //myAssert(length <= SMALL_PATCH, "only for small patch!");
    vector<PII> ret(1, make_pair(l, r));
    enumerateEdit(l, 0, l, r, 1, s->size(), EDIT_DIS_THRES, ret);
    return makeMaximal(ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq %r14, %rax
shlq $0x20, %rax
movl %esi, %ecx
orq %rax, %rcx
leaq 0x20(%rsp), %rdx
movq %rcx, (%rdx)
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rsi
leaq 0x7(%rsp), %rcx
movq %r15, %rdi
callq 0x4b94
movq 0x5f68190(%rip), %rax   # 0x5f6c368
movl 0x8(%rax), %r9d
movl 0x9fee(%rip), %eax      # 0xe1d0
pushq $0x1
popq %r8
movl %ebp, %edi
xorl %esi, %esi
movl %ebp, %edx
movl %r14d, %ecx
pushq %r15
pushq %rax
callq 0x3d39
popq %rcx
popq %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2685
leaq 0x8(%rsp), %rdi
callq 0x733a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x733a
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::lcp(long long, long long)
long long lcp(long long i, long long j) {
        long long ret = 0;
        if (i == j) {
            ret = n - 1 - i;
        } else {
            long long l = rank[i], r = rank[j];
            if (l > r) {
                swap(l, r);
            }
            l += 1;
            ret = getMin(0, n - 1, l, r);
        }
        return ret;
    }

// Assembly:
cmpq %rdx, %rsi
jne 0x4a97
notq %rsi
addq (%rdi), %rsi
movq %rsi, %rax
retq
movq 0xa0(%rdi), %rax
movq (%rax,%rsi,8), %rsi
movq (%rax,%rdx,8), %r8
cmpq %r8, %rsi
movq %r8, %rcx
cmovlq %rsi, %rcx
cmovgq %rsi, %r8
movq (%rdi), %rdx
incq %rcx
decq %rdx
xorl %esi, %esi
jmp 0x5206
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::getMin(long long, long long, long long, long long)
long long getMin(long long l, long long r, long long ll, long long rr) {
        if (r < ll || l > rr) {
            return INF_LL;
        }
        if (ll <= l && r <= rr) {
            return segment_tree[ID(l, r)];
        }
        long long mid = l + r >> 1;
        return min(getMin(l, mid, ll, rr), getMin(mid + 1, r, ll, rr));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %r14
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %r13, %r15
jl 0x5268
cmpq %r12, %rsi
jg 0x5268
cmpq %r12, %r15
setg %al
cmpq %r13, %rsi
setl %cl
orb %al, %cl
je 0x5274
leaq (%rsi,%r15), %rbp
sarq %rbp
movq %r14, %rdi
movq %rbp, %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0x5206
incq %rbp
cmpq %rax, %rbx
cmovgeq %rax, %rbx
movq %rbp, %rsi
jmp 0x5227
movabsq $0xde0b6b3a7640000, %rax # imm = 0xDE0B6B3A7640000
jmp 0x528e
leaq (%rsi,%r15), %rax
xorl %ecx, %ecx
cmpq %r15, %rsi
setne %cl
orq %rax, %rcx
movq 0xd0(%r14), %rax
movq (%rax,%rcx,8), %rax
cmpq %rax, %rbx
cmovlq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::build_tree(long long, long long)
void build_tree(long long l, long long r) {
        if (l == r) {
            segment_tree[ID(l, r)] = height[l];
            return;
        }
        long long mid = l + r >> 1;
        build_tree(l, mid);
        build_tree(mid + 1, r);
        segment_tree[ID(l, r)] = min(segment_tree[ID(l, mid)], segment_tree[ID(mid + 1, r)]);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
jne 0x6060
movq 0xb8(%rbx), %rax
leaq (,%r15,8), %rcx
movq (%rax,%r15,8), %rax
addq 0xd0(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
jmp 0x60d2
movq %rdx, %r14
leaq (%rdx,%r15), %rbp
movq %rbp, %r12
sarq %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x602a
leaq 0x1(%r12), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x602a
leaq (%r12,%r15), %rax
xorl %ecx, %ecx
cmpq %r15, %r12
setne %cl
orq %rax, %rcx
movq 0xd0(%rbx), %rax
leaq (%r12,%r14), %rdx
incq %rdx
xorl %esi, %esi
cmpq %r14, %r13
setne %sil
orq %rdx, %rsi
movq (%rax,%rsi,8), %rdx
movq (%rax,%rcx,8), %rcx
cmpq %rcx, %rdx
cmovlq %rdx, %rcx
shlq $0x3, %rbp
orq $0x8, %rbp
movq %rcx, (%rax,%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::sort(int*, int*, int*, long long, int)
void sort(int *r, int *a, int *b, long long n, int m) {
        for (long long i = 0; i < n; ++ i) {
            wv[i] = r[a[i]];
        }
        for (int i = 0; i < m; ++ i) {
            wss[i]=0;
        }
        for (long long i = 0; i < n; ++ i) {
            ++ wss[wv[i]];
        }
        for (int i = 1; i < m; ++ i) {
            wss[i] += wss[i - 1];
        }
        for (long long i = n - 1; i >= 0; -- i) {
            b[-- wss[wv[i]]] = a[i];
        }
    }

// Assembly:
pushq %rbx
movq 0x70(%rdi), %r10
xorl %r11d, %r11d
testq %r8, %r8
movl $0x0, %eax
cmovgq %r8, %rax
cmpq %r11, %rax
je 0x648b
movslq (%rdx,%r11,4), %rbx
movl (%rsi,%rbx,4), %ebx
movl %ebx, (%r10,%r11,4)
incq %r11
jmp 0x6476
movq 0x88(%rdi), %rsi
xorl %r10d, %r10d
testl %r9d, %r9d
movl $0x0, %r11d
cmovgl %r9d, %r11d
cmpq %r10, %r11
je 0x64b1
andl $0x0, (%rsi,%r10,4)
incq %r10
jmp 0x64a2
movq 0x70(%rdi), %rsi
movq 0x88(%rdi), %r10
xorl %r11d, %r11d
cmpq %r11, %rax
je 0x64d1
movslq (%rsi,%r11,4), %rbx
incl (%r10,%rbx,4)
incq %r11
jmp 0x64bf
movq 0x88(%rdi), %rax
movslq %r9d, %rsi
movabsq $0x1, %r9
cmpq %rsi, %r9
jge 0x64f8
movl -0x4(%rax,%r9,4), %r10d
addl %r10d, (%rax,%r9,4)
incq %r9
jmp 0x64e5
movq 0x70(%rdi), %rax
movq 0x88(%rdi), %rsi
testq %r8, %r8
jle 0x6528
movl -0x4(%rdx,%r8,4), %edi
movslq -0x4(%rax,%r8,4), %r9
decq %r8
movslq (%rsi,%r9,4), %r10
leaq -0x1(%r10), %r11
movl %r11d, (%rsi,%r9,4)
movl %edi, -0x4(%rcx,%r10,4)
jmp 0x6503
popq %rbx
retq