LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: cmp_hap_alignment_chaining(void const*, void const*)
int cmp_hap_alignment_chaining(const void * a, const void * b)
{
    if((*(asg_arc_t_offset*)a).x.el > (*(asg_arc_t_offset*)b).x.el) return 1;
    if((*(asg_arc_t_offset*)a).x.el < (*(asg_arc_t_offset*)b).x.el) return -1;

    if(((*(asg_arc_t_offset*)a).Off>>32) > ((*(asg_arc_t_offset*)b).Off>>32)) return 1;
    if(((*(asg_arc_t_offset*)a).Off>>32) < ((*(asg_arc_t_offset*)b).Off>>32)) return -1;

    if((uint32_t)((*(asg_arc_t_offset*)a).Off) > (uint32_t)((*(asg_arc_t_offset*)b).Off)) return 1;
    if((uint32_t)((*(asg_arc_t_offset*)a).Off) < (uint32_t)((*(asg_arc_t_offset*)b).Off)) return -1;

    return 0;
}

// Assembly:
movb 0x12(%rsi), %al
cmpb %al, 0x12(%rdi)
jbe 0x105ee3
movl $0x1, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jae 0x105eeb
retq
movq 0x18(%rdi), %rcx
movq %rcx, %rdi
shrq $0x20, %rdi
movq 0x18(%rsi), %rdx
movq %rdx, %rsi
shrq $0x20, %rsi
cmpq %rsi, %rdi
ja 0x105edd
cmpl %esi, %edi
jb 0x105eea
movl $0x1, %eax
cmpl %edx, %ecx
ja 0x105eea
xorl %eax, %eax
cmpl %edx, %ecx
sbbl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: cmp_hap_candidates(void const*, void const*)
int cmp_hap_candidates(const void * a, const void * b)
{
    if((*(hap_candidates*)a).weight < (*(hap_candidates*)b).weight) return 1;
    if((*(hap_candidates*)a).weight > (*(hap_candidates*)b).weight) return -1;

    if((*(hap_candidates*)a).index_beg > (*(hap_candidates*)b).index_beg) return 1;
    if((*(hap_candidates*)a).index_beg < (*(hap_candidates*)b).index_beg) return -1;
    
    return 0;
}

