LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cmp_haplotype_evdience(void const*, void const*)
int cmp_haplotype_evdience(const void * a, const void * b)
{
    if ((*(haplotype_evdience*)a).site != (*(haplotype_evdience*)b).site)
    {
        return (*(haplotype_evdience*)a).site > (*(haplotype_evdience*)b).site ? 1 : -1; 
    }
    else
    {
        if ((*(haplotype_evdience*)a).type != (*(haplotype_evdience*)b).type)
        {
            return (*(haplotype_evdience*)a).type > (*(haplotype_evdience*)b).type ? 1 : -1; 
        }
        else
        {
            if ((*(haplotype_evdience*)a).misBase != (*(haplotype_evdience*)b).misBase)
            {
                return (*(haplotype_evdience*)a).misBase > (*(haplotype_evdience*)b).misBase ? 1 : -1; 
            }
            else
            {
                return 0;
            }
            
        }
        
    }
    
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x3c5ba
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3c631
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0xc(%rcx), %ecx
cmpl %ecx, %eax
je 0x3c5f2
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %edx
movq -0x18(%rbp), %rax
movzbl 0xc(%rax), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovgl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3c631
movq -0x10(%rbp), %rax
movsbl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0x14(%rcx), %ecx
cmpl %ecx, %eax
je 0x3c62a
movq -0x10(%rbp), %rax
movsbl 0x14(%rax), %edx
movq -0x18(%rbp), %rax
movsbl 0x14(%rax), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovgl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3c631
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cmp_snp_stats(void const*, void const*)
int cmp_snp_stats(const void * a, const void * b)
{
    if ((*(SnpStats*)a).score != (*(SnpStats*)b).score)
    {
        return (*(SnpStats*)a).score < (*(SnpStats*)b).score ? 1 : -1; 
    }
    else
    {
        if ((*(SnpStats*)a).occ_2 != (*(SnpStats*)b).occ_2)
        {
            return (*(SnpStats*)a).occ_2 > (*(SnpStats*)b).occ_2 ? 1 : -1; 
        }
        else
        {
            return 0;
        }   
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
je 0x3daae
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3dae7
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0x3dae0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3dae7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: calculate_distance_snp_vector(signed char*, signed char*, int)
int calculate_distance_snp_vector(int8_t *vector1, int8_t *vector2, int Len)
{
    int i;
    for (i = 0; i < Len; i++)
    {
        if(vector1[i] != vector2[i])
        {
            if ((vector1[i] == 0 || vector1[i] == 1) && (vector2[i] == 0 || vector2[i] == 1))
            {
                return 1;
            }
        }
    }
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3df36
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x3df29
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3defc
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x3df27
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3df1e
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x3df27
movl $0x1, -0x4(%rbp)
jmp 0x3df3d
jmp 0x3df29
jmp 0x3df2b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3deb6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: add_to_result_snp_vector(haplotype_evdience_alloc*, signed char*, int)
void add_to_result_snp_vector(haplotype_evdience_alloc* hap, int8_t *new_vector, int Len)
{
    int8_t *r_vector = Get_Result_SNP_Vector((*hap));
    int j;
    for (j = 0; j < Len; j++)
    {
        if(r_vector[j] == -1)
        {
            if(new_vector[j] == 0)
            {
                hap->result_stat.occ_0++;
                r_vector[j] = new_vector[j];
            }
            else if(new_vector[j] == 1)
            {
                hap->result_stat.occ_1++;
                r_vector[j] = new_vector[j];
            }
        }
        ///can debug here
    }

    hap->result_stat.overlap_num = hap->result_stat.occ_0 + hap->result_stat.occ_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3e25c
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $-0x1, %eax
jne 0x3e24c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x3e20e
movq -0x8(%rbp), %rax
movl 0x1f4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1f4(%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x3e24a
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x3e248
movq -0x8(%rbp), %rax
movl 0x1f8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1f8(%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x3e24a
jmp 0x3e24c
jmp 0x3e24e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e1b5
movq -0x8(%rbp), %rax
movl 0x1f4(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x1f8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1f0(%rax)
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: debug_add_to_result_snp_vector(haplotype_evdience_alloc*, signed char*, int)
int debug_add_to_result_snp_vector(haplotype_evdience_alloc* hap, int8_t *new_vector, int Len)
{
    int8_t *r_vector = Get_Result_SNP_Vector((*hap));
    int j;
    for (j = 0; j < Len; j++)
    {
        if(r_vector[j] == -1)
        {
            if(new_vector[j] == 0)
            {
                hap->result_stat.occ_0++;
                r_vector[j] = new_vector[j];
            }
            else if(new_vector[j] == 1)
            {
                hap->result_stat.occ_1++;
                r_vector[j] = new_vector[j];
            }
        }
        else ///can debug here
        {
            ///if((new_vector[j] != -1 && new_vector[j] != 2 && new_vector[j] != r_vector[j]))
            if((new_vector[j] == 0 || new_vector[j] == 1) && new_vector[j] != r_vector[j])
            {
                return j;
            }
        }
    }

    return -1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3e394
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $-0x1, %eax
jne 0x3e33c
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x3e2fe
movq -0x10(%rbp), %rax
movl 0x1f4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1f4(%rax)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x3e33a
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x3e338
movq -0x10(%rbp), %rax
movl 0x1f8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1f8(%rax)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x3e33a
jmp 0x3e384
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3e35e
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x3e382
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x3e382
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3e39b
jmp 0x3e384
jmp 0x3e386
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3e2a5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: Preorder_Merge_Advance_Repeat(unsigned int, haplotype_evdience_alloc*, int)
void Preorder_Merge_Advance_Repeat(uint32_t snpID, haplotype_evdience_alloc* hap, int pathLen) 
{ 
    hap->dp.visit[snpID] = 1;
    hap->dp.buffer[pathLen] = snpID;
    pathLen++;

    if(hap->dp.backtrack_length[snpID] == 0)
    {
        insert_SNP_IDs_addition(&(hap->dp.SNP_IDs), hap->dp.buffer, pathLen);
        return;
    }
    else
    {
        uint32_t* column;
        int j;

        column = Get_DP_Backtrack_Column(hap->dp, snpID);
        for (j = 0; j < (int)hap->dp.backtrack_length[snpID]; j++)
        {
            Preorder_Merge_Advance_Repeat(column[j], hap, pathLen); 
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x258(%rax), %rax
movl -0x4(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x290(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x278(%rax), %rax
movl -0x4(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
jne 0x3ea5a
movq -0x10(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
addq $0x60, %rdi
movq -0x10(%rbp), %rax
movq 0x290(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0xa1520
jmp 0x3eac1
movq -0x10(%rbp), %rax
movq 0x280(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x250(%rcx), %ecx
imull -0x4(%rbp), %ecx
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x278(%rcx), %rcx
movl -0x4(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jge 0x3eabf
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3e9e0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3ea87
jmp 0x3eac1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: Preorder_Merge_Advance(unsigned int, haplotype_evdience_alloc*, int)
void Preorder_Merge_Advance(uint32_t snpID, haplotype_evdience_alloc* hap, int pathLen) 
{ 
    hap->dp.visit[snpID] = 1;
    hap->dp.buffer[pathLen] = snpID;
    pathLen++;

    if(hap->dp.backtrack_length[snpID] == 0)
    {
        generate_result_vector(hap, pathLen);
        return;
    }
    else
    {
        uint32_t* column;
        int j;

        column = Get_DP_Backtrack_Column(hap->dp, snpID);
        for (j = 0; j < (int)hap->dp.backtrack_length[snpID]; j++)
        {
            Preorder_Merge_Advance(column[j], hap, pathLen); 
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x258(%rax), %rax
movl -0x4(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x290(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x278(%rax), %rax
movl -0x4(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
jne 0x3ee54
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3ead0
jmp 0x3eebb
movq -0x10(%rbp), %rax
movq 0x280(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x250(%rcx), %ecx
imull -0x4(%rbp), %ecx
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x278(%rcx), %rcx
movl -0x4(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jge 0x3eeb9
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3edf0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3ee81
jmp 0x3eebb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: if_snp_vector_useful(haplotype_evdience_alloc*, long long, long long, unsigned int*, long long)
int if_snp_vector_useful(haplotype_evdience_alloc* hap,
long long occ_0, long long occ_1, uint32_t* SNPs, long long SNPsLen)
{

    double occ_1_coverage_low = (occ_0 + occ_1) * 0.3;
    
    if(occ_1 == 0 || occ_0 == 0)
    {
        return 0;
    }

    ///Fix-attention
    if(occ_1 >= occ_1_coverage_low && occ_0 >= occ_1_coverage_low)
    {
        return 1;
    }
    else if(occ_1 >= 5 && occ_0 >= 5)
    {
        return 1;
    }
    else if(occ_1 >= 3 && occ_0 >= 3 && SNPsLen >= 2)
    {
        int nearsnp;
        int non_nearsnps;
        count_nearby_snps(hap, SNPs, SNPsLen, &nearsnp, &non_nearsnps);
        if(non_nearsnps > 0)
        {
            return 1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x342a47(%rip), %xmm1   # 0x381948
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3ef18
cmpq $0x0, -0x18(%rbp)
jne 0x3ef24
movl $0x0, -0x4(%rbp)
jmp 0x3efaa
cvtsi2sdq -0x20(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
jb 0x3ef47
cvtsi2sdq -0x18(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
jb 0x3ef47
movl $0x1, -0x4(%rbp)
jmp 0x3efaa
cmpq $0x5, -0x20(%rbp)
jl 0x3ef5e
cmpq $0x5, -0x18(%rbp)
jl 0x3ef5e
movl $0x1, -0x4(%rbp)
jmp 0x3efaa
cmpq $0x3, -0x20(%rbp)
jl 0x3ef9f
cmpq $0x3, -0x18(%rbp)
jl 0x3ef9f
cmpq $0x2, -0x30(%rbp)
jl 0x3ef9f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rax
movl %eax, %edx
leaq -0x3c(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0xa18b0
cmpl $0x0, -0x40(%rbp)
jle 0x3ef9d
movl $0x1, -0x4(%rbp)
jmp 0x3efaa
jmp 0x3ef9f
jmp 0x3efa1
jmp 0x3efa3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: process_repeat_snps(haplotype_evdience_alloc*, overlap_region_alloc*)
void process_repeat_snps(haplotype_evdience_alloc* hap, overlap_region_alloc* overlap_list)
{
    int i;
    uint32_t* snp_ids;
    long long length;

    

    for (i = 0; i < hap->dp.SNP_IDs.IDs_length; i++)
    {
        snp_ids = hap->dp.SNP_IDs.buffer + hap->dp.SNP_IDs.IDs[i].beg;
        length = hap->dp.SNP_IDs.IDs[i].end -hap->dp.SNP_IDs.IDs[i].beg + 1;

        merge_SNP_Vectors(hap, snp_ids, length);

        if(if_snp_vector_useful(hap, hap->result_stat.occ_0, hap->result_stat.occ_1, 
        snp_ids, length))
        {
            try_to_remove_reads(Get_Result_SNP_Vector((*hap)), Get_SNP_Vector_Length((*hap)), 
            overlap_list, snp_ids, length, hap);

            hap->dp.SNP_IDs.IDs[i].is_remove = 1;
        }
        else
        {
            hap->dp.SNP_IDs.IDs[i].is_remove = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2b8(%rcx), %rax
jge 0x3f64b
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2c8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
movl (%rcx), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x2c8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x2c8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
subl (%rcx), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3efc0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1f4(%rax), %eax
movl %eax, %esi
movq -0x8(%rbp), %rax
movl 0x1f8(%rax), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x3eed0
cmpl $0x0, %eax
je 0x3f61e
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x1c8(%rax), %eax
movl %eax, %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x8(%rbp), %r9
callq 0x3f330
movq -0x8(%rbp), %rax
movq 0x2c8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x18(%rax)
jmp 0x3f63b
movq -0x8(%rbp), %rax
movq 0x2c8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x18(%rax)
jmp 0x3f63d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f517
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: debug_print_snp_stat(char*, haplotype_evdience_alloc*, overlap_region_alloc*, All_reads*)
int debug_print_snp_stat(char* name, haplotype_evdience_alloc* hap, overlap_region_alloc* overlap_list, All_reads* R_INF)
{
    if(overlap_list->length > 0 &&
       memcmp(name, Get_NAME((*R_INF), overlap_list->list[0].x_id), 
       Get_NAME_LENGTH((*R_INF), overlap_list->list[0].x_id)) == 0)
    {
        fprintf(stderr, "\n%s, available_snp: %d\n", name, (int)hap->snp_stat.n);
        int i;
        for (i = 0; i < (int)hap->snp_stat.n; i++)
        {
            fprintf(stderr, "site: %d, occ_0: %d, occ_1: %d, occ_2: %d\n", 
            hap->snp_stat.a[i].site, hap->snp_stat.a[i].occ_0,
            hap->snp_stat.a[i].occ_1, hap->snp_stat.a[i].occ_2);
        }
    }

    return 1;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x3fc09
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
addq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
subq (%rax,%rcx,8), %rdx
callq 0x20b0
cmpl $0x0, %eax
jne 0x3fc09
movq 0x3844a4(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movl %eax, %ecx
leaq 0x342c78(%rip), %rsi    # 0x3827cf
movb $0x0, %al
callq 0x22a0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x220(%rcx), %rcx
cmpl %ecx, %eax
jge 0x3fc07
movq 0x38445e(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x218(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x218(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x218(%rax), %rax
movslq -0x24(%rbp), %rsi
imulq $0x28, %rsi, %rsi
addq %rsi, %rax
movl 0xc(%rax), %r8d
movq -0x10(%rbp), %rax
movq 0x218(%rax), %rax
movslq -0x24(%rbp), %rsi
imulq $0x28, %rsi, %rsi
addq %rsi, %rax
movl 0x10(%rax), %r9d
leaq 0x342bf5(%rip), %rsi    # 0x3827e7
movb $0x0, %al
callq 0x22a0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3fb65
jmp 0x3fc09
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: prt_sub_read(char*, unsigned long, unsigned long, unsigned long)
void prt_sub_read(char *str, uint64_t str_l, uint64_t site, uint64_t win)
{
    uint64_t k, s, e;
    s = ((site >= win)?(site-win):(0)); 
    e = (((site+win+1) <= str_l)?(site+win+1):(str_l));
    fprintf(stderr, "[M::%s-site::%lu] [%lu, %lu)\n", __func__, site, s, e);

    for (k = s; k < site; k++) fprintf(stderr, "%c", str[k]);
    fprintf(stderr, "[%c]", str[k++]);
    for (; k < e; k++) fprintf(stderr, "%c", str[k]);

    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x41a10
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x41a18
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x41a18
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x10(%rbp), %rax
ja 0x41a44
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x41a4c
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x382585(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
leaq 0x340e12(%rip), %rsi    # 0x382883
leaq 0x340e29(%rip), %rdx    # 0x3828a1
movb $0x0, %al
callq 0x22a0
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x41ac3
movq 0x382548(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0x34d51b(%rip), %rsi    # 0x38efc9
movb $0x0, %al
callq 0x22a0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x41a87
movq 0x382516(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movsbl (%rax,%rcx), %edx
leaq 0x340dc3(%rip), %rsi    # 0x3828ae
movb $0x0, %al
callq 0x22a0
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x41b2e
movq 0x3824dd(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0x34d4b0(%rip), %rsi    # 0x38efc9
movb $0x0, %al
callq 0x22a0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x41af2
movq 0x3824ab(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x344ee9(%rip), %rsi    # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: dbg_prt_rphase_vec(SnpStats*, unsigned long, haplotype_evdience*)
void dbg_prt_rphase_vec(SnpStats *ai, uint64_t id, haplotype_evdience *za)
{
    haplotype_evdience *iz = NULL; int64_t in, ik; uint8_t fi;
    iz = za + ai->non_homopolymer_num; in = ai->homopolymer_num - ai->non_homopolymer_num;

    for (ik = 0; ik < in; ik++) {
        fi = 2;
        if(hh_tp(iz[ik]) == 0) {
            fi = 0;
        } else if(iz[ik].overlapSite == id){
            fi = 1;
        }
        fprintf(stderr, "oid::%u(f::%u)\n", iz[ik].overlapID, fi);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x4463e
movb $0x2, -0x31(%rbp)
movq -0x20(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movzbl 0xc(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x445ea
movb $0x0, -0x31(%rbp)
jmp 0x44605
movq -0x20(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpq -0x10(%rbp), %rax
jne 0x44603
movb $0x1, -0x31(%rbp)
jmp 0x44605
movq 0x37f9d4(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movzbl -0x31(%rbp), %ecx
leaq 0x33e443(%rip), %rsi    # 0x382a6c
movb $0x0, %al
callq 0x22a0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x445be
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: is_hpc_vec(SnpStats*, unsigned long, haplotype_evdience*)
int64_t is_hpc_vec(SnpStats *ai, uint64_t id, haplotype_evdience *za)
{
    haplotype_evdience *iz = NULL; int64_t in, ik, n0 = ai->occ_0, n1 = ai->occ_1, f = 0; 
    iz = za + ai->non_homopolymer_num; in = ai->homopolymer_num - ai->non_homopolymer_num;

    for (ik = 0; ik < in; ik++) {
        if(!hh_hp(iz[ik])) continue;
        if(hh_tp(iz[ik]) == 0) {
            ai->occ_0 -= iz[ik].cov;
        } else if(iz[ik].overlapSite == id){
            ai->occ_1 -= iz[ik].cov;
        }
    }
    if((ai->occ_0 < 2 || ai->occ_1 < 2) || (!(ai->occ_0 >= asm_opt.s_hap_cov && ai->occ_1 >= asm_opt.infor_cov))) f = 1;
    ai->occ_0 = n0; ai->occ_1 = n1;
    // if((sec_check) && (((n0)<=((n0+n1)*0.333333)) || ((n1)<=((n0+n1)*0.333333)))) f = 1;
    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x44d5c
movq -0x20(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movzbl 0xc(%rax), %eax
sarl %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x44ce2
jmp 0x44d4b
movq -0x20(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movzbl 0xc(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x44d17
movq -0x20(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
jmp 0x44d49
movq -0x20(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpq -0x10(%rbp), %rax
jne 0x44d47
movq -0x20(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rax)
jmp 0x44d49
jmp 0x44d4b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x44cb8
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jb 0x44d9e
movq -0x8(%rbp), %rax
cmpl $0x2, 0xc(%rax)
jb 0x44d9e
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
leaq 0x37fa7a(%rip), %rcx    # 0x3c47f8
cmpq 0x218(%rcx), %rax
jl 0x44d9e
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
leaq 0x37fa63(%rip), %rcx    # 0x3c47f8
cmpq 0x210(%rcx), %rax
jge 0x44da6
movq $0x1, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x48(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: get_hq_value(SnpStats*, unsigned long, haplotype_evdience*, long*, long*, long*, long*, unsigned char*)
void get_hq_value(SnpStats *ai, uint64_t id, haplotype_evdience *za, int64_t *lq0, int64_t *hq0, int64_t *lq1, int64_t *hq1, uint8_t *ref_a)
{
    haplotype_evdience *z; int64_t n, k, occ0[2], occ1[2]; uint8_t fi;
    z = za + ai->non_homopolymer_num; n = ai->homopolymer_num - ai->non_homopolymer_num;
    occ0[0] = occ0[1] = occ1[0] = occ1[1] = 0;
    for (k = 0; k < n; k++) {
        if((hh_tp(z[k]) == 1) && (z[k].overlapSite != id)) continue;
        fi = 0;
        if((hh_bq(z[k]) > 1)) fi = 1;

        if(hh_tp(z[k]) == 0) occ0[fi]++;
        else occ1[fi]++;
    }
    if(ref_a) {
        if(ref_a[ai->site] > 1) occ0[1]++;
        else occ0[0]++;
    }
    (*lq0) = occ0[0]; (*hq0) = occ0[1]; 
    (*lq1) = occ1[0]; (*hq1) = occ1[1]; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x44f0b
movq -0x38(%rbp), %rax
imulq $0x18, -0x48(%rbp), %rcx
addq %rcx, %rax
movzbl 0xc(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x44e93
movq -0x38(%rbp), %rax
imulq $0x18, -0x48(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpq -0x10(%rbp), %rax
je 0x44e93
jmp 0x44efa
movb $0x0, -0x71(%rbp)
movq -0x38(%rbp), %rax
imulq $0x18, -0x48(%rbp), %rcx
addq %rcx, %rax
movzbl 0xc(%rax), %eax
sarl $0x2, %eax
cltq
andq $0x3, %rax
cmpq $0x1, %rax
jbe 0x44eba
movb $0x1, -0x71(%rbp)
movq -0x38(%rbp), %rax
imulq $0x18, -0x48(%rbp), %rcx
addq %rcx, %rax
movzbl 0xc(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x44ee6
movzbl -0x71(%rbp), %eax
movq -0x60(%rbp,%rax,8), %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp,%rax,8)
jmp 0x44ef8
movzbl -0x71(%rbp), %eax
movq -0x70(%rbp,%rax,8), %rcx
addq $0x1, %rcx
movq %rcx, -0x70(%rbp,%rax,8)
jmp 0x44efa
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x44e56
cmpq $0x0, 0x18(%rbp)
je 0x44f42
movq 0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jle 0x44f34
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x44f40
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x44f42
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: debug_phasing_snp_site_status(haplotype_evdience_alloc*, haplotype_evdience*, unsigned long, overlap_region_alloc*)
void debug_phasing_snp_site_status(haplotype_evdience_alloc* h, haplotype_evdience* a, uint64_t a_n, overlap_region_alloc* olist)
{
    uint64_t i;
    for (i = 0; i < a_n; i++) {
        if(a[i].site == 76046) {
            fprintf(stderr, "[M::utg%.6dl::]x_site->%u, y_site->%u, type->%u, cov->%u, misBase->%c\n", 
            (int)olist->list[a[i].overlapID].y_id+1, a[i].site, 
            a[i].overlapSite, a[i].type, a[i].cov, a[i].misBase);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x4b52e
movq -0x10(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
cmpl $0x1290e, (%rax)        # imm = 0x1290E
jne 0x4b51b
movq 0x378b53(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rcx
movl 0x4(%rcx), %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %edx
addl $0x1, %edx
movq -0x10(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rsi
addq %rsi, %rax
movl 0x8(%rax), %r8d
movq -0x10(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rsi
addq %rsi, %rax
movzbl 0xc(%rax), %r9d
movq -0x10(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rsi
addq %rsi, %rax
movl 0x10(%rax), %r10d
movq -0x10(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rsi
addq %rsi, %rax
movsbl 0x14(%rax), %eax
leaq 0x33782f(%rip), %rsi    # 0x382d3b
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x22a0
jmp 0x4b51d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4b460
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: ovlp_occ(overlap_region_alloc*, unsigned char)
uint64_t ovlp_occ(overlap_region_alloc* overlap_list, uint8_t is_match)
{
    uint64_t occ = 0, k;
    for (k = 0; k < overlap_list->length; k++) {
        if(overlap_list->list[k].is_match == is_match) occ++;
    }
    return occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4c226
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x20(%rbp), %rcx
addq %rcx, %rax
movzbl 0x2c(%rax), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4c216
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4c218
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4c1de
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: clear_Correct_dumy(Correct_dumy*, overlap_region_alloc*, void*)
void clear_Correct_dumy(Correct_dumy* list, overlap_region_alloc* overlap_list, void *km)
{
    list->length = 0;
    list->lengthNT = 0;
    list->start_i = 0;

    if (list->size < overlap_list->length){
        list->size = overlap_list->length;
        if(!km) REALLOC(list->overlapID, list->size);
        else KREALLOC(km, list->overlapID, list->size);
    }

    list->last_boundary_length = 0;
    list->corrected_read_length = 0;
    list->corrected_base = 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4c511
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x4c4e7
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x4c50f
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
shlq $0x3, %rdx
callq 0x30e740
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x4c511
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: print_ovlp_occ_stat(overlap_region_alloc*, unsigned int, unsigned char)
void print_ovlp_occ_stat(overlap_region_alloc* overlap_list, uint32_t xlen, uint8_t is_match)
{
    uint64_t k;
    for (k = 0; k < overlap_list->length; k++) {
        if(overlap_list->list[k].is_match != is_match) continue;
        fprintf(stderr, "[M::%s::xlen::%u] utg%.6dl(%c), is_match::%u, x::[%u, %u)\n", __func__, xlen,
            (int32_t)overlap_list->list[k].y_id + 1, 
            "+-"[overlap_list->list[k].y_pos_strand], overlap_list->list[k].is_match,
            overlap_list->list[k].x_pos_s, overlap_list->list[k].x_pos_e+1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4c653
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rcx
addq %rcx, %rax
movzbl 0x2c(%rax), %eax
movzbl -0xd(%rbp), %ecx
cmpl %ecx, %eax
je 0x4c591
jmp 0x4c642
movq 0x377a48(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rdx
addq %rdx, %rax
movl 0x10(%rax), %r8d
addl $0x1, %r8d
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rdx
addq %rdx, %rax
movl 0x1c(%rax), %eax
movl %eax, %edx
leaq 0x3368c5(%rip), %rax    # 0x382e9b
movsbl (%rax,%rdx), %r9d
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rdx
addq %rdx, %rax
movzbl 0x2c(%rax), %r11d
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rdx
addq %rdx, %rax
movl 0x4(%rax), %r10d
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rdx
addq %rdx, %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
leaq 0x336825(%rip), %rsi    # 0x382e4c
leaq 0x336859(%rip), %rdx    # 0x382e87
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4c55c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: resize_Cigar_record_alloc(Cigar_record_alloc*, long long)
void resize_Cigar_record_alloc(Cigar_record_alloc* x, long long new_size)
{
    long long i;
    if(new_size > x->size)
    {
        x->buffer = (Cigar_record*)realloc(x->buffer, new_size*sizeof(Cigar_record));
        for (i = 0; i < x->size; i++)
        {
            clear_Cigar_record(&(x->buffer[i]));
        }
        for (; i < new_size; i++)
        {
            init_Cigar_record(&(x->buffer[i]));
            clear_Cigar_record(&(x->buffer[i]));
        }

        x->size = new_size;
    }
    else
    {
        for (i = 0; i < new_size; i++)
        {
            clear_Cigar_record(&(x->buffer[i]));
        }
    }

    x->length = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x4ca86
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
shlq $0x6, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x4ca2e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x31d60
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4c9fa
jmp 0x4ca30
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4ca78
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x31ec0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x31d60
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4ca30
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4cac0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4cabe
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x31d60
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4ca8e
jmp 0x4cac0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: destory_Cigar_record_alloc(Cigar_record_alloc*)
void destory_Cigar_record_alloc(Cigar_record_alloc* x)
{
    long long i;
    for (i = 0; i < x->size; i++)
    {
        destory_Cigar_record(&(x->buffer[i]));
    }
    free(x->buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x4cb28
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x320c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4caf4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: add_new_cell_to_cigar_record(Cigar_record*, unsigned int, unsigned int)
void add_new_cell_to_cigar_record(Cigar_record* dummy, uint32_t len, uint32_t type)
{
    uint32_t tmp;
    tmp = len;
    tmp = tmp << 2;
    tmp = tmp | type;

    dummy->length++;


    if(dummy->length > dummy->size)
    {
        dummy->size = dummy->size * 2;
        dummy->record = (uint32_t*)realloc(dummy->record, dummy->size*sizeof(uint32_t));
    }

    dummy->record[dummy->length - 1] = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x4cbc3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x2, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: add_existing_cell_to_cigar_record(Cigar_record*, unsigned int, unsigned int)
void add_existing_cell_to_cigar_record(Cigar_record* dummy, uint32_t len, uint32_t type)
{
    uint32_t tmp;

    tmp = dummy->record[dummy->length - 1] >> 2;
    tmp = tmp + len;
    tmp = tmp << 2;
    tmp = tmp | type;
    dummy->record[dummy->length - 1] = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
shrl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: add_new_cell_to_cigar_record_with_different_base(Cigar_record*, unsigned int, unsigned int, char*)
void add_new_cell_to_cigar_record_with_different_base(Cigar_record* dummy, uint32_t len, uint32_t type, char* seq)
{
    uint32_t tmp;
    tmp = len;
    tmp = tmp << 2;
    tmp = tmp | type;
   

    dummy->length++;

    if(dummy->length > dummy->size)
    {
        dummy->size = dummy->size * 2;
        dummy->record = (uint32_t*)realloc(dummy->record, dummy->size*sizeof(uint32_t));
    }

    dummy->record[dummy->length - 1] = tmp;

    

    if (dummy->lost_base_length + len> dummy->lost_base_size)
    {
        dummy->lost_base_size = (dummy->lost_base_length + len) * 2;
        dummy->lost_base = (char*)realloc(dummy->lost_base, dummy->lost_base_size*sizeof(char));
    }

    uint32_t i = 0;
    for (i = 0; i < len; i++, dummy->lost_base_length++)
    {
        dummy->lost_base[dummy->lost_base_length] = seq[i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x4cce7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x2, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x4cd56
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movl -0xc(%rbp), %eax
addq %rax, %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
shlq $0x0, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x4cda4
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
jmp 0x4cd64
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: add_existing_cell_to_cigar_record_with_different_base(Cigar_record*, unsigned int, unsigned int, char*)
void add_existing_cell_to_cigar_record_with_different_base(Cigar_record* dummy, uint32_t len, uint32_t type, char* seq)
{
    uint32_t tmp;

    tmp = dummy->record[dummy->length - 1] >> 2;
    tmp = tmp + len;
    tmp = tmp << 2;
    tmp = tmp | type;
    dummy->record[dummy->length - 1] = tmp;

    if (dummy->lost_base_length + len> dummy->lost_base_size)
    {
        dummy->lost_base_size = (dummy->lost_base_length + len) * 2;
        dummy->lost_base = (char*)realloc(dummy->lost_base, dummy->lost_base_size*sizeof(char));
    }

    uint32_t i = 0;
    for (i = 0; i < len; i++, dummy->lost_base_length++)
    {
        dummy->lost_base[dummy->lost_base_length] = seq[i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
shrl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x4ce6d
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movl -0xc(%rbp), %eax
addq %rax, %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
shlq $0x0, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x4cebb
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
jmp 0x4ce7b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)