LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: get_hap_arch(hap_overlaps*, unsigned int, unsigned int, int, float, int, asg_arc_t*)
int get_hap_arch(hap_overlaps* hap, uint32_t qLen, uint32_t tLen, int max_hang, float max_hang_rate, 
int min_ovlp, asg_arc_t* t)
{
    int r;
    ma_hit_t h;
    h.qns = hap->xUid;
    h.qns = h.qns << 32;
    h.qns = h.qns | hap->x_beg_pos;
    h.qe = hap->x_end_pos;
    h.tn = hap->yUid;
    h.ts = hap->y_beg_pos;
    h.te = hap->y_end_pos;
    h.rev = hap->rev;
    h.del = 0;
    h.bl = h.el = h.ml = h.no_l_indel = 0;

    r = ma_hit2arc(&h, qLen, tLen, max_hang, max_hang_rate, min_ovlp, t);
    if(r < 0) return r;
    uint64_t score = (hap->score >= 0? (hap->score) : (hap->score*(-1)));
    if(hap->score >= 0) score += (((uint64_t)1)<<63);
    t->ol = (uint32_t)score;
    t->ul >>= 32; t->ul <<= 32; t->ul |= (score>>32);
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x8(%rsp)
movl 0x4(%rdi), %ebx
movl 0x8(%rdi), %r11d
movl 0xc(%rdi), %r13d
movl 0x10(%rdi), %r12d
movb (%rdi), %r9b
subl %r12d, %edx
testb $0x1, %r9b
movl %r13d, %ebp
cmovel %edx, %ebp
cmovel %r13d, %edx
cmpl %ebx, %edx
movl %ebx, %r10d
cmovll %edx, %r10d
movl %esi, %r15d
subl %r11d, %r15d
cmpl %ebp, %r15d
movl %ebp, %r14d
cmovll %r15d, %r14d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %r10d
jg 0x112b8b
cmpl %ecx, %r14d
jg 0x112b8b
movl %r11d, %ecx
subl %ebx, %ecx
cvtsi2ss %rcx, %xmm1
addl %r10d, %r14d
addl %r14d, %ecx
cvtsi2ss %rcx, %xmm2
mulss %xmm0, %xmm2
ucomiss %xmm1, %xmm2
ja 0x112b8b
subl %r13d, %r12d
xorps %xmm1, %xmm1
cvtsi2ss %r12, %xmm1
addl %r12d, %r14d
xorps %xmm2, %xmm2
cvtsi2ss %r14, %xmm2
mulss %xmm0, %xmm2
ucomiss %xmm1, %xmm2
ja 0x112b8b
cmpl %edx, %ebx
setg %al
cmpl %ebp, %r15d
setg %r10b
orb %al, %r10b
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpb $0x1, %r10b
jne 0x112b8b
cmpl %ebp, %r15d
setl %al
cmpl %edx, %ebx
setl %r10b
orb %al, %r10b
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
cmpb $0x1, %r10b
jne 0x112b8b
cmpl %r8d, %ecx
setl %al
cmpl %r8d, %r14d
setl %cl
orb %al, %cl
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jne 0x112b8b
movl 0x24(%rdi), %r8d
addq %r8, %r8
movl 0x28(%rdi), %r10d
testb $0x1, %r9b
sete %r9b
addl %ebp, %r11d
movl %esi, %ebp
subl %r11d, %ebp
xorl %ecx, %ecx
subl %edx, %ebx
setle %cl
setg %dl
movl %ebx, %eax
cmovlel %ebp, %eax
xorb %r9b, %dl
movzbl %dl, %edx
andl $-0x2, %r8d
orl %r8d, %ecx
leal (%rdx,%r10,2), %edx
shlq $0x20, %rcx
leaq (%rax,%rcx), %r8
movq -0x8(%rsp), %r9
movq %r8, (%r9)
movl %edx, 0x8(%r9)
subl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl %esi, 0xc(%r9)
movb $0x0, 0x12(%r9)
andb $0x3f, 0x11(%r9)
testl %eax, %eax
js 0x112b8b
movq 0x30(%rdi), %rdx
movq %rdx, %rsi
negq %rsi
cmovsq %rdx, %rsi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
andq %rdx, %rdi
orq %rsi, %rdi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl %esi, 0xc(%r9)
shrq $0x20, %rdi
orq %rdi, %rcx
btcq $0x1f, %rcx
movq %rcx, (%r9)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1128b4
movslq %eax, %r14
movq %rbx, %rdi
movss 0xc(%rsp), %xmm0
callq 0x112db1
cltq
addq %r14, %rax
jne 0x113119
testl %ebp, %ebp
je 0x113155
movss 0x11af8b(%rip), %xmm0   # 0x22e0d0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x112db1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq 0x10(%rsi), %rax
movl 0x24(%rdx), %esi
leaq (%rsi,%rsi,4), %rsi
cmpl $0x0, 0x10(%rax,%rsi,8)
je 0x1143ca
movl 0x28(%rdx), %r8d
leaq (%r8,%r8,4), %r8
cmpl $0x0, 0x10(%rax,%r8,8)
je 0x1143ca
leaq (%rax,%rsi,8), %rsi
leaq (%rax,%r8,8), %rax
xorl %r10d, %r10d
xorl %r8d, %r8d
testl %ecx, %ecx
setne %r10b
movq %rsi, %r9
cmoveq %rax, %r9
sete %r8b
cmoveq %rsi, %rax
movl 0x14(%rdx,%r8,8), %ecx
movl 0x18(%rdx,%r8,8), %esi
movl 0x14(%rdx,%r10,8), %r8d
movl 0x18(%rdx,%r10,8), %edx
subl %r8d, %edx
jne 0x11431f
xorl %eax, %eax
jmp 0x114347
shlq $0x3, %r8
addq 0x18(%rax), %r8
movq 0x8(%rdi), %r10
xorl %eax, %eax
xorl %r11d, %r11d
movq (%r8,%r11,8), %rbx
shrq $0x21, %rbx
movl (%r10,%rbx,4), %ebx
addq %rbx, %rax
incq %r11
cmpq %r11, %rdx
jne 0x114330
cmpl %ecx, %esi
je 0x1143ca
movq %rcx, %r8
shlq $0x3, %r8
addq 0x18(%r9), %r8
movl %esi, %r9d
subl %ecx, %r9d
movq 0x30(%rdi), %rdx
movq 0x20(%rdx), %rdx
xorl %r10d, %r10d
xorl %r11d, %r11d
movq (%r8,%r11,8), %rbx
shrq $0x21, %rbx
movl (%rdx,%rbx,8), %ebx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
addq %rbx, %r10
incq %r11
cmpq %r11, %r9
jne 0x11436a
testq %r10, %r10
je 0x114392
xorl %edx, %edx
divq %r10
jmp 0x114394
xorl %eax, %eax
cmpl %ecx, %esi
je 0x1143ca
movq 0x8(%rdi), %rcx
movq 0x30(%rdi), %rdx
movq 0x20(%rdx), %rdx
xorl %esi, %esi
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq (%r8,%rsi,8), %r10
shrq $0x21, %r10
movl (%rdx,%r10,8), %r11d
andl %edi, %r11d
imull %eax, %r11d
addl %r11d, (%rcx,%r10,4)
incq %rsi
cmpq %rsi, %r9
jne 0x1143ab
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movl 0x14(%rsi), %ebp
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rbp
movq %rbp, %rdi
callq 0x2280
movq %rax, %r15
movq %rax, %rdi
movl $0x1, %esi
movq %rbp, %rdx
callq 0x20e0
xorl %eax, %eax
movq %rax, (%r12)
movq %rax, (%rbx)
movq 0x18(%r13), %rcx
movl 0x14(%rcx), %eax
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andq %rdx, %rax
je 0x115fa8
movq 0x20(%rcx), %rcx
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,8)
js 0x115fa0
cmpb $0x1, 0x4(%rcx,%rdx,8)
je 0x115fa0
movq 0x10(%r13), %rsi
leaq (%rdx,%rdx,4), %rdi
cmpl $0x0, 0xc(%rsi,%rdi,8)
je 0x115fa0
leaq (%rsi,%rdi,8), %rdi
movl 0x10(%rdi), %esi
testq %rsi, %rsi
je 0x115fa0
movq 0x18(%rdi), %rdi
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r9
shrq $0x21, %r9
movb $0x0, (%r15,%r9)
incq %r8
cmpq %rsi, %r8
jb 0x115f8b
incq %rdx
cmpq %rax, %rdx
jb 0x115f5c
movq %r14, %rdi
movq %r15, %rsi
callq 0x115840
movq %rax, (%rbx)
movl 0x14(%r14), %eax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
je 0x115fd6
xorl %ecx, %ecx
movb $0x1, %dl
subb (%r15,%rcx), %dl
movb %dl, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x115fc4
movq %r14, %rdi
movq %r15, %rsi
callq 0x115840
movq %rax, (%r12)
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_O3/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 0x117e4f
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x117e4e
movq 0x18(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x40(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0xa0494
movq (%rbx), %rax
movq 0x28(%rax), %rdi
callq 0xa0494
movq (%rbx), %rdi
callq 0x2220
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl 0x8(%rsi), %ecx
testl %ecx, %ecx
je 0x118299
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rax
xorl %esi, %esi
leaq (%rsi,%rsi,2), %rbp
cmpq $0x0, (%rax,%rbp,8)
je 0x11828f
movq %rsi, (%rsp)
movl $0x1, %r13d
xorl %ecx, %ecx
movq 0x10(%rax,%rbp,8), %rdi
shlq $0x6, %rcx
movl 0x28(%rdi,%rcx), %edx
cmpl 0x24(%rdi,%rcx), %edx
jb 0x11827b
addq %rcx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x117e50
movq (%r15), %rax
movl %r13d, %ecx
incl %r13d
cmpq %rcx, (%rax,%rbp,8)
ja 0x118254
movl 0x8(%r15), %ecx
movq (%rsp), %rsi
incq %rsi
movl %ecx, %edx
cmpq %rdx, %rsi
jb 0x11823d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, (%rsp)
movl %edx, %r15d
leaq (%rsi,%r15,4), %rsi
movq %rbx, %rdi
callq 0x10f575
testl %ebp, %ebp
je 0x118573
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
jne 0x118473
movl (%rbx,%rdi,4), %edi
jmp 0x11847b
movl (%rbx,%rdi,4), %edi
cmpl %edi, (%rbx,%rdx,4)
je 0x118484
movl %eax, %esi
incl %eax
movl %edi, (%rbx,%rsi,4)
movl %edx, %esi
incq %rdx
cmpq %rdx, %rcx
jne 0x118467
cmpl $0x2, %eax
jb 0x118573
movl %eax, %ecx
movl $0x1, %edx
xorl %esi, %esi
movq %rsi, %rdi
incq %rsi
cmpq %rcx, %rsi
jae 0x118567
movl (%rbx,%rdi,4), %edi
movq (%rsp), %r8
movq (%r8), %r8
leaq (%rdi,%rdi,2), %r9
leaq (%r8,%r9,8), %r9
movq (%r9), %r10
movq %rdx, %r11
movl (%rbx,%r11,4), %r15d
testq %r10, %r10
je 0x11850c
movq 0x10(%r9), %r12
movl $0x1, %ebp
xorl %r13d, %r13d
shlq $0x6, %r13
cmpl %edi, 0x24(%r12,%r13)
jne 0x1184ee
addq %r12, %r13
cmpl %r15d, 0x28(%r13)
je 0x1184fa
movl %ebp, %r13d
incl %ebp
cmpq %r13, %r10
ja 0x1184da
jmp 0x11850c
subl $0x1, %ebp
jb 0x11850c
movslq %ebp, %r14
shlq $0x6, %r14
movb $0x2, 0x2(%r12,%r14)
leaq (%r15,%r15,2), %r14
movq (%r8,%r14,8), %r13
testq %r13, %r13
je 0x11855b
leaq (%r8,%r14,8), %r14
movq 0x10(%r14), %r12
movl $0x1, %ebp
xorl %r14d, %r14d
shlq $0x6, %r14
cmpl %r15d, 0x24(%r12,%r14)
jne 0x11853d
addq %r12, %r14
cmpl %edi, 0x28(%r14)
je 0x118549
movl %ebp, %r14d
incl %ebp
cmpq %r14, %r13
ja 0x118529
jmp 0x11855b
subl $0x1, %ebp
jb 0x11855b
movslq %ebp, %r14
shlq $0x6, %r14
movb $0x2, 0x2(%r12,%r14)
incq %r11
cmpl %r11d, %eax
jne 0x1184c5
incq %rdx
cmpq %rcx, %rsi
jne 0x11849e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x118959
xorl %ebx, %ebx
jmp 0x1189a7
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_O3/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 0x118a47
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 0x118a14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x8(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
callq 0x118da3
movl $0x1, %edi
movl $0x20, %esi
callq 0x2120
movq %rax, %r14
movl (%rbx), %eax
movl %eax, (%r14)
movl 0x4(%rbx), %ebp
movl %ebp, 0x4(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
movslq %eax, %r12
movl $0x20, %esi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x18(%r14)
cmpl $0x1f, %ebp
je 0x118d5a
movq %rax, %r13
xorl %ebp, %ebp
xorl %r15d, %r15d
movl $0x1, %edi
movl $0x18, %esi
callq 0x2120
movq %rax, (%r13,%rbp,2)
movq 0x20(%rbx), %rcx
movq (%rcx,%rbp), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x11b8f6
incq %r15
addq $0x10, %rbp
cmpq %r12, %r15
jl 0x118d27
leaq 0x10(%rsp), %rdx
movq %rbx, (%rdx)
movq %r14, 0x8(%rdx)
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rdx)
leaq 0x9a(%rip), %rsi        # 0x118e0e
movl 0xc(%rsp), %edi
movq %r12, %rcx
callq 0x108f2c
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_O3/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:
movl 0x4(%rdi), %ecx
cmpl $0x1f, %ecx
je 0x118e0d
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%rax,%r15), %r14
testq %r14, %r14
je 0x118de4
movq 0x8(%r14), %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2220
movq 0x20(%rbx), %rax
movl 0x4(%rbx), %ecx
movq $0x0, (%rax,%r15)
movl $0x1, %edx
shll %cl, %edx
incq %r12
movslq %edx, %rdx
addq $0x10, %r15
cmpq %rdx, %r12
jl 0x118dc3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq 0x10(%r15), %rax
xorl %ebp, %ebp
leaq 0x14(%rsp), %r12
movl $0x0, %edx
testq %rax, %rax
je 0x118e6e
movb (%r15), %cl
movl $0x1, %edx
shll %cl, %edx
cmpl %edx, %ebp
je 0x118ed3
movq 0x8(%r15), %rcx
movl %ebp, %edx
shrl $0x5, %edx
movl (%rcx,%rdx,4), %ecx
btl %ebp, %ecx
jae 0x118ecf
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 0x11bb02
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), %rcx
andl $0xfff, %ecx            # imm = 0xFFF
addq %rdx, %rcx
movq %rcx, 0x8(%r13)
incl %ebp
jmp 0x118e5a
movq %r15, %rdi
callq 0x11bc0f
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_O3/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 $0x28, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
callq 0x118da3
movl $0x1, %edi
movl $0x20, %esi
callq 0x2120
movq %rax, %r14
movl (%rbx), %eax
movl %eax, (%r14)
movl 0x4(%rbx), %r13d
movl %r13d, 0x4(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movl $0x1, %eax
movl %r13d, %ecx
shll %cl, %eax
movslq %eax, %r15
movl $0x20, %esi
movq %r15, %rdi
callq 0x2120
movq %rax, 0x18(%r14)
cmpl $0x1f, %r13d
je 0x118fbe
movq %rax, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movl $0x1, %edi
movl $0x18, %esi
callq 0x2120
movq %rax, (%r12,%r13,2)
movq 0x20(%rbx), %rcx
movq (%rcx,%r13), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x11b8f6
incq %rbp
addq $0x10, %r13
cmpq %r15, %rbp
jl 0x118f8c
leaq 0x10(%rsp), %rdx
movq %rbx, (%rdx)
movq %r14, 0x8(%rdx)
leaq 0x2f(%rip), %rsi        # 0x119000
movl 0xc(%rsp), %edi
movq %r15, %rcx
callq 0x108f2c
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_O3/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)
movq 0x10(%r15), %rax
xorl %ebp, %ebp
leaq 0x14(%rsp), %r12
movl $0x0, %edx
testq %rax, %rax
je 0x119060
movb (%r15), %cl
movl $0x1, %edx
shll %cl, %edx
cmpl %edx, %ebp
je 0x1190c1
movq 0x8(%r15), %rcx
movl %ebp, %edx
shrl $0x5, %edx
movl (%rcx,%rdx,4), %ecx
btl %ebp, %ecx
jae 0x1190bd
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 0x11bb02
movq (%r13), %rcx
movq 0x10(%rcx), %rcx
movl %eax, %edx
shlq $0x4, %rdx
movq $0x0, 0x8(%rcx,%rdx)
movq 0x10(%r15), %rax
movq (%rax,%rbx,8), %rsi
andl $0xfff, %esi            # imm = 0xFFF
orq %rsi, (%rcx,%rdx)
incl %ebp
jmp 0x11904c
movq %r15, %rdi
callq 0x11bc0f
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
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_cnt_insert_list(ha_pt_s*, int, unsigned long const*)
int ha_pt_cnt_insert_list(ha_pt_t *h, int n, const uint64_t *a)
{
	int j, mask = (1<<h->pre) - 1, n_ins = 0;
	ha_pt1_t *g;
	if (n == 0) return 0;
	g = &h->h[a[0]&mask];
	for (j = 0; j < n; ++j) {
		uint64_t x = a[j] >> h->pre;
		khint_t k;
		assert((a[j]&mask) == (a[0]&mask));
		k = yak_pt_get(g->h, x<<YAK_COUNTER_BITS);
		if (k == kh_end(g->h)) continue; // TODO: understand why we sometimes come here
		++kh_val(g->h, k);
		++n_ins;
	}
	// fprintf(stderr, "n: %d, n_ins: %d\n", n, n_ins);
	return n_ins;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
testl %esi, %esi
je 0x1193cf
movl 0x4(%rdi), %ecx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rsp)
shll %cl, %r12d
testl %esi, %esi
jle 0x1193cf
movq %rdx, %rbx
notl %r12d
movl %r12d, %r13d
andl (%rdx), %r13d
shlq $0x5, %r13
addq 0x18(%rdi), %r13
movl %esi, %eax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
movq (%rbx,%r14,8), %rsi
movl (%rbx), %eax
xorl %esi, %eax
testl %r12d, %eax
jne 0x1193e0
movq 0x10(%rsp), %rcx
shrq %cl, %rsi
movq (%r13), %r15
shlq $0xc, %rsi
movq %r15, %rdi
callq 0x1192c4
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x1193b2
movb (%r15), %cl
movl $0x1, %esi
shll %cl, %esi
jmp 0x1193b4
xorl %esi, %esi
cmpl %esi, %eax
je 0x1193c5
movl %eax, %eax
shlq $0x4, %rax
incq 0x8(%rdx,%rax)
incl %ebp
incq %r14
cmpq %r14, 0x8(%rsp)
jne 0x119378
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1209ab(%rip), %rdi    # 0x239d92
leaq 0x120951(%rip), %rsi    # 0x239d3f
leaq 0x1209b8(%rip), %rcx    # 0x239dad
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_destroy(ha_pt_s*)
void ha_pt_destroy(ha_pt_t *h)
{
	int i;
	if (h == 0) return;
	for (i = 0; i < 1<<h->pre; ++i) {
		yak_pt_destroy(h->h[i].h);
		if(h->h[i].a){
			free(h->h[i].a); h->h[i].a = NULL;
		}
		if(h->h[i].al){
			free(h->h[i].al); h->h[i].al = NULL;
		}	
	}
	free(h->h); free(h);
}

// Assembly:
testq %rdi, %rdi
je 0x119495
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1f, 0x4(%rdi)
movq 0x18(%rdi), %rdi
je 0x119483
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rdi,%r14), %rdi
callq 0x119496
movq 0x18(%rbx), %rdi
movq 0x10(%rdi,%r14), %rax
testq %rax, %rax
je 0x11944c
movq %rax, %rdi
callq 0x2220
movq 0x18(%rbx), %rdi
movq $0x0, 0x10(%rdi,%r14)
movq 0x18(%rdi,%r14), %rax
testq %rax, %rax
je 0x11946b
movq %rax, %rdi
callq 0x2220
movq 0x18(%rbx), %rdi
movq $0x0, 0x18(%rdi,%r14)
movb 0x4(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
incq %r15
cltq
addq $0x20, %r14
cmpq %rax, %r15
jl 0x119420
callq 0x2220
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_get(ha_pt_s const*, unsigned long, int*)
const ha_idxpos_t *ha_pt_get(const ha_pt_t *h, uint64_t hash, int *n)
{
	khint_t k;
	const ha_pt1_t *g = &h->h[hash & ((1ULL<<h->pre) - 1)];
	*n = 0;
	k = yak_pt_get(g->h, hash >> h->pre << YAK_COUNTER_BITS);
	if (k == kh_end(g->h)) return 0;
	*n = kh_key(g->h, k) & YAK_MAX_COUNT;
	return &g->a[kh_val(g->h, k)];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movb 0x4(%rdi), %cl
movq $-0x1, %r12
shlq %cl, %r12
movq 0x18(%rdi), %r15
notq %r12
andq %rsi, %r12
shlq $0x5, %r12
movl $0x0, (%rdx)
movq (%r15,%r12), %r14
movb 0x4(%rdi), %cl
shrq %cl, %rsi
shlq $0xc, %rsi
movq %r14, %rdi
callq 0x1192c4
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x119512
movb (%r14), %cl
movl $0x1, %esi
shll %cl, %esi
jmp 0x119514
xorl %esi, %esi
cmpl %esi, %eax
jne 0x11951c
xorl %eax, %eax
jmp 0x11953c
addq %r12, %r15
movl %eax, %eax
shlq $0x4, %rax
movl $0xfff, %ecx            # imm = 0xFFF
andl (%rdx,%rax), %ecx
movl %ecx, (%rbx)
movq 0x8(%rdx,%rax), %rax
shlq $0x3, %rax
addq 0x10(%r15), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ptl_get(ha_pt_s const*, unsigned long, int*)
const ha_idxposl_t *ha_ptl_get(const ha_pt_t *h, uint64_t hash, int *n)
{
	khint_t k;
	const ha_pt1_t *g = &h->h[hash & ((1ULL<<h->pre) - 1)];
	*n = 0;
	k = yak_pt_get(g->h, hash >> h->pre << YAK_COUNTER_BITS);
	if (k == kh_end(g->h)) return 0;
	*n = kh_key(g->h, k) & YAK_MAX_COUNT;
	return &g->al[kh_val(g->h, k)];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movb 0x4(%rdi), %cl
movq $-0x1, %r12
shlq %cl, %r12
movq 0x18(%rdi), %r15
notq %r12
andq %rsi, %r12
shlq $0x5, %r12
movl $0x0, (%rdx)
movq (%r15,%r12), %r14
movb 0x4(%rdi), %cl
shrq %cl, %rsi
shlq $0xc, %rsi
movq %r14, %rdi
callq 0x1192c4
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x11959f
movb (%r14), %cl
movl $0x1, %esi
shll %cl, %esi
jmp 0x1195a1
xorl %esi, %esi
cmpl %esi, %eax
jne 0x1195a9
xorl %eax, %eax
jmp 0x1195c9
addq %r12, %r15
movl %eax, %eax
shlq $0x4, %rax
movl $0xfff, %ecx            # imm = 0xFFF
andl (%rdx,%rax), %ecx
movl %ecx, (%rbx)
movq 0x8(%rdx,%rax), %rax
shlq $0x4, %rax
addq 0x18(%r15), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_cnt(ha_pt_s const*, unsigned long)
const int ha_pt_cnt(const ha_pt_t *h, uint64_t hash)
{
	khint_t k;
	const ha_pt1_t *g = &h->h[hash & ((1ULL<<h->pre) - 1)];
	k = yak_pt_get(g->h, hash >> h->pre << YAK_COUNTER_BITS);
	if (k == kh_end(g->h)) return 0;
	return kh_key(g->h, k) & YAK_MAX_COUNT;
}

// Assembly:
pushq %rbx
movq 0x18(%rdi), %rax
movb 0x4(%rdi), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rsi, %rdx
shlq $0x5, %rdx
movq (%rax,%rdx), %rbx
shrq %cl, %rsi
shlq $0xc, %rsi
movq %rbx, %rdi
callq 0x1192c4
movl %eax, %edx
movq 0x10(%rbx), %rsi
xorl %eax, %eax
movl $0x0, %edi
testq %rsi, %rsi
je 0x11961f
movb (%rbx), %cl
movl $0x1, %edi
shll %cl, %edi
cmpl %edi, %edx
je 0x119631
movl %edx, %ecx
shlq $0x4, %rcx
movl $0xfff, %eax            # imm = 0xFFF
andl (%rsi,%rcx), %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: debug_ct_index(void*, void*)
void debug_ct_index(void* q_ct_idx, void* r_ct_idx)
{
	ha_ct_t* ct_idx = (ha_ct_t*)q_ct_idx;
	yak_ct_t *g = NULL;
	uint64_t i;
	khint_t k;
	for (i = 0; (int)i < 1<<ct_idx->pre; i++)
	{
		g = ct_idx->h[i].h;
		for (k = 0; k < kh_end(g); ++k) 
		{
			if (kh_exist(g, k)) 
			{
				int c = kh_key(g, k) & YAK_MAX_COUNT;
				uint64_t hash = ((kh_key(g, k) >> ct_idx->pre)<<ct_idx->pre) | i;
				int q = query_ct_index(r_ct_idx, hash);
				if(q!=c)
				{
					fprintf(stderr, "ERROR:c: %d, q: %d\n", c, q);
				}
			}
		}
	}
}

// Assembly:
cmpl $0x1f, 0x4(%rdi)
je 0x11a5de
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movq 0x20(%r14), %rax
movq %r13, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r12
xorl %r15d, %r15d
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x11a555
movb (%r12), %cl
movl $0x1, %edx
shlq %cl, %rdx
jmp 0x11a557
xorl %edx, %edx
cmpq %rdx, %r15
jae 0x11a5b9
movq 0x8(%r12), %rcx
movq %r15, %rdx
shrq $0x5, %rdx
movl (%rcx,%rdx,4), %ecx
btl %r15d, %ecx
jae 0x11a596
movq (%rax,%r15,8), %rsi
movl %esi, %ebp
andl $0xfff, %ebp            # imm = 0xFFF
movb 0x4(%r14), %cl
shrq %cl, %rsi
shlq %cl, %rsi
orq %r13, %rsi
movq %rbx, %rdi
callq 0x11a5df
cmpl %ebp, %eax
jne 0x11a59b
incq %r15
jmp 0x11a53d
movq 0x17aa3e(%rip), %rcx    # 0x294fe0
movq (%rcx), %rdi
leaq 0x11f9de(%rip), %rsi    # 0x239f8a
movl %ebp, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x22b0
jmp 0x11a596
incq %r13
movb 0x4(%r14), %cl
movl $0x1, %eax
shll %cl, %eax
cmpl %r13d, %eax
jg 0x11a52b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: query_ct_index(void*, unsigned long)
int query_ct_index(void* ct_idx, uint64_t hash)
{
	ha_ct1_t *g = &(((ha_ct_t*)ct_idx)->h[hash & ((1ULL<<((ha_ct_t*)ct_idx)->pre) - 1)]);
	khint_t k;
	k = yak_ct_get(g->h, hash);
	if (k == kh_end(g->h)) return 0;
	return ((kh_key(g->h, k)&YAK_MAX_COUNT)==YAK_MAX_COUNT)?-1:(kh_key(g->h, k)&YAK_MAX_COUNT);
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rax
movb 0x4(%rdi), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rsi, %rdx
shlq $0x4, %rdx
movq (%rax,%rdx), %rbx
movq %rbx, %rdi
callq 0x11acf5
movl %eax, %edx
movq 0x10(%rbx), %rsi
xorl %eax, %eax
movl $0x0, %edi
testq %rsi, %rsi
je 0x11a622
movb (%rbx), %cl
movl $0x1, %edi
shll %cl, %edi
cmpl %edi, %edx
je 0x11a63f
movl %edx, %eax
movl $0xfff, %ecx            # imm = 0xFFF
movq (%rsi,%rax,8), %rdx
andq %rcx, %rdx
cmpq %rcx, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %edx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_destroy(ha_ct_t*)
static void ha_ct_destroy(ha_ct_t *h)
{
	int i;
	if (h == 0) return;
	ha_ct_destroy_bf(h);
	for (i = 0; i < 1<<h->pre; ++i)
		yak_ct_destroy(h->h[i].h);
	free(h->h); free(h);
}

// Assembly:
testq %rdi, %rdi
je 0x11a87c
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x118da3
cmpl $0x1f, 0x4(%rbx)
je 0x11a866
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x11bc0f
movb 0x4(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
incq %r15
cltq
addq $0x10, %r14
cmpq %rax, %r15
jl 0x11a841
movq 0x20(%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_hist(ha_ct_t const*, long*, int)
static void ha_ct_hist(const ha_ct_t *h, int64_t cnt[YAK_N_COUNTS], int n_thread)
{
	hist_aux_t a;
	int i, j;
	a.h = h;
	memset(cnt, 0, YAK_N_COUNTS * sizeof(uint64_t));
	CALLOC(a.cnt, n_thread);
	///start 4096 threads
	kt_for(n_thread, worker_ct_hist, &a, 1<<h->pre);
	for (i = 0; i < YAK_N_COUNTS; ++i) cnt[i] = 0;
	for (j = 0; j < n_thread; ++j)
		for (i = 0; i < YAK_N_COUNTS; ++i)
			cnt[i] += a.cnt[j].c[i];
	free(a.cnt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movq %rsp, %r14
movq %rdi, (%r14)
movl $0x8000, %edx           # imm = 0x8000
movq %rsi, %rdi
xorl %esi, %esi
callq 0x20e0
movslq %ebp, %r15
movl $0x8000, %esi           # imm = 0x8000
movq %r15, %rdi
callq 0x2120
movq %rax, 0x8(%r14)
movb 0x4(%r12), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
leaq 0x3e0c(%rip), %rsi      # 0x11e908
movl %r15d, %edi
movq %r14, %rdx
callq 0x108f2c
movl $0x8000, %edx           # imm = 0x8000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20e0
movq 0x8(%r14), %rdi
testl %r15d, %r15d
jle 0x11ab4b
movl %ebp, %eax
xorl %ecx, %ecx
movq %rdi, %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
addq %r8, (%rbx,%rsi,8)
incq %rsi
cmpq $0x1000, %rsi           # imm = 0x1000
jne 0x11ab28
incq %rcx
addq $0x8000, %rdx           # imm = 0x8000
cmpq %rax, %rcx
jne 0x11ab26
callq 0x2220
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: load_ct_index(void**, char*)
int load_ct_index(void **i_ct_idx, char* file_name)
{
	char* gfa_name = (char*)malloc(strlen(file_name)+25);
    sprintf(gfa_name, "%s.ct_flt", file_name);
    FILE* fp = fopen(gfa_name, "r");
	if (!fp) {
		free(gfa_name);
        return 0;
    }
	ha_ct_t** ct_idx = (ha_ct_t**)i_ct_idx;
	double index_time = 0;
	uint64_t flag = 0;
	int i;
	ha_ct_t *h = 0;
	ha_ct1_t *g;
	CALLOC(h, 1);

	flag += fread(&h->k, sizeof(h->k), 1, fp);
	flag += fread(&h->pre, sizeof(h->pre), 1, fp);
	flag += fread(&h->n_hash, sizeof(h->n_hash), 1, fp);
	flag += fread(&h->n_shift, sizeof(h->n_shift), 1, fp);
	flag += fread(&h->tot, sizeof(h->tot), 1, fp);
	CALLOC(h->h, 1<<h->pre);


	index_time = yak_realtime();
	for (i = 0; i < 1<<h->pre; ++i) 
	{
		g = &(h->h[i]);
		yak_ct_load(&(g->h), fp);
	}

	(*ct_idx) = h;
	fprintf(stderr, "[M::%s::%.3f] ==> Loaded count table\n", __func__, yak_realtime() - index_time);
	fprintf(stderr, "[M::%s] Index has been loaded.\n", __func__);
	free(gfa_name);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %r14
leaq 0x11f4f8(%rip), %rsi    # 0x23a278
xorl %ebp, %ebp
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x124a61(%rip), %rsi    # 0x23f7f7
movq %r14, %rdi
callq 0x2210
testq %rax, %rax
jne 0x11adb8
movq %r14, %rdi
callq 0x2220
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1411a
movl $0x1, %ebp
jmp 0x11ada3
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: uidx_write(void*, ha_pt_s*, char*, ma_ug_t*)
int uidx_write(void *flt_tab, ha_pt_t *ha_idx, char* file_name, ma_ug_t *ug)
{
	char* gfa_name = (char*)malloc(strlen(file_name)+25);
    sprintf(gfa_name, "%s.uidx.bin", file_name);
    FILE* fp = fopen(gfa_name, "w");
    if (!fp) {
        free(gfa_name);
        return 0;
    }

	if(ug) write_dbug(ug, fp);

	yak_ft_t *ha_flt_tab = (yak_ft_t*)flt_tab;

    if(ha_flt_tab)
    {
        fwrite("f", 1, 1, fp);
        yak_ft_save(ha_flt_tab, fp);
    }

	if(ha_idx)
    {
        int i;
        ha_pt1_t *g;
        fwrite("h", 1, 1, fp);
        fwrite(&ha_idx->k, sizeof(ha_idx->k), 1, fp);
        fwrite(&ha_idx->pre, sizeof(ha_idx->pre), 1, fp);
        fwrite(&ha_idx->tot, sizeof(ha_idx->tot), 1, fp);
        fwrite(&ha_idx->tot_pos, sizeof(ha_idx->tot_pos), 1, fp);

        for (i = 0; i < 1<<ha_idx->pre; ++i) 
        {
            g = &(ha_idx->h[i]);
            yak_pt_save(g->h, fp);
            fwrite(&g->n, sizeof(g->n), 1, fp);
            fwrite(g->al, sizeof(ha_idxposl_t), g->n, fp);
        }
    }
	fprintf(stderr, "[M::%s] Index has been written.\n", __func__);
    free(gfa_name);
    fclose(fp);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq %rdx, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x11ed59(%rip), %rsi    # 0x23a3bc
xorl %ebp, %ebp
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x12d069(%rip), %rsi    # 0x2486e2
movq %rbx, %rdi
callq 0x2210
testq %rax, %rax
jne 0x11b69f
movq %rbx, %rdi
callq 0x2220
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
testq %r13, %r13
je 0x11b6b2
movq %r13, %rdi
movq %r15, %rsi
callq 0xc3874
testq %r12, %r12
je 0x11b6cf
movl $0x66, %edi
movq %r15, %rsi
callq 0x2270
movq %r12, %rdi
movq %r15, %rsi
callq 0x11b016
testq %r14, %r14
je 0x11b7a5
movl $0x68, %edi
movq %r15, %rsi
callq 0x2270
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rcx
callq 0x2410
leaq 0x4(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
leaq 0x8(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
leaq 0x10(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
cmpl $0x1f, 0x4(%r14)
je 0x11b7a5
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x18(%r14), %rax
leaq (%rax,%r13), %r12
addq $0x8, %r12
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x11b0ff
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x2410
movq (%r12), %rdx
movq 0x10(%r12), %rdi
movl $0x10, %esi
movq %r15, %rcx
callq 0x2410
movb 0x4(%r14), %cl
movl $0x1, %eax
shll %cl, %eax
incq %rbp
cltq
addq $0x20, %r13
cmpq %rax, %rbp
jl 0x11b748
movq 0x179834(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x11eacc(%rip), %rsi    # 0x23a282
leaq 0x11ec0b(%rip), %rdx    # 0x23a3c8
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2190
movl $0x1, %ebp
jmp 0x11b68e
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: worker_ct_shrink(void*, long, int)
static void worker_ct_shrink(void *data, long i, int tid) // callback for kt_for()
{
	shrink_aux_t *a = (shrink_aux_t*)data;
	ha_ct_t *h = a->h;
	yak_ct_t *g = h->h[i].h, *f;
	khint_t k;
	f = yak_ct_init();
	yak_ct_resize(f, kh_size(g));
	for (k = 0; k < kh_end(g); ++k) {
		if (kh_exist(g, k)) {
			int absent, c = kh_key(g, k) & YAK_MAX_COUNT;
			if (c >= a->min && c <= a->max)
				yak_ct_put(f, kh_key(g, k), &absent);
		}
	}
	yak_ct_destroy(g);
	h->h[i].h = f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rax), %rax
shlq $0x4, %rbx
movq (%rax,%rbx), %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x2120
movq %rax, %r12
movl 0x4(%r15), %esi
movq %rax, %rdi
callq 0x11e2d5
xorl %ebp, %ebp
leaq 0x14(%rsp), %r13
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x11e69e
movb (%r15), %cl
movl $0x1, %edx
shlq %cl, %rdx
jmp 0x11e6a0
xorl %edx, %edx
cmpq %rdx, %rbp
jae 0x11e6de
movq 0x8(%r15), %rcx
movq %rbp, %rdx
shrq $0x5, %rdx
movl (%rcx,%rdx,4), %ecx
btl %ebp, %ecx
jae 0x11e6d9
movq (%rax,%rbp,8), %rsi
movl %esi, %eax
andl $0xfff, %eax            # imm = 0xFFF
cmpl (%r14), %eax
jl 0x11e6d9
cmpl 0x4(%r14), %eax
jg 0x11e6d9
movq %r12, %rdi
movq %r13, %rdx
callq 0x11e1d0
incq %rbp
jmp 0x11e688
movq %r15, %rdi
callq 0x11bc0f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %r12, (%rax,%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: worker_ct_hist(void*, long, int)
static void worker_ct_hist(void *data, long i, int tid) // callback for kt_for()
{
	hist_aux_t *a = (hist_aux_t*)data;
	uint64_t *cnt = a->cnt[tid].c;
	yak_ct_t *g = a->h->h[i].h;
	khint_t k;
	for (k = 0; k < kh_end(g); ++k)
		if (kh_exist(g, k))
			++cnt[kh_key(g, k)&YAK_MAX_COUNT];
}

// Assembly:
movslq %edx, %rax
shlq $0xf, %rax
addq 0x8(%rdi), %rax
movq (%rdi), %rcx
movq 0x20(%rcx), %rcx
shlq $0x4, %rsi
movq (%rcx,%rsi), %rdx
movq 0x10(%rdx), %rsi
xorl %edi, %edi
movl $0xfff, %r8d            # imm = 0xFFF
testq %rsi, %rsi
je 0x11e940
movb (%rdx), %cl
movl $0x1, %r9d
shlq %cl, %r9
jmp 0x11e943
xorl %r9d, %r9d
cmpq %r9, %rdi
jae 0x11e96b
movq 0x8(%rdx), %rcx
movq %rdi, %r9
shrq $0x5, %r9
movl (%rcx,%r9,4), %ecx
btl %edi, %ecx
jae 0x11e966
movl (%rsi,%rdi,8), %ecx
andl %r8d, %ecx
incq (%rax,%rcx,8)
incq %rdi
jmp 0x11e92e
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hist.cpp
// Function: adj_m_peak_hom(int, int, int, int, int*)
int adj_m_peak_hom(int m_peak_hom, int max_i, int max2_i, int max3_i, int *peak_het)
{
	int64_t mm[3], d, min_i, min_d, i;
	mm[0] = max2_i; mm[1] = max_i; mm[2] = max3_i;
	for (i = 0, min_i = -1, min_d = -1; i < 3; i++){
		if(mm[i] <= 0) continue;
		d = (mm[i] >= m_peak_hom?mm[i]-m_peak_hom:m_peak_hom-mm[i]);
		if(min_d == -1 || min_d > d || (min_d == d && i == 1)){
			min_d = d; min_i = i;
		}
	}
	if(min_i < 0) return m_peak_hom;
	if(mm[min_i] < m_peak_hom){
		d = m_peak_hom - mm[min_i];
		if(d >= mm[min_i]*0.51) {
			*peak_het = mm[min_i];
			return m_peak_hom;
		}
	}

	for (i = min_i-1; i >= 0; i--){
		if(mm[i] <= 0) continue;
		*peak_het = mm[i];
		break;
	}
	return mm[min_i];
}

// Assembly:
movl %edi, %eax
movslq %edx, %rdx
movq %rdx, -0x18(%rsp)
movslq %esi, %rdx
movq %rdx, -0x10(%rsp)
movslq %ecx, %rcx
movq %rcx, -0x8(%rsp)
movslq %edi, %rdx
movq $-0x1, %rdi
xorl %esi, %esi
movq $-0x1, %rcx
movq -0x18(%rsp,%rsi,8), %r10
testq %r10, %r10
jle 0x11eb0f
subq %rdx, %r10
movq %r10, %r9
negq %r9
cmovsq %r10, %r9
cmpq $-0x1, %rdi
sete %r10b
cmpq %r9, %rdi
setg %r11b
orb %r10b, %r11b
jne 0x11eb09
cmpq $0x1, %rsi
jne 0x11eb0f
cmpq %r9, %rdi
jne 0x11eb0f
movq %rsi, %rcx
movq %r9, %rdi
incq %rsi
cmpq $0x3, %rsi
jne 0x11ead3
testq %rcx, %rcx
js 0x11eb56
movq -0x18(%rsp,%rcx,8), %rsi
subq %rsi, %rdx
jle 0x11eb3f
cvtsi2sd %rdx, %xmm0
cvtsi2sd %rsi, %xmm1
mulsd 0x112b0f(%rip), %xmm1   # 0x231648
ucomisd %xmm1, %xmm0
jae 0x11eb57
testq %rcx, %rcx
jle 0x11eb54
movq -0x20(%rsp,%rcx,8), %rax
decq %rcx
testq %rax, %rax
jle 0x11eb3f
movl %eax, (%r8)
movl %esi, %eax
retq
movl %esi, (%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/anchor.cpp
// Function: lable_matched_ovlp(overlap_region_alloc*, ma_hit_t_alloc*)
void lable_matched_ovlp(overlap_region_alloc* overlap_list, ma_hit_t_alloc* paf)
{
	uint64_t j = 0, inner_j = 0;
	while (j < overlap_list->length && inner_j < paf->length)
    {
        if(overlap_list->list[j].y_id < paf->buffer[inner_j].tn)
        {
            j++;
        }
        else if(overlap_list->list[j].y_id > paf->buffer[inner_j].tn)
        {
            inner_j++;
        }
        else
        {
            if(overlap_list->list[j].y_pos_strand == paf->buffer[inner_j].rev)
            {
				overlap_list->list[j].is_match = 1;
            }
            j++;
            inner_j++;
        }
    }
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x12a539
pushq %rbp
pushq %r14
pushq %rbx
movl 0xc(%rsi), %ecx
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %rcx, %rdx
jae 0x12a535
movq (%rdi), %rbx
imulq $0xa8, %r8, %r14
leaq (%rbx,%r14), %r9
movq (%rsi), %r10
leaq (%rdx,%rdx,4), %r11
movl 0xc(%r10,%r11,8), %ebp
cmpl %ebp, 0x10(%rbx,%r14)
jae 0x12a511
incq %r8
jmp 0x12a530
ja 0x12a52d
leaq (%r10,%r11,8), %r10
movl 0x18(%r10), %r10d
shrl $0x1f, %r10d
cmpl %r10d, 0x1c(%r9)
jne 0x12a52a
movb $0x1, 0x2c(%r9)
incq %r8
incq %rdx
cmpq %rax, %r8
jb 0x12a4e6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/anchor.cpp
// Function: ha_get_ul_candidates_interface(ha_abufl_s*, long, char*, unsigned long, unsigned long, unsigned long, ul_idx_t const*, overlap_region_alloc*, overlap_region_alloc*, Candidates_list*, double, int, int, kvec_t_u8_warp*, kvec_t_u64_warp*, overlap_region*, kvec_t_u64_warp*, st_mt_t*, unsigned int, void*)
void ha_get_ul_candidates_interface(ha_abufl_t *ab, int64_t rid, char* rs, uint64_t rl, uint64_t mz_w, uint64_t mz_k, const ul_idx_t *uref, overlap_region_alloc *overlap_list, overlap_region_alloc *overlap_list_hp, Candidates_list *cl, double bw_thres, 
								 int max_n_chain, int keep_whole_chain, kvec_t_u8_warp* k_flag, kvec_t_u64_warp* chain_idx, overlap_region* f_cigar, kvec_t_u64_warp* dbg_ct, st_mt_t *sp, uint32_t high_occ, void *km)
{
	extern void *ha_flt_tab;
	extern ha_pt_t *ha_idx;

	ha_get_new_ul_candidates(ab, rid, rs, rl, mz_w, mz_k, uref, overlap_list, cl, bw_thres, max_n_chain, keep_whole_chain, k_flag, chain_idx, ha_flt_tab, ha_idx, f_cigar, dbg_ct, sp, high_occ, km);
	if(km) {
		ha_abufl_free_buf(km, ab, 1); 
		destory_Candidates_list_buf(km, cl, 1); 
	}
	ks_introsort_or_xs(overlap_list->length, overlap_list->list);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x70(%rsp)
movq 0x110(%rsp), %r14
movq 0xc8(%rsp), %r15
movq 0xb8(%rsp), %r12
movq 0xb0(%rsp), %rcx
movl 0xd0(%rsp), %eax
movl 0xd8(%rsp), %r10d
movaps 0xe0(%rsp), %xmm1
movaps 0xf0(%rsp), %xmm2
movq 0x100(%rsp), %r11
leaq 0x16ba5b(%rip), %r13    # 0x296430
movq (%r13), %r13
leaq 0x16ba58(%rip), %rbp    # 0x296438
movq (%rbp), %rbp
movl 0x108(%rsp), %ebx
movl %ebx, 0x60(%rsp)
movq %r15, %rbx
movq %rdi, %r15
movq %r11, 0x58(%rsp)
movq %r14, 0x68(%rsp)
movups %xmm2, 0x48(%rsp)
movq %rbp, 0x40(%rsp)
movq %r13, 0x38(%rsp)
movups %xmm1, 0x28(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x18(%rsp)
movq %rcx, (%rsp)
movq %rbx, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movq 0x70(%rsp), %rcx
callq 0x129150
testq %r14, %r14
je 0x12aa59
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x128963
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3f1e1
movq (%r12), %rsi
movq 0x10(%r12), %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x126994