// Assembly:
movq (%rsi), %rcx
movl $0x1, %eax
cmpq %rcx, (%rdi)
jb 0x105f43
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ja 0x105f43
movl 0x18(%rdi), %ecx
movl 0x18(%rsi), %edx
movl $0x1, %eax
cmpl %edx, %ecx
ja 0x105f43
xorl %eax, %eax
cmpl %edx, %ecx
sbbl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: classify_hap_overlap(long long, long long, long long, long long, long long, long long, long long*, long long*, long long*, long long*)
uint32_t classify_hap_overlap(long long xBeg, long long xEnd, long long xLen,
long long yBeg, long long yEnd, long long yLen, long long* r_xBeg, long long* r_xEnd, 
long long* r_yBeg, long long* r_yEnd)
{
    long long n_x_beg, n_x_end, n_y_beg, n_y_end;
    get_hap_overlapLen(xBeg, xEnd, xLen, yBeg, yEnd, yLen, &n_x_beg, &n_x_end, &n_y_beg, &n_y_end);
    if(r_xBeg) (*r_xBeg) = n_x_beg;
    if(r_xEnd) (*r_xEnd) = n_x_end;
    if(r_yBeg) (*r_yBeg) = n_y_beg;
    if(r_yEnd) (*r_yEnd) = n_y_end;
    if(n_x_beg == 0 && n_x_end == xLen - 1) return YCX;
    if(n_y_beg == 0 && n_y_end == yLen - 1) return XCY;
    if(n_y_beg == 0 && n_x_end == xLen - 1) return X2Y;
    if(n_x_beg == 0 && n_y_end == yLen - 1) return Y2X;
    return XCY;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
movq %rdi, %r11
subq %rcx, %r11
movl $0x0, %r10d
cmovgq %r11, %r10
negq %r11
cmpq %rcx, %rdi
movq 0x10(%rsp), %rax
cmovgq %rbx, %r11
movq %rsi, %rdi
notq %rdi
addq %rdx, %rdi
leaq (%rdi,%r8), %rcx
notq %r8
addq %r9, %r8
decq %rdx
addq %r8, %rsi
decq %r9
cmpq %r8, %rdi
cmovgq %r9, %rcx
movq 0x18(%rsp), %rdi
cmovleq %rdx, %rsi
testq %rax, %rax
je 0x105f9a
movq %r10, (%rax)
movq 0x20(%rsp), %rax
testq %rdi, %rdi
je 0x105fa7
movq %rsi, (%rdi)
movq 0x28(%rsp), %rdi
testq %rax, %rax
je 0x105fb4
movq %r11, (%rax)
testq %rdi, %rdi
je 0x105fbc
movq %rcx, (%rdi)
xorq %rdx, %rsi
movl $0x3, %eax
movq %r10, %rdx
orq %rsi, %rdx
je 0x105fed
xorq %r9, %rcx
movl $0x2, %eax
movq %r11, %rdx
orq %rcx, %rdx
je 0x105fed
xorl %eax, %eax
orq %rsi, %r11
je 0x105fed
xorl %eax, %eax
orq %rcx, %r10
setne %al
incl %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: get_pair_hap_coverage(unsigned long*, unsigned int, ma_hit_t_alloc*, ma_sub_t*)
uint64_t get_pair_hap_coverage(uint64_t* readIDs, uint32_t Len, ma_hit_t_alloc* sources, ma_sub_t* coverage_cut)
{
    uint32_t m, n, qn;
    ma_hit_t *h;
    uint64_t R_bases = 0, C_bases = 0;

    for (m = 0; m < Len; m++)
    {
        qn = readIDs[m]>>33;
        R_bases += coverage_cut[qn].e - coverage_cut[qn].s;
        for (n = 0; n < (uint64_t)(sources[qn].length); n++)
        {
            h = &(sources[qn].buffer[n]);
            C_bases += Get_qe((*h)) - Get_qs((*h));
        }
    }

    return C_bases/R_bases;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %esi
xorl %r9d, %r9d
movl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
xorl %eax, %eax
xorl %r8d, %r8d
movq (%rdi,%r9,8), %r11
shrq $0x21, %r11
leaq (%r11,%r11,2), %r11
movl 0xc(%rdx,%r11,8), %r14d
testq %r14, %r14
je 0x106043
leaq (%rdx,%r11,8), %rbx
movq (%rbx), %rbx
shlq $0x3, %r14
leaq (%r14,%r14,4), %r14
xorl %r15d, %r15d
movl 0x8(%rbx,%r15), %r12d
subl (%rbx,%r15), %r12d
addq %r12, %rax
addq $0x28, %r15
cmpq %r15, %r14
jne 0x10602e
movl 0x4(%rcx,%r11,4), %ebx
movl (%rcx,%r11,4), %r11d
andl %r10d, %r11d
subl %r11d, %ebx
addq %rbx, %r8
incq %r9
cmpq %rsi, %r9
jne 0x106006
xorl %edx, %edx
divq %r8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: vote_overlap_type(kvec_asg_arc_t_offset*, hap_candidates*, unsigned long*, ma_utg_t*, ma_utg_t*)
uint32_t vote_overlap_type(kvec_asg_arc_t_offset* u_buffer, hap_candidates* hap_can, 
uint64_t* position_index, ma_utg_t* xReads, ma_utg_t* yReads)
{
    uint32_t i, xBasePos, yBasePos;
    asg_arc_t_offset* arch = NULL;
    uint32_t flag[4];
    flag[X2Y] = flag[Y2X] = flag[XCY] = flag[YCX] = 0;


    for (i = hap_can->index_beg; i <= hap_can->index_end; i++)
    {
        arch = &(u_buffer->a.a[i]);
        xBasePos = (uint32_t)(arch->Off>>32);
        yBasePos = (uint32_t)(arch->Off);
        flag[classify_hap_overlap(xBasePos, xBasePos, xReads->len, yBasePos, yBasePos, yReads->len,
        NULL, NULL, NULL, NULL)]++;
    }
    
    uint32_t max_flag_i = 0;
    for (i = 0; i < 4; i++)
    {
        if(i == max_flag_i) continue;
        if(flag[i] > flag[max_flag_i])
        {
            max_flag_i = i;
        }
    }
    
    return max_flag_i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x18(%rsi), %ebp
movl 0x1c(%rsi), %r15d
cmpl %r15d, %ebp
ja 0x1076fe
movq 0x10(%rdi), %r12
movl (%rcx), %ebx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rbx
movl (%r8), %r14d
andq %rax, %r14
movl %ebp, %eax
leaq (%rax,%rax,4), %rax
movq 0x18(%r12,%rax,8), %rdi
movl %edi, %ecx
shrq $0x20, %rdi
movups %xmm0, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rdi, %rsi
movq %rbx, %rdx
movq %rcx, %r8
movq %r14, %r9
callq 0x105f44
xorps %xmm0, %xmm0
movl %eax, %eax
incl 0x20(%rsp,%rax,4)
incl %ebp
cmpl %r15d, %ebp
jbe 0x1076c3
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
cmpq %rdx, %rcx
je 0x107719
movl 0x20(%rsp,%rcx,4), %edi
movl %ecx, %esi
cmpl 0x20(%rsp,%rdx,4), %edi
ja 0x107717
movl %eax, %esi
movl %esi, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x107702
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: get_xy_pos_by_pos(asg_t*, asg_arc_t*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned char*)
uint64_t get_xy_pos_by_pos(asg_t *read_g, asg_arc_t* t, uint32_t v_in_unitig, uint32_t w_in_unitig, 
uint32_t v_in_pos, uint32_t w_in_pos, uint32_t xUnitigLen, uint32_t yUnitigLen, uint8_t* rev)
{
    uint32_t x_pos, y_pos, x_dir = 0, y_dir = 0;
    uint64_t tmp;
    x_pos = y_pos = (uint32_t)-1;
    if((t->ul>>32)==v_in_unitig)///end pos
    {
        x_pos = v_in_pos + read_g->seq[v_in_unitig>>1].len - 1;
        x_dir = 0;
    }
    else if((t->ul>>32)==(v_in_unitig^1))///start pos
    {
        x_pos = v_in_pos;
        x_dir = 1;
    }
    else
    {
        fprintf(stderr, "ERROR\n");
    }
    
    if(t->v == w_in_unitig)
    {
        y_pos = w_in_pos + t->ol - 1;
        y_dir = 0;
    }
    else if(t->v == (w_in_unitig^1))
    {
        y_pos = w_in_pos + read_g->seq[w_in_unitig>>1].len - t->ol;
        y_dir = 1;
    }
    else
    {
        fprintf(stderr, "ERROR\n");
    }

    (*rev) = x_dir^y_dir;
    if((*rev))
    {
        if(yUnitigLen <= y_pos)
        {
            y_pos = (uint32_t)-1;
        }
        else
        {
            y_pos = yUnitigLen - y_pos - 1;
        }
    } 

    if(x_pos>=xUnitigLen) x_pos = (uint32_t)-1;
    if(y_pos>=yUnitigLen) y_pos = (uint32_t)-1;
    
    tmp = x_pos; tmp = tmp << 32; tmp = tmp | y_pos;
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %ebx
movl %ecx, %r12d
movq %rsi, %r15
movq %rdi, %r13
movq (%rsi), %rax
shrq $0x20, %rax
movl %edx, %ecx
cmpq %rcx, %rax
jne 0x108355
movq 0x20(%r13), %rax
shrl %edx
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
andl (%rax,%rdx,8), %ecx
addl %ecx, %ebx
decl %ebx
xorl %ebp, %ebp
jmp 0x108363
xorl $0x1, %edx
movb $0x1, %bpl
cmpl %edx, %eax
jne 0x1083f2
movq 0x50(%rsp), %r8
movl 0x8(%r15), %eax
cmpl %r12d, %eax
jne 0x108383
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl 0xc(%r15), %eax
addl %r14d, %eax
decl %eax
xorl %esi, %esi
jmp 0x1083a9
xorl %r12d, %eax
cmpl $0x1, %eax
jne 0x108401
movq 0x20(%r13), %rax
shrl %r12d
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl (%rax,%r12,8), %eax
andl %ecx, %eax
addl %r14d, %eax
andl 0xc(%r15), %ecx
subl %ecx, %eax
movb $0x1, %sil
movl 0x48(%rsp), %ecx
movl 0x40(%rsp), %edx
movl %esi, %edi
xorb %bpl, %dil
movb %dil, (%r8)
cmpb %sil, %bpl
je 0x1083cb
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jae 0x1083cd
notl %eax
addl %ecx, %eax
movl %eax, %esi
cmpl %edx, %ebx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %eax, %ebx
cmpl %ecx, %esi
cmovbl %esi, %eax
shlq $0x20, %rbx
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1391b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x108351
movq %r8, %r14
callq 0x13937
movq %r14, %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x10837f
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: get_idx_by_base(ma_utg_t*, asg_t*, long long, long long, long long*, long long*)
void get_idx_by_base(ma_utg_t *x, asg_t *read_g, long long beg_base, long long end_base, 
                                            long long* beg_idx, long long* end_idx)
{
    long long offset, r_beg, r_end;
    uint64_t i, rId;
    (*beg_idx) = (*end_idx) = -1;
    for (i = 0, offset = 0; i < x->n; i++)
    {
        rId = x->a[i]>>33;
        r_beg = offset; r_end = offset + (long long)(read_g->seq[rId].len) - 1;
        offset += (uint32_t)x->a[i];
        if(beg_base > r_end || r_beg > end_base)
        {
            if((*beg_idx) != -1 && (*end_idx) != -1) break;
            continue;
        } 
        if((*beg_idx) == -1) (*beg_idx) = i;
        (*end_idx) = i;
    }
}

// Assembly:
movq $-0x1, %rax
movq %rax, (%r9)
movq %rax, (%r8)
movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x1096b4
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rdi
movq 0x20(%rsi), %rsi
xorl %ebx, %ebx
xorl %r10d, %r10d
movq (%rdi,%r10,8), %r15
movl %r15d, %r11d
addq %rbx, %r11
movq (%r8), %r14
cmpq %rcx, %rbx
jg 0x109698
shrq $0x21, %r15
movl (%rsi,%r15,8), %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
addq %r15, %rbx
cmpq %rdx, %rbx
jle 0x109698
cmpq $-0x1, %r14
jne 0x109693
movq %r10, (%r8)
movq %r10, (%r9)
jmp 0x1096a4
cmpq $-0x1, %r14
je 0x1096a4
cmpq $-0x1, (%r9)
jne 0x1096af
incq %r10
movq %r11, %rbx
cmpq %rax, %r10
jb 0x109661
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: adjust_hap_overlaps_score(ma_utg_t*, float*, long long*, long long, long long, long long, long long)
void adjust_hap_overlaps_score(ma_utg_t* xReads, float *sim, long long *score, 
long long xUid, long long yUid, long long xBeg, long long xEnd)
{
    uint64_t all, found;
    if(count_unique_k_mers(xReads->s + xBeg, xEnd+1-xBeg, xUid, yUid, &all, &found))
    {
        double k_w = 1;
        if(sim) (*sim) = MAX((*sim), (all == 0?0:(((double)found)/((double)all))));
        if(all) k_w += ((double)(found)/(double)(all));
        if(score) (*score) = ((*score)*k_w)/2;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x30(%rsp), %rsi
movq 0x20(%rdi), %rdi
addq %r9, %rdi
subq %r9, %rsi
incq %rsi
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rcx, %rdx
movq %rax, %rcx
callq 0x15db71
testq %rax, %rax
je 0x10ae73
testq %r14, %r14
je 0x10adf0
movss (%r14), %xmm0
movq 0x10(%rsp), %rax
movsd 0x11a4be(%rip), %xmm2   # 0x225240
movsd 0x8(%rsp), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movapd 0x11a4bd(%rip), %xmm4   # 0x225250
subpd %xmm4, %xmm3
movapd %xmm3, %xmm1
unpckhpd %xmm3, %xmm1            # xmm1 = xmm1[1],xmm3[1]
addsd %xmm3, %xmm1
movq %rax, %xmm3
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
subpd %xmm4, %xmm3
movapd %xmm3, %xmm2
unpckhpd %xmm3, %xmm2            # xmm2 = xmm2[1],xmm3[1]
addsd %xmm3, %xmm2
divsd %xmm2, %xmm1
xorpd %xmm2, %xmm2
testq %rax, %rax
je 0x10adcd
movapd %xmm1, %xmm2
xorps %xmm4, %xmm4
cvtss2sd %xmm0, %xmm4
xorpd %xmm3, %xmm3
je 0x10ade1
xorps %xmm3, %xmm3
cvtsd2ss %xmm1, %xmm3
ucomisd %xmm2, %xmm4
jae 0x10adeb
movapd %xmm3, %xmm0
movss %xmm0, (%r14)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x10ae4a
movsd 0x8(%rsp), %xmm1
movsd 0x11a438(%rip), %xmm2   # 0x225240
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x11a43d(%rip), %xmm3   # 0x225250
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
addsd 0x11a428(%rip), %xmm0   # 0x225270
jmp 0x10ae52
movsd 0x11a41e(%rip), %xmm0   # 0x225270
testq %rbx, %rbx
je 0x10ae73
xorps %xmm1, %xmm1
cvtsi2sdq (%rbx), %xmm1
mulsd %xmm1, %xmm0
mulsd 0x11a685(%rip), %xmm0   # 0x2254f0
cvttsd2si %xmm0, %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: get_specific_hap_overlap(kvec_hap_overlaps*, unsigned int, unsigned int)
int get_specific_hap_overlap(kvec_hap_overlaps* x, uint32_t qn, uint32_t tn)
{
    uint32_t i;
    for (i = 0; i < x->a.n; i++)
    {
        if(x->a.a[i].xUid == qn && x->a.a[i].yUid == tn)
        {
            return i;
        }        
    }

    return -1;
}

// Assembly:
movq (%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x10c0ef
movq 0x10(%rdi), %rdi
xorl %r9d, %r9d
xorl %r8d, %r8d
shlq $0x6, %r9
cmpl %esi, 0x24(%rdi,%r9)
jne 0x10c0e4
addq %rdi, %r9
cmpl %edx, 0x28(%r9)
je 0x10c0f0
incl %r8d
movq %r8, %r9
cmpq %r8, %rcx
ja 0x10c0d0
retq
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: set_reverse_hap_overlap(hap_overlaps*, hap_overlaps*, unsigned int*)
void set_reverse_hap_overlap(hap_overlaps* dest, hap_overlaps* source, uint32_t* types)
{
    dest->status = REVE_EXIST;
    dest->rev = source->rev;
    dest->type = types[source->type];
    dest->weight = source->weight;
    dest->xUid = source->yUid;
    dest->yUid = source->xUid;
    dest->x_beg_pos = source->y_beg_pos;
    dest->x_end_pos = source->y_end_pos;
    dest->y_beg_pos = source->x_beg_pos;
    dest->y_end_pos = source->x_end_pos;
    dest->x_beg_id = source->y_beg_id;
    dest->x_end_id = source->y_end_id;
    dest->y_beg_id = source->x_beg_id;
    dest->y_end_id = source->x_end_id;
    dest->score = source->score;
}

// Assembly:
movb $0x1, 0x2(%rdi)
movb (%rsi), %al
movb %al, (%rdi)
movzbl 0x1(%rsi), %eax
movb (%rdx,%rax,4), %al
movb %al, 0x1(%rdi)
movl 0x2c(%rsi), %eax
movl %eax, 0x2c(%rdi)
movl 0x28(%rsi), %eax
movl %eax, 0x24(%rdi)
movl 0x24(%rsi), %eax
movl %eax, 0x28(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0x4(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0xc(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0x1c(%rsi), %eax
movl %eax, 0x14(%rdi)
movl 0x20(%rsi), %eax
movl %eax, 0x18(%rdi)
movl 0x14(%rsi), %eax
movl %eax, 0x1c(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x20(%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: filter_hap_overlaps_by_length(hap_overlaps_list*, unsigned int)
void filter_hap_overlaps_by_length(hap_overlaps_list* all_ovlp, uint32_t minLen)
{
    if(minLen == 0) return;
    hap_overlaps *x = NULL;
    uint32_t v, i, m, uId;    

    for (v = 0; v < all_ovlp->num; v++)
    {
        uId = v;
        m = 0;
        for (i = 0; i < all_ovlp->x[uId].a.n; i++)
        {
            x = &(all_ovlp->x[uId].a.a[i]);
            if(x->x_end_id - x->x_beg_id < minLen) continue;
            all_ovlp->x[uId].a.a[m] = (*x);
            m++;
        }
        all_ovlp->x[uId].a.n = m;
    }
}

// Assembly:
testl %esi, %esi
je 0x10cdcc
cmpl $0x0, 0x8(%rdi)
je 0x10cdcc
xorl %eax, %eax
movq (%rdi), %r10
leaq (%rax,%rax,2), %rcx
cmpq $0x0, (%r10,%rcx,8)
je 0x10cdb4
xorl %r9d, %r9d
movl $0x1, %edx
xorl %r8d, %r8d
movq 0x10(%r10,%rcx,8), %r10
shlq $0x6, %r9
movl 0x18(%r10,%r9), %r11d
subl 0x14(%r10,%r9), %r11d
cmpl %esi, %r11d
jb 0x10cd9d
addq %r10, %r9
movl %r8d, %r11d
shlq $0x6, %r11
movups (%r9), %xmm0
movups 0x10(%r9), %xmm1
movups 0x20(%r9), %xmm2
movups 0x30(%r9), %xmm3
movups %xmm3, 0x30(%r10,%r11)
movups %xmm2, 0x20(%r10,%r11)
movups %xmm1, 0x10(%r10,%r11)
movups %xmm0, (%r10,%r11)
incl %r8d
movl %edx, %r9d
movq (%rdi), %r10
incl %edx
cmpq %r9, (%r10,%rcx,8)
ja 0x10cd4e
leaq (%r10,%rcx,8), %rcx
movl %r8d, %edx
jmp 0x10cdba
leaq (%r10,%rcx,8), %rcx
xorl %edx, %edx
movq %rdx, (%rcx)
incq %rax
movl 0x8(%rdi), %ecx
cmpq %rcx, %rax
jb 0x10cd35
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_purge_gfa(ma_ug_t*, asg_t*)
void print_purge_gfa(ma_ug_t *ug, asg_t *purge_g)
{
    uint32_t v, i, n_vtx = purge_g->n_seq * 2;
    for (v = 0; v < n_vtx; v++)
    {
        if(v%2==0) fprintf(stderr, "\n");
        if(purge_g->seq[v>>1].del)
        {
            fprintf(stderr, "(D) v>>1: %u, v&1: %u, utg%.6d%c\n", v>>1, v&1, (v>>1)+1,
            "lc"[ug->u.a[v>>1].circ]);
            continue;
        } 

        fprintf(stderr, "(E) v>>1: %u, v&1: %u, utg%.6dl%c\n", v>>1, v&1, (v>>1)+1,
        "lc"[ug->u.a[v>>1].circ]);
        
        uint32_t nv = asg_arc_n(purge_g, v);
		asg_arc_t *av = asg_arc_a(purge_g, v);
        for (i = 0; i < nv; i++)
        {
            if(av[i].del) continue;
            fprintf(stderr, "av[i].ul: %u (utg%.6d%c, dir: %u, len: %u), av[i].v: %u (utg%.6d%c, dir: %u, len: %u), ol: %u\n", 
                (uint32_t)(av[i].ul>>33), (uint32_t)(av[i].ul>>33)+1, "lc"[ug->u.a[av[i].ul>>33].circ], (uint32_t)(av[i].ul>>32)&1, ug->u.a[av[i].ul>>33].len, 
                av[i].v>>1, (av[i].v>>1)+1, "lc"[ug->u.a[av[i].v>>1].circ], av[i].v&1, ug->u.a[av[i].v>>1].len, av[i].ol);
        }

    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movl 0x14(%rsi), %eax
addl %eax, %eax
je 0x10d1b2
movq %rsi, %rbx
movq (%rsp), %rcx
leaq 0x10(%rcx), %r15
movl %eax, %r12d
xorl %r13d, %r13d
testb $0x1, %r13b
jne 0x10d0f1
movq 0x17cefc(%rip), %rax    # 0x289fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2270
movl %r13d, %ecx
andl $0x1, %ecx
movq 0x20(%rbx), %rax
movl %r13d, %edx
shrl %edx
movl %edx, %r8d
incl %r8d
cmpl $0x0, (%rax,%rdx,8)
movq 0x17cecf(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq (%rdx,%rdx,4), %rax
js 0x10d17e
movq (%r15), %rsi
movl (%rsi,%rax,8), %eax
shrl $0x1f, %eax
leaq 0x11b501(%rip), %rsi    # 0x22862b
movsbl (%rax,%rsi), %r9d
leaq 0x1205ea(%rip), %rsi    # 0x22d720
xorl %eax, %eax
callq 0x22b0
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rax
testl %eax, %eax
je 0x10d1a6
movq %rax, %rcx
shrq $0x20, %rcx
leaq (%rcx,%rcx,2), %rbp
shlq $0x3, %rbp
addq 0x8(%rbx), %rbp
movl %eax, %r14d
movl 0xc(%rbp), %edx
testl %edx, %edx
jns 0x10d171
addq $0x18, %rbp
decq %r14
jne 0x10d15f
jmp 0x10d1a6
movq %rbp, %rdi
movq %r15, %rsi
callq 0x13c0b
jmp 0x10d166
movq (%rsp), %rsi
movq 0x10(%rsi), %rsi
movl (%rsi,%rax,8), %eax
shrl $0x1f, %eax
leaq 0x11b498(%rip), %rsi    # 0x22862b
movsbl (%rax,%rsi), %r9d
leaq 0x12055f(%rip), %rsi    # 0x22d6fe
xorl %eax, %eax
callq 0x22b0
incq %r13
cmpq %r12, %r13
jne 0x10d0d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: decode_score(unsigned int, unsigned int)
long long decode_score(uint32_t h_bits, uint32_t l_bits)
{
    uint64_t x; 
    x = h_bits; x <<= 32; x += l_bits;
    long long score = ((uint64_t)((uint64_t)x<<1)>>1);
    if((x>>63) == 0) score *= -1;
    return score;
}

// Assembly:
movl %esi, %eax
movl %edi, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, %rax
negq %rax
testl %edi, %edi
cmovsq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: asg_pop_bubble_purge_graph(asg_t*)
int asg_pop_bubble_purge_graph(asg_t *purge_g)
{
	uint32_t v, n_vtx = purge_g->n_seq * 2;
	uint64_t n_pop = 0;
	buf_t b;
	if (!purge_g->is_symm) asg_symm(purge_g);
	memset(&b, 0, sizeof(buf_t));
	///set information for each node
	b.a = (binfo_t*)calloc(n_vtx, sizeof(binfo_t));
	//traverse all node with two directions 
	for (v = 0; v < n_vtx; ++v) {
		uint32_t i, n_arc = 0, nv = asg_arc_n(purge_g, v);
		asg_arc_t *av = asg_arc_a(purge_g, v);
		///some node could be deleted
		if (nv < 2 || purge_g->seq[v>>1].del || purge_g->seq[v>>1].c == ALTER_LABLE) continue;
		///some edges could be deleted
		for (i = 0; i < nv; ++i) // asg_bub_pop1() may delete some edges/arcs
			if (!av[i].del) ++n_arc;
		if (n_arc > 1)
			n_pop += asg_bub_pop1_purge_graph(purge_g, v, purge_g->n_seq, &b);            
	}
	free(b.a); free(b.S.a); free(b.T.a); free(b.b.a); free(b.e.a);
	if (n_pop) asg_cleanup(purge_g);

	if(VERBOSE >= 1)
    {
        fprintf(stderr, "[M::%s] popped %lu bubbles\n", __func__, (unsigned long)n_pop);
    }
    return n_pop;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movl 0x14(%rdi), %eax
leal (%rax,%rax), %ebp
testl %eax, %eax
js 0x10d8f9
movq %rbx, %rdi
callq 0xa047e
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x60(%rsp)
movl %ebp, %r15d
movl $0x1c, %esi
movq %r15, %rdi
callq 0x2120
movq %rax, (%rsp)
testl %ebp, %ebp
je 0x10d9c3
xorl %r12d, %r12d
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq %rsp, %r13
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rax
testl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
je 0x10d9b9
movq 0x20(%rbx), %rcx
movl %r12d, %edx
shrl %edx
cmpl $0x0, (%rcx,%rdx,8)
js 0x10d9b9
cmpb $0x1, 0x4(%rcx,%rdx,8)
je 0x10d9b9
movq 0x8(%rbx), %rcx
movq %rax, %rdx
shrq $0x20, %rdx
movl %eax, %eax
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,8), %rdx
addq $0xc, %rdx
xorl %ecx, %ecx
movl (%rdx), %esi
notl %esi
shrl $0x1f, %esi
addl %esi, %ecx
addq $0x18, %rdx
decq %rax
jne 0x10d98c
cmpl $0x2, %ecx
jb 0x10d9b9
movl 0x14(%rbx), %edx
andl %ebp, %edx
movq %rbx, %rdi
movl %r12d, %esi
movq %r13, %rcx
callq 0x10d208
addq %rax, %r14
incq %r12
cmpq %r15, %r12
jne 0x10d94c
jmp 0x10d9c6
xorl %r14d, %r14d
movq (%rsp), %rdi
callq 0x2220
movq 0x18(%rsp), %rdi
callq 0x2220
movq 0x30(%rsp), %rdi
callq 0x2220
movq 0x48(%rsp), %rdi
callq 0x2220
movq 0x60(%rsp), %rdi
callq 0x2220
testq %r14, %r14
je 0x10da04
movq %rbx, %rdi
callq 0xa02fa
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: clean_purge_graph(asg_t*, float, unsigned int)
void clean_purge_graph(asg_t *purge_g, float drop_ratio, uint32_t is_force_break)
{
    uint64_t operation = 1;
    while (operation > 0)
    {
        operation = 0;
        operation += asg_pop_bubble_purge_graph(purge_g);
        operation += purge_g_arc_del_short_diploid_by_score(purge_g, drop_ratio);
    }
    
    if(is_force_break) purge_g_arc_del_short_diploid_by_score(purge_g, 1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x10d8d6
movslq %eax, %r14
movq %rbx, %rdi
movss 0xc(%rsp), %xmm0
callq 0x10ddd4
cltq
addq %r14, %rax
jne 0x10e11f
testl %ebp, %ebp
je 0x10e15b
movss 0x113f75(%rip), %xmm0   # 0x2220c0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x10ddd4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: collect_trans_purge_cov(hap_cov_t*, ma_ug_t*, hap_overlaps*, unsigned int)
void collect_trans_purge_cov(hap_cov_t *cov, ma_ug_t *ug, hap_overlaps* x, uint32_t is_keep_X)
{
    if(ug->u.a[x->xUid].n == 0 || ug->u.a[x->yUid].n == 0) return;
    uint64_t *pri = NULL, pri_n, *aux = NULL, aux_n, i, rId, uCov = 0, uLen = 0;

    if(is_keep_X)
    {
        pri = ug->u.a[x->xUid].a + x->x_beg_id;
        pri_n = x->x_end_id - x->x_beg_id;

        aux = ug->u.a[x->yUid].a + x->y_beg_id;
        aux_n = x->y_end_id - x->y_beg_id;
    }
    else
    {
        pri = ug->u.a[x->yUid].a + x->y_beg_id;
        pri_n = x->y_end_id - x->y_beg_id;

        aux = ug->u.a[x->xUid].a + x->x_beg_id;
        aux_n = x->x_end_id - x->x_beg_id;
    }


    uCov = uLen = 0;
    for (i = 0; i < aux_n; i++)
    {
        rId = aux[i]>>33;
        uCov += cov->cov[rId];
    }

    for (i = 0; i < pri_n; i++)
    {
        rId = pri[i]>>33;
        uLen += cov->read_g->seq[rId].len;
    }
    
    uCov = (uLen == 0? 0 : uCov / uLen);


    for (i = 0; i < pri_n; i++)
    {
        rId = pri[i]>>33;
        cov->cov[rId] += (uCov * cov->read_g->seq[rId].len);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
movl 0x24(%rdx), %esi
leaq (%rsi,%rsi,4), %rsi
cmpl $0x0, 0x10(%rax,%rsi,8)
je 0x10edf1
movl 0x28(%rdx), %r8d
leaq (%r8,%r8,4), %r8
cmpl $0x0, 0x10(%rax,%r8,8)
je 0x10edf1
leaq (%rax,%rsi,8), %rsi
leaq (%rax,%r8,8), %rax
xorl %ebx, %ebx
xorl %r8d, %r8d
testl %ecx, %ecx
setne %bl
movq %rsi, %rcx
cmoveq %rax, %rcx
sete %r8b
cmoveq %rsi, %rax
movl 0x14(%rdx,%r8,8), %r9d
movl 0x18(%rdx,%r8,8), %r10d
movq %r9, %rsi
shlq $0x3, %rsi
movl %r10d, %r8d
subl %r9d, %r8d
movl 0x14(%rdx,%rbx,8), %r11d
movl 0x18(%rdx,%rbx,8), %edx
subl %r11d, %edx
jne 0x10ed49
xorl %eax, %eax
jmp 0x10ed71
shlq $0x3, %r11
addq 0x18(%rax), %r11
movq 0x8(%rdi), %rbx
xorl %eax, %eax
xorl %r14d, %r14d
movq (%r11,%r14,8), %r15
shrq $0x21, %r15
movl (%rbx,%r15,4), %r15d
addq %r15, %rax
incq %r14
cmpq %r14, %rdx
jne 0x10ed5a
addq 0x18(%rcx), %rsi
xorl %ecx, %ecx
cmpl %r9d, %r10d
jne 0x10ed81
xorl %r11d, %r11d
jmp 0x10edac
movq 0x30(%rdi), %rdx
movq 0x20(%rdx), %rdx
xorl %r11d, %r11d
xorl %ebx, %ebx
movq (%rsi,%rbx,8), %r14
shrq $0x21, %r14
movl (%rdx,%r14,8), %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
addq %r14, %r11
incq %rbx
cmpq %rbx, %r8
jne 0x10ed8e
testq %r11, %r11
je 0x10edb9
xorl %edx, %edx
divq %r11
movq %rax, %rcx
cmpl %r9d, %r10d
je 0x10edf1
movq 0x8(%rdi), %rax
movq 0x30(%rdi), %rdx
movq 0x20(%rdx), %rdx
xorl %edi, %edi
movl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
movq (%rsi,%rdi,8), %r10
shrq $0x21, %r10
movl (%rdx,%r10,8), %r11d
andl %r9d, %r11d
imull %ecx, %r11d
addl %r11d, (%rax,%r10,4)
incq %rdi
cmpq %rdi, %r8
jne 0x10edd2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: get_contig_length(ma_ug_t*, asg_t*, unsigned long*, unsigned long*)
void get_contig_length(ma_ug_t *ug, asg_t *g, uint64_t* primaryLen, uint64_t* alterLen)
{
    uint8_t *del = (uint8_t *)malloc(sizeof(uint8_t)*g->n_seq);
    uint32_t v, k;
    ma_utg_t* u = NULL;
    memset(del, 1, g->n_seq);
    (*primaryLen) = (*alterLen) = 0;

    for (v = 0; v < ug->g->n_seq; ++v) 
    {
        if(ug->g->seq[v].del) continue;
        if(ug->g->seq[v].c == ALTER_LABLE) continue;
        u = &(ug->u.a[v]);
        if(u->m == 0) continue;
        for (k = 0; k < u->n; k++)
        {
            del[u->a[k]>>33] = 0;
        }
    }
    (*primaryLen) = get_specific_contig_length(g, del);


    for (v = 0; v < g->n_seq; ++v) 
    {
        del[v] = 1 - del[v];
    }

    (*alterLen) = get_specific_contig_length(g, del);

    free(del);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movl 0x14(%rsi), %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq %rbp, %rdi
callq 0x2280
movq %rax, %r15
movq %rax, %rdi
movl $0x1, %esi
movq %rbp, %rdx
callq 0x20e0
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, (%r12)
movq 0x18(%r13), %rax
testl $0x7fffffff, 0x14(%rax) # imm = 0x7FFFFFFF
je 0x110852
xorl %ecx, %ecx
movq 0x20(%rax), %rdx
cmpl $0x0, (%rdx,%rcx,8)
js 0x110841
cmpb $0x1, 0x4(%rdx,%rcx,8)
je 0x110841
movq 0x10(%r13), %rdx
leaq (%rcx,%rcx,4), %rsi
cmpl $0x0, 0xc(%rdx,%rsi,8)
je 0x110841
leaq (%rdx,%rsi,8), %rdx
cmpl $0x0, 0x10(%rdx)
je 0x110841
xorl %esi, %esi
movq 0x18(%rdx), %rdi
movq (%rdi,%rsi,8), %rdi
shrq $0x21, %rdi
movb $0x0, (%r15,%rdi)
incq %rsi
movl 0x10(%rdx), %edi
cmpq %rdi, %rsi
jb 0x110825
incq %rcx
movl 0x14(%rax), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpq %rdx, %rcx
jb 0x1107f9
movq %r14, %rdi
movq %r15, %rsi
callq 0x110123
movq %rax, (%r12)
movl 0x14(%r14), %eax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
je 0x110881
xorl %ecx, %ecx
movb $0x1, %dl
subb (%r15,%rcx), %dl
movb %dl, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x11086f
movq %r14, %rdi
movq %r15, %rsi
callq 0x110123
movq %rax, (%rbx)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: destory_p_g_t(p_g_t**)
void destory_p_g_t(p_g_t **pg)
{
    if(pg && (*pg))
    {
        kv_destroy((*pg)->pg_het_node);
        kv_destroy((*pg)->pg_h_lev_idx);
        asg_destroy((*pg)->pg_het);
        asg_destroy((*pg)->pg_h_lev);
        free((*pg)); 
        (*pg) = NULL;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x1122f1
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1122f0
movq 0x18(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x40(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x9fcdb
movq (%rbx), %rax
movq 0x28(%rax), %rdi
callq 0x9fcdb
movq (%rbx), %rdi
callq 0x2220
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: collect_purge_trans_cov(ma_ug_t*, hap_overlaps_list*, hap_cov_t*, unsigned long*)
void collect_purge_trans_cov(ma_ug_t *ug, hap_overlaps_list* ha, hap_cov_t *cov, uint64_t* position_index)
{   
    uint32_t v, i;
    hap_overlaps *x = NULL;
    for (v = 0; v < ha->num; v++)
    {
        for (i = 0; i < ha->x[v].a.n; i++)
        {
            x = &(ha->x[v].a.a[i]);
            if(x->yUid < x->xUid) continue;
            chain_origin_trans_uid_by_purge(x, ug, cov, position_index);
        }
    }
}

// Assembly:
cmpl $0x0, 0x8(%rsi)
je 0x112716
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %edx, %edx
movq (%r15), %rcx
movq %rdx, (%rsp)
leaq (%rdx,%rdx,2), %rbp
cmpq $0x0, (%rcx,%rbp,8)
je 0x1126f8
movl $0x1, %r13d
xorl %eax, %eax
movq 0x10(%rcx,%rbp,8), %rdi
shlq $0x6, %rax
movl 0x28(%rdi,%rax), %ecx
cmpl 0x24(%rdi,%rax), %ecx
jb 0x1126e9
addq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1122f2
movl %r13d, %eax
movq (%r15), %rcx
incl %r13d
cmpq %rax, (%rcx,%rbp,8)
ja 0x1126c5
movq (%rsp), %rdx
incq %rdx
movl 0x8(%r15), %eax
cmpq %rax, %rdx
jb 0x1126ab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: filter_ovlp_vecs(hap_overlaps_list*, unsigned int*, unsigned int)
void filter_ovlp_vecs(hap_overlaps_list* ha, uint32_t *a, uint32_t a_n)
{
    uint32_t st, k, i, m, v, w;
    int idx;
    radix_sort_ru32(a, a + a_n);
    for (st = 0, m = 0, k = 1; k <= a_n; k++){
        if(k == a_n || a[k] != a[st]){
            a[m++] = a[st];
            st = k;
        }
    }
    a_n = m;
    if(a_n < 2) return;
    for (k = 0; k < a_n; k++){
        v = a[k];
        for (i = k+1; i < a_n; i++) {
            w = a[i];
            idx = get_specific_hap_overlap(&(ha->x[v]), v, w);
            if(idx != -1) ha->x[v].a.a[idx].status = DELETE;
            idx = get_specific_hap_overlap(&(ha->x[w]), w, v);
            if(idx != -1) ha->x[w].a.a[idx].status = DELETE;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, (%rsp)
movl %edx, %r15d
leaq (%rsi,%r15,4), %rsi
movq %rbx, %rdi
callq 0x10a405
testl %ebp, %ebp
je 0x11297e
incl %ebp
cmpl $0x3, %ebp
movl $0x2, %ecx
cmovael %ebp, %ecx
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %esi, %edi
cmpq %rdx, %r15
je 0x112968
movl (%rbx,%rdx,4), %r8d
cmpl (%rbx,%rdi,4), %r8d
je 0x112974
movl (%rbx,%rdi,4), %esi
movl %eax, %edi
incl %eax
movl %esi, (%rbx,%rdi,4)
movl %edx, %esi
incq %rdx
cmpq %rdx, %rcx
jne 0x112957
jmp 0x112980
xorl %eax, %eax
cmpl $0x2, %eax
jb 0x112a88
movl %eax, %esi
movl $0x1, %edx
xorl %ecx, %ecx
movq %rsi, 0x8(%rsp)
leaq 0x1(%rcx), %rdi
movq %rdi, 0x10(%rsp)
cmpq %rsi, %rdi
jae 0x112a72
movl (%rbx,%rcx,4), %edi
movq (%rsp), %rcx
movq (%rcx), %r8
leaq (%rdi,%rdi,2), %rcx
leaq (%r8,%rcx,8), %r9
movq (%r9), %r10
movq %rdx, %r11
movl (%rbx,%r11,4), %r15d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r10, %r10
je 0x1129fc
movq 0x10(%r9), %r12
xorl %ecx, %ecx
xorl %r14d, %r14d
shlq $0x6, %rcx
cmpl %edi, 0x24(%r12,%rcx)
jne 0x1129ec
addq %r12, %rcx
cmpl %r15d, 0x28(%rcx)
je 0x1129f9
incl %r14d
movq %r14, %rcx
cmpq %r14, %r10
ja 0x1129d8
jmp 0x1129fc
movl %r14d, %ebp
cmpl $-0x1, %ebp
je 0x112a11
movq 0x10(%r9), %rcx
movslq %ebp, %rsi
shlq $0x6, %rsi
movb $0x2, 0x2(%rcx,%rsi)
leaq (%r15,%r15,2), %r12
movq (%r8,%r12,8), %r13
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r13, %r13
je 0x112a50
leaq (%r8,%r12,8), %rcx
movq 0x10(%rcx), %r14
xorl %ecx, %ecx
xorl %esi, %esi
shlq $0x6, %rcx
cmpl %r15d, 0x24(%r14,%rcx)
jne 0x112a42
addq %r14, %rcx
cmpl %edi, 0x28(%rcx)
je 0x112a4e
incl %esi
movq %rsi, %rcx
cmpq %rsi, %r13
ja 0x112a2f
jmp 0x112a50
movl %esi, %ebp
cmpl $-0x1, %ebp
je 0x112a66
movq 0x10(%r8,%r12,8), %rcx
movslq %ebp, %rsi
shlq $0x6, %rsi
movb $0x2, 0x2(%rcx,%rsi)
incq %r11
cmpl %r11d, %eax
jne 0x1129c1
incq %rdx
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
cmpq %rsi, %rcx
jne 0x112997
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: yak_copt_init(yak_copt_t*)
void yak_copt_init(yak_copt_t *o)
{
	memset(o, 0, sizeof(yak_copt_t));
	o->bf_shift = 0;
	o->bf_n_hash = 4;
	o->k = 31;
	o->w = 1;
	o->pre = YAK_COUNTER_BITS;
	o->n_thread = 4;
	o->chunk_size = 20000000;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movabsq $0x1f00000004, %rax     # imm = 0x1F00000004
movq %rax, 0x4(%rdi)
movl $0x1, 0xc(%rdi)
movabsq $0x40000000c, %rax      # imm = 0x40000000C
movq %rax, 0x18(%rdi)
movq $0x1312d00, 0x20(%rdi)  # imm = 0x1312D00
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: yak_bf_init(int, int)
yak_bf_t *yak_bf_init(int n_shift, int n_hashes)
{
	yak_bf_t *b;
	void *ptr = 0;
	if (n_shift + YAK_BLK_SHIFT > 64 || n_shift < YAK_BLK_SHIFT) return 0;
	CALLOC(b, 1);
	b->n_shift = n_shift;
	b->n_hashes = n_hashes;
	posix_memalign(&ptr, 1<<(YAK_BLK_SHIFT-3), 1ULL<<(n_shift-3));
	b->b = (uint8_t*)ptr;
	bzero(b->b, 1ULL<<(n_shift-3));
	return b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
movq $0x0, (%rsp)
leal -0x38(%r14), %eax
cmpl $-0x2f, %eax
jae 0x112e69
xorl %ebx, %ebx
jmp 0x112eb7
movl %esi, %ebp
movl $0x1, %r15d
movl $0x1, %edi
movl $0x10, %esi
callq 0x2120
movq %rax, %rbx
movl %r14d, (%rax)
movl %ebp, 0x4(%rax)
addb $-0x3, %r14b
movl %r14d, %ecx
shlq %cl, %r15
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x20c0
movq (%r14), %rdi
movq %rdi, 0x8(%rbx)
xorl %esi, %esi
movq %r15, %rdx
callq 0x20e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: yak_bf_insert(yak_bf_t*, unsigned long)
int yak_bf_insert(yak_bf_t *b, uint64_t hash)
{
	int x = b->n_shift - YAK_BLK_SHIFT;
	uint64_t y = hash & ((1ULL<<x) - 1);
	int h1 = hash >> x & YAK_BLK_MASK;
	int h2 = hash >> b->n_shift & YAK_BLK_MASK;
	uint8_t *p = &b->b[y<<(YAK_BLK_SHIFT-3)];
	int i, z = h1, cnt = 0;
	if ((h2&31) == 0) h2 = (h2 + 1) & YAK_BLK_MASK; // otherwise we may repeatedly use a few bits
	for (i = 0; i < b->n_hashes; z = (z + h2) & YAK_BLK_MASK) {
		uint8_t *q = &p[z>>3], u;
		u = 1<<(z&7);
		cnt += !!(*q & u);
		*q |= u;
		++i;
	}
	return cnt;
}

// Assembly:
movl (%rdi), %edx
leal -0x9(%rdx), %eax
movq $-0x1, %r8
movl %eax, %ecx
shlq %cl, %r8
movq %rsi, %r9
movl %edx, %ecx
shrq %cl, %r9
movl %r9d, %ecx
andl $0x1f, %ecx
cmpl $0x1, %ecx
adcl $0x0, %r9d
cmpl $0x0, 0x4(%rdi)
jle 0x112f57
notq %r8
andq %rsi, %r8
shlq $0x6, %r8
movl %eax, %ecx
shrq %cl, %rsi
addq 0x8(%rdi), %r8
xorl %ecx, %ecx
xorl %eax, %eax
movl %esi, %edx
andl $0x1ff, %edx            # imm = 0x1FF
movl %edx, %r10d
shrl $0x3, %r10d
andl $0x7, %esi
movzbl (%r8,%r10), %r11d
btl %esi, %r11d
adcl $0x0, %eax
btsl %esi, %r11d
movb %r11b, (%r8,%r10)
incl %ecx
addl %r9d, %edx
movl %edx, %esi
cmpl 0x4(%rdi), %ecx
jl 0x112f24
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_gen(ha_ct_t*, int, int)
ha_pt_t *ha_pt_gen(ha_ct_t *ct, int n_thread, int is_l)
{
	pt_gen_aux_t a;
	int i;
	ha_pt_t *pt;
	ha_ct_destroy_bf(ct);
	CALLOC(pt, 1);
	pt->k = ct->k, pt->pre = ct->pre, pt->tot = ct->tot;
	CALLOC(pt->h, 1<<pt->pre);
	for (i = 0; i < 1<<pt->pre; ++i) {
		pt->h[i].h = yak_pt_init();
		yak_pt_resize(pt->h[i].h, kh_size(ct->h[i].h));
	}
	a.ct = ct, a.pt = pt, a.is_l = is_l;
	kt_for(n_thread, worker_pt_gen, &a, 1<<pt->pre);
	free(ct->h); free(ct);
	return pt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
callq 0x1132c7
movl $0x1, %edi
movl $0x20, %esi
callq 0x2120
movq %rax, %r14
movl (%rbx), %eax
movl %eax, (%r14)
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movl $0x1, %r13d
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdi
movl $0x20, %esi
callq 0x2120
movq %rax, 0x18(%r14)
movl 0x4(%r14), %ecx
shll %cl, %r13d
cmpl $0x1f, %ecx
je 0x113281
xorl %r12d, %r12d
xorl %ebp, %ebp
movl $0x1, %edi
movl $0x18, %esi
callq 0x2120
movq 0x18(%r14), %rcx
movq %rax, (%rcx,%r12,2)
movq 0x20(%rbx), %rcx
movq (%rcx,%r12), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x115daf
movb 0x4(%r14), %cl
movl $0x1, %r13d
shll %cl, %r13d
incq %rbp
movslq %r13d, %rax
addq $0x10, %r12
cmpq %rax, %rbp
jl 0x11323b
leaq 0x10(%rsp), %rdx
movq %rbx, (%rdx)
movq %r14, 0x8(%rdx)
movl %r15d, 0x10(%rdx)
movslq %r13d, %rcx
leaq 0x94(%rip), %rsi        # 0x11332f
movl 0xc(%rsp), %edi
callq 0x1047b4
movq 0x20(%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2220
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_destroy_bf(ha_ct_t*)
static void ha_ct_destroy_bf(ha_ct_t *h)
{
	int i;
	for (i = 0; i < 1<<h->pre; ++i) {
		if (h->h[i].b)
			yak_bf_destroy(h->h[i].b);
		h->h[i].b = 0;
	}
}

// Assembly:
cmpl $0x1f, 0x4(%rdi)
je 0x11332e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x20(%rbx), %rax
movq (%rax,%r15), %r14
testq %r14, %r14
je 0x1132ff
movq 0x8(%r14), %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2220
movq 0x20(%rbx), %rax
movq $0x0, (%rax,%r15)
movb 0x4(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
incq %r12
cltq
addq $0x10, %r15
cmpq %rax, %r12
jl 0x1132e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: worker_pt_gen(void*, long, int)
static void worker_pt_gen(void *data, long i, int tid) // callback for kt_for()
{
	pt_gen_aux_t *a = (pt_gen_aux_t*)data;
	ha_pt1_t *b = &a->pt->h[i];
	yak_ct_t *g = a->ct->h[i].h;
	khint_t k;
	for (k = 0, b->n = 0; k != kh_end(g); ++k) {
		if (kh_exist(g, k)) {
			int absent;
			khint_t l;
			l = yak_pt_put(b->h, kh_key(g, k) >> a->ct->pre << YAK_COUNTER_BITS, &absent);
			///this should be the start index of kh_key's corresponding pos at ha_idxpos_t* a
			kh_val(b->h, l) = b->n;
			b->n += kh_key(g, k) & YAK_MAX_COUNT;
		}
	}
	yak_ct_destroy(g);
	a->ct->h[i].h = 0;
	if(a->is_l) CALLOC(b->al, b->n);
	else CALLOC(b->a, b->n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rcx
movq %rsi, %rdx
shlq $0x5, %rdx
leaq (%rcx,%rdx), %r13
movq 0x20(%rax), %rax
shlq $0x4, %rsi
movq %rsi, 0x8(%rsp)
movq (%rax,%rsi), %r15
movq $0x0, 0x8(%rcx,%rdx)
xorl %ebp, %ebp
leaq 0x14(%rsp), %r12
movq 0x10(%r15), %rax
movl $0x0, %edx
testq %rax, %rax
je 0x11338f
movb (%r15), %cl
movl $0x1, %edx
shll %cl, %edx
cmpl %edx, %ebp
je 0x1133f3
movq 0x8(%r15), %rcx
movl %ebp, %edx
shrl $0x5, %edx
movl (%rcx,%rdx,4), %ecx
btl %ebp, %ecx
jae 0x1133ef
movq (%r13), %rdi
movl %ebp, %r14d
movq (%rax,%r14,8), %rsi
movq (%rbx), %rax
movb 0x4(%rax), %cl
shrq %cl, %rsi
shlq $0xc, %rsi
movq %r12, %rdx
callq 0x115fe1
movq (%r13), %rcx
movq 0x8(%r13), %rdx
movq 0x10(%rcx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movq %rdx, 0x8(%rcx,%rax)
movq 0x10(%r15), %rax
movq (%rax,%r14,8), %rax
andl $0xfff, %eax            # imm = 0xFFF
addq %rdx, %rax
movq %rax, 0x8(%r13)
incl %ebp
jmp 0x113377
movq %r15, %rdi
callq 0x1160e2
movq (%rbx), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
movq $0x0, (%rax,%rcx)
xorl %r14d, %r14d
cmpl $0x0, 0x10(%rbx)
setne %r14b
movq 0x8(%r13), %rdi
shll $0x3, %r14d
leaq 0x8(%r14), %rsi
callq 0x2120
movq %rax, 0x10(%r13,%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_gen_count(ha_ct_t*, int)
ha_pt_t *ha_pt_gen_count(ha_ct_t *ct, int n_thread)
{
	pt_gen_aux_t a;
	int i;
	ha_pt_t *pt;
	ha_ct_destroy_bf(ct);
	CALLOC(pt, 1);
	pt->k = ct->k, pt->pre = ct->pre, pt->tot = ct->tot;
	CALLOC(pt->h, 1<<pt->pre);
	for (i = 0; i < 1<<pt->pre; ++i) {
		pt->h[i].h = yak_pt_init();
		yak_pt_resize(pt->h[i].h, kh_size(ct->h[i].h));
	}
	a.ct = ct, a.pt = pt;
	kt_for(n_thread, worker_pt_gen_count, &a, 1<<pt->pre);
	free(ct->h); free(ct);
	return pt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1132c7
movl $0x1, %edi
movl $0x20, %esi
callq 0x2120
movq %rax, %r14
movl (%rbx), %eax
movl %eax, (%r14)
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movl $0x1, %r12d
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdi
movl $0x20, %esi
callq 0x2120
movq %rax, 0x18(%r14)
movl 0x4(%r14), %ecx
shll %cl, %r12d
cmpl $0x1f, %ecx
je 0x1134f3
xorl %r15d, %r15d
xorl %r13d, %r13d
movl $0x1, %edi
movl $0x18, %esi
callq 0x2120
movq 0x18(%r14), %rcx
movq %rax, (%rcx,%r15,2)
movq 0x20(%rbx), %rcx
movq (%rcx,%r15), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x115daf
movb 0x4(%r14), %cl
movl $0x1, %r12d
shll %cl, %r12d
incq %r13
movslq %r12d, %rax
addq $0x10, %r15
cmpq %rax, %r13
jl 0x1134ad
movq %rsp, %rdx
movq %rbx, (%rdx)
movq %r14, 0x8(%rdx)
movslq %r12d, %rcx
leaq 0x2a(%rip), %rsi        # 0x113531
movl %ebp, %edi
callq 0x1047b4
movq 0x20(%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2220
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: worker_pt_gen_count(void*, long, int)
static void worker_pt_gen_count(void *data, long i, int tid) // callback for kt_for()
{
	pt_gen_aux_t *a = (pt_gen_aux_t*)data;
	ha_pt1_t *b = &a->pt->h[i];
	yak_ct_t *g = a->ct->h[i].h;
	khint_t k;
	for (k = 0, b->n = 0; k != kh_end(g); ++k) {
		if (kh_exist(g, k)) {
			int absent;
			khint_t l;
			l = yak_pt_put(b->h, kh_key(g, k) >> a->ct->pre << YAK_COUNTER_BITS, &absent);
			kh_val(b->h, l) = 0; kh_key(b->h, l) |= kh_key(g, k) & YAK_MAX_COUNT;
		}
	}
	yak_ct_destroy(g);
	a->ct->h[i].h = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rcx
movq %rsi, %rdx
shlq $0x5, %rdx
leaq (%rcx,%rdx), %r13
movq 0x20(%rax), %rax
shlq $0x4, %rsi
movq %rsi, 0x8(%rsp)
movq (%rax,%rsi), %r15
movq $0x0, 0x8(%rcx,%rdx)
xorl %ebp, %ebp
leaq 0x14(%rsp), %r12
movq 0x10(%r15), %rax
movl $0x0, %edx
testq %rax, %rax
je 0x113591
movb (%r15), %cl
movl $0x1, %edx
shll %cl, %edx
cmpl %edx, %ebp
je 0x1135f2
movq 0x8(%r15), %rcx
movl %ebp, %edx
shrl $0x5, %edx
movl (%rcx,%rdx,4), %ecx
btl %ebp, %ecx
jae 0x1135ee
movq (%r13), %rdi
movl %ebp, %ebx
movq (%rax,%rbx,8), %rsi
movq (%r14), %rax
movb 0x4(%rax), %cl
shrq %cl, %rsi
shlq $0xc, %rsi
movq %r12, %rdx
callq 0x115fe1
movq (%r13), %rcx
movq 0x10(%rcx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movq $0x0, 0x8(%rcx,%rax)
movq 0x10(%r15), %rdx
movq (%rdx,%rbx,8), %rdx
andl $0xfff, %edx            # imm = 0xFFF
orq %rdx, (%rcx,%rax)
incl %ebp
jmp 0x113579
movq %r15, %rdi
callq 0x1160e2
movq (%r14), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
movq $0x0, (%rax,%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq