LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: print_debug_rGraph(min_cut_t*)
void print_debug_rGraph(min_cut_t* x)
{
    fprintf(stderr, "******rGraph******\n");
    uint64_t i, j, u;
    for (i = 0; i < x->rGraphVis.n; i++)
    {
        if(!x->bmerVis.a[i]) continue;
        for (j = 0; j < x->rGraph.a[i].n; j++)
        {
            if(x->rGraph.a[i].a[j].del) continue;
            u = x->rGraph.a[i].a[j].uID;
            if(!x->bmerVis.a[u]) continue;
            fprintf(stderr, "***utg%.6lul\tutg%.6lul\t%f\n", i+1, u+1, x->rGraph.a[i].a[j].weight);    
        }
    }
    fprintf(stderr, "******rGraph******\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x27f312(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x225d80(%rip), %rdi    # 0x23ba58
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
movq 0xb0(%rbx), %rcx
testq %rcx, %rcx
je 0x15d88
xorl %r13d, %r13d
movq 0xf0(%rbx), %rax
cmpb $0x0, (%rax,%r13)
je 0x15d7c
movq 0x10(%rbx), %rax
imulq $0x18, %r13, %rbp
cmpq $0x0, (%rax,%rbp)
je 0x15d7c
leaq 0x1(%r13), %r15
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x10(%rax,%rbp), %rdx
cmpb $0x0, 0x18(%rdx,%r12)
js 0x15d3c
movl 0x8(%rdx,%r12), %ecx
movq 0xf0(%rbx), %rsi
cmpb $0x0, (%rsi,%rcx)
jne 0x15d4b
incq %r14
addq $0x28, %r12
cmpq (%rax,%rbp), %r14
jb 0x15d1d
jmp 0x15d75
movq 0x27f28e(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
incq %rcx
movsd (%rdx,%r12), %xmm0
leaq 0x225d07(%rip), %rsi    # 0x23ba6c
movq %r15, %rdx
movb $0x1, %al
callq 0x22b0
movq 0x10(%rbx), %rax
jmp 0x15d3c
movq 0xb0(%rbx), %rcx
incq %r13
cmpq %rcx, %r13
jb 0x15cf6
movq 0x27f251(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x225cbf(%rip), %rdi    # 0x23ba58
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2410
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: check_connective(min_cut_t*, hc_links*)
void check_connective(min_cut_t* x, hc_links* link)
{
    double index_time = yak_realtime();
    kvec_t_u64_warp buff;
    kv_init(buff.a);
    uint64_t i, k, uID;
    for (i = 0; i < x->n; i++)
    {
        uID = x->order.a[i] & x->uID_mode;
        if(link->a.a[uID].f.n == 0) continue;
        for (k = 0; k < link->a.a[uID].f.n; k++)
        {
            if(link->a.a[uID].f.a[k].del) continue;
            if(x->utgVis.a[link->a.a[uID].f.a[k].uID] == 0) break;
        }
        if(k == link->a.a[uID].f.n) continue;
        reset_min_cut_t(x, link);
        get_s_t(x, link, uID, &(x->src), &(x->dest), &buff);

        bfs_flow(x->src, x->dest, x, NULL);

        x->utgVis.a[uID] = 1;
    }

    //reset x.utgVis
    memset(x->utgVis.a, 0, x->utgVis.n);
    kv_destroy(buff.a);
    fprintf(stderr, "[M::%s::%.3f] \n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1365ef
movsd %xmm0, 0x8(%rsp)
andq $0x0, 0x20(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x148(%rbx), %rax
testq %rax, %rax
jne 0x15df5
xorl %r14d, %r14d
jmp 0x15ebe
leaq 0x150(%rbx), %r15
leaq 0x158(%rbx), %r12
xorl %r13d, %r13d
movq 0x28(%rbx), %rcx
movq 0x138(%rbx), %rbp
andq (%rcx,%r13,8), %rbp
movq 0x10(%r14), %rdx
imulq $0x30, %rbp, %rsi
movq 0x18(%rdx,%rsi), %rcx
testq %rcx, %rcx
je 0x15ead
addq %rsi, %rdx
addq $0x18, %rdx
movq 0x10(%rdx), %rdx
addq $0x18, %rdx
cmpb $0x0, (%rdx)
js 0x15e4f
movq 0xd8(%rbx), %rsi
movl -0x10(%rdx), %edi
cmpb $0x0, (%rsi,%rdi)
je 0x15e5a
addq $0x28, %rdx
decq %rcx
jne 0x15e3a
jmp 0x15ead
testq %rcx, %rcx
je 0x15ead
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1475f3
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r12, %r8
leaq 0x10(%rsp), %r9
callq 0x147b18
movq 0x150(%rbx), %rdi
movq 0x158(%rbx), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x147c19
movq 0xd8(%rbx), %rax
movb $0x1, (%rax,%rbp)
movq 0x148(%rbx), %rax
incq %r13
cmpq %rax, %r13
jb 0x15e06
movq 0x20(%rsp), %r14
movq 0xc8(%rbx), %rdx
movq 0xd8(%rbx), %rdi
xorl %esi, %esi
callq 0x20e0
movq %r14, %rdi
callq 0x2220
movq 0x27f0fe(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd 0x8(%rsp), %xmm0
leaq 0x225ba3(%rip), %rsi    # 0x23ba9a
leaq 0x225bac(%rip), %rdx    # 0x23baaa
movq %rbx, %rdi
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: get_Connected_Components(min_cut_t*)
void get_Connected_Components(min_cut_t* x)
{
    double index_time = yak_realtime();
    uint64_t i, j, k = 0, uID, e;
    kvec_t_u64_warp buff;
    kv_init(buff.a);
    while (1)
    {
        for (i = 0; i < x->n; i++)
        {
            uID = x->order.a[i] & x->uID_mode;
            if(x->rGraphVis.a[uID] == 0) break;
        }
        if(i < x->n)
        {
            e = buff.a.n = 0;
            bfs_flow(uID, (uint64_t)-1, x, &buff);
            for (i = 0; i < buff.a.n; i++)
            {
                for (j = 0; j < x->rGraph.a[buff.a.a[i]].n; j++)
                {
                    if(x->rGraph.a[buff.a.a[i]].a[j].del == 0) e++;
                }
            }
            e >>= 1;
            if(buff.a.n > 1)
            {
                fprintf(stderr, "(%lu) Component: # nodes: %lu, # edges: %lu\n", 
                                                                k, (uint64_t)buff.a.n, e);
            }
            k++;
        }
        else
        {
            break;
        }
    }

    kv_destroy(buff.a);
    fprintf(stderr, "[M::%s::%.3f] # Connected Components: %lu\n", 
    __func__, yak_realtime()-index_time, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
callq 0x1365ef
andq $0x0, 0x20(%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x148(%r14), %rax
testq %rax, %rax
movsd %xmm0, 0x8(%rsp)
jne 0x15f97
xorl %ebx, %ebx
movq 0x20(%rsp), %rdi
callq 0x2220
movq 0x27f081(%rip), %rax    # 0x294fe0
movq (%rax), %r14
callq 0x1365ef
subsd 0x8(%rsp), %xmm0
leaq 0x225b74(%rip), %rsi    # 0x23bae8
leaq 0x225b98(%rip), %rdx    # 0x23bb13
movq %r14, %rdi
movq %rbx, %rcx
movb $0x1, %al
callq 0x22b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %r15
leaq 0x10(%rsp), %r12
movq 0x27f039(%rip), %rbp    # 0x294fe0
leaq 0x225b0d(%rip), %r13    # 0x23babb
xorl %ebx, %ebx
movq 0x28(%r14), %rcx
movq 0xc0(%r14), %rdx
movq 0x138(%r14), %rsi
xorl %r8d, %r8d
movq (%rcx,%r8,8), %rdi
andq %rsi, %rdi
cmpb $0x0, (%rdx,%rdi)
je 0x15fdf
incq %r8
cmpq %r8, %rax
jne 0x15fc5
jmp 0x15f4e
andq $0x0, 0x10(%rsp)
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x147c19
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0x16049
movq 0x10(%r14), %rax
movq 0x20(%rsp), %rdx
xorl %r8d, %r8d
xorl %esi, %esi
imulq $0x18, (%rdx,%rsi,8), %r9
movq (%rax,%r9), %rdi
testq %rdi, %rdi
je 0x1603b
addq %rax, %r9
movq 0x10(%r9), %r9
addq $0x18, %r9
xorl %r10d, %r10d
cmpb $0x0, (%r9)
setns %r10b
addq %r10, %r8
addq $0x28, %r9
decq %rdi
jne 0x16024
incq %rsi
cmpq %rcx, %rsi
jne 0x1600b
cmpq $0x1, %rcx
jne 0x16061
incq %rbx
movq 0x148(%r14), %rax
testq %rax, %rax
jne 0x15fb0
jmp 0x15f4e
shrq %r8
movq (%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x16049
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: clean_bubbles(hc_links*, bubble_type*, min_cut_t*, ma_ug_t const*)
G_partition* clean_bubbles(hc_links* link, bubble_type* bub, min_cut_t* m, const ma_ug_t *ug)
{
    double index_time = yak_realtime();
    uint64_t i;
    bub_p_t_warp b; 
    memset(&b, 0, sizeof(bub_p_t_warp));
    CALLOC(b.a, ug->g->n_seq*2); 
    uint8_t* flag = NULL;
    CALLOC(flag, ug->g->n_seq);
    G_partition* x; CALLOC(x, 1);
    init_G_partition(x, ug->g->n_seq);

    for (i = 0; i < bub->f_bub; i++)
    {
        phase_bubble(i, &b, bub, flag, ug, m, link, x);
    }

    free(b.a); free(b.S.a); free(b.T.a); free(b.b.a); free(b.e.a);
    free(flag);
    fprintf(stderr, "[M::%s::%.3f]\n", __func__, yak_realtime()-index_time);
    ///print_phased_bubble(x, bub, ug->g->n_seq);

    return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r12
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, 0x18(%rsp)
callq 0x1365ef
movsd %xmm0, 0x20(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x80(%rsp)
movupd %xmm0, 0x70(%rsp)
movupd %xmm0, 0x60(%rsp)
movupd %xmm0, 0x50(%rsp)
movupd %xmm0, 0x40(%rsp)
andq $0x0, 0x90(%rsp)
movupd %xmm0, 0x30(%rsp)
movq 0x18(%r12), %rax
movl 0x14(%rax), %ebp
leal (,%rbp,2), %edi
pushq $0x38
popq %rsi
callq 0x2120
movq %rax, (%rsp)
movq %rax, 0x28(%rsp)
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
pushq $0x1
popq %rbx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2120
movq %rax, %r15
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x2120
movq %rax, %r14
leaq (,%rbp,4), %rbx
movq %rbx, %rdi
callq 0x2280
movq %rax, 0x18(%r14)
testq %rbp, %rbp
je 0x1630f
movq %rax, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x20e0
movq %r15, 0x8(%rsp)
cmpq $0x0, 0x80(%r13)
jne 0x1632f
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebx, %ebx
movq (%rsp), %rdi
jmp 0x16393
xorl %ebx, %ebx
movq %r14, (%rsp)
movq 0x10(%rsp), %rbp
movq %r12, %r14
movq 0x8(%rsp), %r12
movq 0x18(%rsp), %r15
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
movq %rbp, %r9
pushq (%rsp)
pushq %r15
callq 0x149dfc
popq %rax
popq %rcx
incq %rbx
cmpq 0x80(%r13), %rbx
jb 0x16347
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rbx
movq 0x58(%rsp), %r13
movq 0x70(%rsp), %r12
movq 0x88(%rsp), %r15
movq (%rsp), %r14
callq 0x2220
movq %rbx, %rdi
callq 0x2220
movq %r13, %rdi
callq 0x2220
movq %r12, %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2220
movq 0x8(%rsp), %rdi
callq 0x2220
movq 0x27ec17(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd 0x20(%rsp), %xmm0
leaq 0x22580d(%rip), %rsi    # 0x23bbeb
leaq 0x225815(%rip), %rdx    # 0x23bbfa
movq %rbx, %rdi
movb $0x1, %al
callq 0x22b0
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: print_b_utg_occ(bubble_type*, unsigned int)
uint32_t print_b_utg_occ(bubble_type* bub, uint32_t v)
{
    ma_ug_t *bub_ug = bub->b_ug;
    ma_utg_t *u = NULL;
    uint32_t k_i, k_j, *a = NULL, n, tan_occ = 0, beg, sink;

    
    u = &(bub_ug->u.a[v]);
    fprintf(stderr, "\nstart: %u-th bubble-utg-start (# bubbles: %u)\n", v, (uint32_t)u->n);
    for (k_i = 0; k_i < u->n; k_i++)
    {
        get_bubbles(bub, u->a[k_i]>>33, &beg, &sink, &a, &n, NULL);
        for (k_j = 0; k_j < n; k_j++)
        {
            tan_occ += bub->ug->u.a[a[k_j]>>1].n;
        }

        fprintf(stderr, "bid: %lu, n: %u, beg-utg%.6dl(%u), sink-utg%.6dl(%u)\n", u->a[k_i]>>33, n, (beg>>1)+1, beg&1, (sink>>1)+1, sink&1);
    }

    fprintf(stderr, "end: %u-th bubble-utg-end\n\n", v);
    return tan_occ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %edx
movq %rdi, %r14
movq 0xc0(%rdi), %rax
movq 0x10(%rax), %r12
movl %esi, %eax
imulq $0x28, %rax, %rbx
movq 0x27e8f4(%rip), %r13    # 0x294fe0
movq (%r13), %rdi
movl 0x10(%r12,%rbx), %ecx
leaq 0x225775(%rip), %rsi    # 0x23be71
xorl %ebp, %ebp
movl %edx, 0x4(%rsp)
xorl %eax, %eax
callq 0x22b0
cmpl $0x0, 0x10(%r12,%rbx)
je 0x167bb
addq %rbx, %r12
leaq 0x225782(%rip), %r15    # 0x23bea1
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x18(%r12), %rax
movq (%rax,%rbx,8), %rdx
shrq $0x21, %rdx
movq 0x28(%r14), %rax
movq 0x40(%r14), %rcx
movl (%rcx,%rdx,4), %esi
movl 0x4(%rcx,%rdx,4), %ecx
subl %esi, %ecx
addl $-0x2, %ecx
je 0x16771
leaq (%rax,%rsi,4), %rdi
movq 0x10(%r14), %r8
movq 0x10(%r8), %r8
movl %ecx, %r9d
xorl %r10d, %r10d
movl 0x8(%rdi,%r10,4), %r11d
shrl %r11d
imulq $0x28, %r11, %r11
addl 0x10(%r8,%r11), %ebp
incq %r10
cmpq %r10, %r9
jne 0x16758
leal 0x1(%rsi), %edi
movl (%rax,%rsi,4), %r9d
movl (%rax,%rdi,4), %r10d
movq (%r13), %rdi
movl %r9d, %r8d
shrl %r8d
incl %r8d
andl $0x1, %r9d
movl %r10d, %r11d
shrl %r11d
incl %r11d
andl $0x1, %r10d
movq %r15, %rsi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x22b0
popq %rcx
popq %rdx
incq %rbx
movl 0x10(%r12), %eax
cmpq %rax, %rbx
jb 0x16723
movq (%r13), %rdi
leaq 0x225711(%rip), %rsi    # 0x23bed7
movl 0x4(%rsp), %edx
xorl %eax, %eax
callq 0x22b0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: debug_flip(G_partition*, hc_links*, bubble_type*, unsigned int)
void debug_flip(G_partition* g_p, hc_links* link, bubble_type* bub, uint32_t id)
{
    fprintf(stderr, "33333333333\n");
    uint32_t *h0, h0_n, *h1, h1_n, k, wrong;
    double hw0, hw1;
    for (k = wrong = 0; k < g_p->n; k++)
    {
        hw0 = hw1 = 0;
        get_phased_block(g_p, NULL, k, NULL, NULL, &h0, &h0_n, &h1, &h1_n, NULL, NULL);
        if(h0_n >0) hw0 = get_cluster_weight_debug(g_p, link, h0, h0_n);
        if(h1_n >0) hw1 = get_cluster_weight_debug(g_p, link, h1, h1_n);
        if(hw0 != g_p->a[k].weight[0])
        {
            if((uint32_t)hw0 != (uint32_t)g_p->a[k].weight[0]) wrong = 1;
            fprintf(stderr, "k: %u, ERROR(id: %u): hw0: %f, weight[0]: %f\n", k, id, hw0, g_p->a[k].weight[0]);
        } 
        
        if(hw1 != g_p->a[k].weight[1])
        {
            if((uint32_t)hw1 != (uint32_t)g_p->a[k].weight[1]) wrong = 1;
            fprintf(stderr, "k: %u, ERROR(id: %u): hw1: %f, weight[1]: %f\n", k, id, hw1, g_p->a[k].weight[1]);
        }

        if(wrong) break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0x14(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movq 0x27ce32(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x223dfe(%rip), %rdi    # 0x23bfb6
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
cmpq $0x0, (%rbx)
je 0x1831a
movq %rbx, %rcx
xorl %r12d, %r12d
movq %rbx, 0x8(%rsp)
movq 0x10(%rcx), %r15
imulq $0x48, %r12, %r14
movq 0x10(%r15,%r14), %rbp
movl 0x18(%r15,%r14), %ebx
movl 0x1c(%r15,%r14), %r13d
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
testq %rbx, %rbx
je 0x1821d
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x154bf1
movq 0x8(%rsp), %rcx
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
testl %r13d, %r13d
je 0x18250
leaq (,%rbx,4), %rdx
addq %rbp, %rdx
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %ecx
movsd %xmm2, 0x18(%rsp)
callq 0x154bf1
movsd 0x18(%rsp), %xmm2
movq 0x8(%rsp), %rcx
movsd 0x30(%r15,%r14), %xmm1
ucomisd %xmm1, %xmm2
jne 0x1827f
jp 0x1827f
movsd 0x38(%r15,%r14), %xmm1
ucomisd %xmm1, %xmm0
jne 0x182dd
jp 0x182dd
incl %r12d
cmpq %r12, (%rcx)
ja 0x181d8
jmp 0x1831a
cvttsd2si %xmm2, %r15
cvttsd2si %xmm1, %r13
cmpl %r13d, %r15d
sete %bl
movq 0x27cd4a(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x223d23(%rip), %rsi    # 0x23bfc3
movl %r12d, %edx
movl 0x14(%rsp), %ecx
movsd %xmm0, 0x18(%rsp)
movapd %xmm2, %xmm0
movb $0x2, %al
callq 0x22b0
movsd 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rax
movsd 0x38(%rax,%r14), %xmm1
ucomisd %xmm1, %xmm0
jne 0x182df
jp 0x182df
cmpl %r13d, %r15d
je 0x1826e
jmp 0x1831a
movb $0x1, %bl
cvttsd2si %xmm0, %r14
cvttsd2si %xmm1, %r15
movq 0x27ccf0(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x223cf7(%rip), %rsi    # 0x23bff1
movl %r12d, %edx
movl 0x14(%rsp), %ecx
movb $0x2, %al
callq 0x22b0
movq 0x8(%rsp), %rcx
cmpl %r15d, %r14d
jne 0x1831a
testb %bl, %bl
jne 0x1826e
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/hic.cpp
// Function: print_chain_phasing(H_partition*, ma_ug_t*, bubble_type*, unsigned int)
void print_chain_phasing(H_partition* hap, ma_ug_t *ug, bubble_type* bub, uint32_t chain_id)
{
    uint32_t i, k;
    uint32_t beg, sink, *a, n;
    uint64_t bid, uid;
    ma_utg_t *u = &(bub->b_ug->u.a[chain_id]);
    fprintf(stderr, "\n**********chain_id: %u**********\n", chain_id);
    for (i = 0; i < u->n; i++)
    {
        bid = u->a[i]>>33;
        fprintf(stderr, "(%u) chain_id: %u, u->n: %u, bid: %u\n", i, chain_id, (uint32_t)u->n, i);
        get_bubbles(bub, bid, &beg, &sink, &a, &n, NULL);
        for (k = 0; k < n; k++)
        {
            uid = a[k]>>1;
            fprintf(stderr, "utg%.6ul, hap: %u, group: %u, stats: %d\n", (int)(uid+1), hap->hap[uid], 
                        get_phase_group(hap, uid), get_phase_status(hap, uid));
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq %rdx, 0x8(%rsp)
movq 0xc0(%rdx), %rax
movq 0x10(%rax), %r14
movl %ecx, %eax
imulq $0x28, %rax, %rbx
movq 0x27c8c1(%rip), %r12    # 0x294fe0
movq (%r12), %rdi
leaq 0x2239c5(%rip), %rsi    # 0x23c0ef
movl %ecx, 0x4(%rsp)
movl %ecx, %edx
xorl %eax, %eax
callq 0x22b0
movl 0x10(%r14,%rbx), %r8d
testl %r8d, %r8d
je 0x18820
addq %rbx, %r14
xorl %ebp, %ebp
movq %r14, 0x10(%rsp)
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %rbx
movq (%r12), %rdi
leaq 0x2239b0(%rip), %rsi    # 0x23c112
movl %ebp, %edx
movl 0x4(%rsp), %ecx
movl %ebp, %r9d
xorl %eax, %eax
callq 0x22b0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
shrq $0x21, %rbx
movl (%rax,%rbx,4), %ecx
movl 0x4(%rax,%rbx,4), %eax
subl %ecx, %eax
addl $-0x2, %eax
je 0x1880b
movq 0x8(%rsp), %rdx
movq 0x28(%rdx), %rdx
leaq (%rdx,%rcx,4), %r13
addq $0x8, %r13
movl %eax, %ebx
xorl %r14d, %r14d
movl (%r13,%r14,4), %ecx
shrl %ecx
movq (%r12), %rdi
movq 0x10(%r15), %rax
movl (%rax,%rcx,4), %eax
movl %ecx, %edx
incl %edx
movb 0x2c(%r15), %cl
movl %eax, %r8d
shrl %cl, %r8d
xorl %ecx, %ecx
testl %eax, 0x18(%r15)
setne %cl
leal (%rcx,%rcx,2), %ecx
addl $-0x2, %ecx
movl 0x1c(%r15), %esi
andl %eax, %esi
negl %esi
movl $0x0, %r9d
sbbl %r9d, %r9d
orl %ecx, %r9d
testl %eax, 0x20(%r15)
movl $0x0, %ecx
cmovnel %ecx, %r9d
leaq 0x22393e(%rip), %rsi    # 0x23c138
movl %eax, %ecx
xorl %eax, %eax
callq 0x22b0
incq %r14
cmpq %r14, %rbx
jne 0x187a3
incq %rbp
movq 0x10(%rsp), %r14
movl 0x10(%r14), %r8d
cmpq %r8, %rbp
jb 0x1874f
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/hic.cpp
// Function: sort_bubble_ele(G_partition*, hc_links*, bubble_type*, unsigned int)
void sort_bubble_ele(G_partition* g_p, hc_links* link, bubble_type* bub, uint32_t n_utg)
{
    double index_time = yak_realtime();
    kvec_t_u64_warp stack; kv_init(stack.a);
    bub_sort_vec w_stack; kv_init(w_stack);
    uint8_t* vis = NULL; MALLOC(vis, n_utg);
    uint32_t* set_hap = NULL; MALLOC(set_hap, n_utg); memset(set_hap, -1, sizeof(uint32_t)*n_utg);
    uint32_t i;
    
   for (i = 0; i < bub->chain_weight.n; i++)
   {
       if(bub->chain_weight.a[i].del) continue;
       sort_bubble_ele_by_chain(g_p, link, bub, &stack, &w_stack, vis, set_hap, n_utg, bub->chain_weight.a[i].id);
   }

   kv_destroy(stack.a); kv_destroy(w_stack); free(vis); free(set_hap);
   fprintf(stderr, "[M::%s::%.3f]\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x1365ef
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movl %r15d, %ebx
movq %rbx, %rdi
callq 0x2280
movq %rax, (%rsp)
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rax, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x20e0
movq 0xc8(%r12), %rax
testq %rax, %rax
jne 0x188b6
xorl %r15d, %r15d
xorl %edi, %edi
jmp 0x18919
pushq $0x1
popq %rbx
xorl %ecx, %ecx
movq 0xd8(%r12), %rdx
shlq $0x5, %rcx
cmpb $0x0, 0x18(%rdx,%rcx)
jne 0x18906
addq %rcx, %rdx
movl 0x10(%rdx), %eax
subq $0x8, %rsp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
leaq 0x38(%rsp), %rcx
leaq 0x18(%rsp), %r8
movq 0x8(%rsp), %r9
pushq %rax
pushq %r15
pushq %r14
callq 0x15745f
addq $0x20, %rsp
movq 0xc8(%r12), %rax
movl %ebx, %ecx
incl %ebx
cmpq %rcx, %rax
ja 0x188bb
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %r15
callq 0x2220
movq %r15, %rdi
callq 0x2220
movq (%rsp), %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2220
movq 0x27c6a2(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd 0x8(%rsp), %xmm0
leaq 0x223298(%rip), %rsi    # 0x23bbeb
leaq 0x2238bc(%rip), %rdx    # 0x23c216
movq %rbx, %rdi
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: print_kv_weight(kv_u_trans_t*, signed char*)
void print_kv_weight(kv_u_trans_t *ta, int8_t *s)
{
    uint32_t i;
    // u_trans_t *e = NULL;
    fprintf(stderr, "\n[M::%s]\n", __func__);
    fprintf(stderr, "*********ta->n: %u\n", (uint32_t)ta->n);
    for (i = 0; i < ta->n; i++)
    {
        fprintf(stderr, "+s-utg%.6ul(s:%d)\td-utg%.6ul(s:%d)\tw-%f\n", 
                        ta->a[i].qn+1, s[ta->a[i].qn], ta->a[i].tn+1, s[ta->a[i].tn], ta->a[i].nw);
        /**
        get_u_trans_spec(ta, ta->a[i].tn, ta->a[i].qn, &e, NULL);
        if(e)
        {
            fprintf(stderr, "-d-utg%.6ul->s-utg%.6ul: %f\n", e->qn+1, e->tn+1, e->nw);
        }
        else
        {
            fprintf(stderr, "ERROR");
        }
        **/
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27ae65(%rip), %r12    # 0x294fe0
movq (%r12), %rdi
leaq 0x222345(%rip), %rsi    # 0x23c4cb
leaq 0x222348(%rip), %rdx    # 0x23c4d5
xorl %eax, %eax
callq 0x22b0
movq (%r12), %rdi
movl (%r14), %edx
leaq 0x222343(%rip), %rsi    # 0x23c4e5
xorl %eax, %eax
callq 0x22b0
cmpq $0x0, (%r14)
je 0x1a1f9
pushq $0x1
popq %rbp
xorl %eax, %eax
leaq 0x22233e(%rip), %r15    # 0x23c4f9
movq (%r12), %rdi
movq 0x10(%r14), %rsi
imulq $0x30, %rax, %rax
movl 0x8(%rsi,%rax), %ecx
movl 0x14(%rsi,%rax), %r9d
leal 0x1(%rcx), %edx
movsbl (%rbx,%rcx), %ecx
leal 0x1(%r9), %r8d
movsbl (%rbx,%r9), %r9d
movsd 0x20(%rsi,%rax), %xmm0
movq %r15, %rsi
movb $0x1, %al
callq 0x22b0
movl %ebp, %eax
incl %ebp
cmpq %rax, (%r14)
ja 0x1a1bb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: print_debug_hc_links(ha_ug_index*, bubble_type*, hc_links*, kv_u_trans_t*, kvec_pe_hit*)
void print_debug_hc_links(ha_ug_index* idx, bubble_type* bub, hc_links* lk, kv_u_trans_t *ta, kvec_pe_hit* hits)
{
    uint64_t k, len = 0, occ = 0, shif = 64 - idx->uID_bits, beg, end;
    hc_edge *e = NULL;
    for (k = 0; k < hits->a.n; ++k) 
    {
        beg = ((hits->a.a[k].s<<1)>>shif);
        end = ((hits->a.a[k].e<<1)>>shif);
        if(beg == end) continue;
        if(IF_HOM(beg, *bub)) continue;
        if(IF_HOM(end, *bub)) continue;
        len += (hits->a.a[k].len>>32) + ((uint32_t)hits->a.a[k].len);
        occ++;
    }

    fprintf(stderr, "# total Hi-C aligned bases: %lu\n", len);
    fprintf(stderr, "# total Hi-C aligned pairs: %lu\n", occ);
    for (k = 0; k < ta->n; k++)
    {
        e = get_hc_edge(lk, ta->a[k].qn, ta->a[k].tn, 0);
        fprintf(stderr, "s-utg%.6ul\td-utg%.6ul\tD:%lu\tW:%f\n", 
        ta->a[k].qn+1, ta->a[k].tn+1, e->dis == (uint64_t)-1? (uint64_t)-1 : e->dis>>3, ta->a[k].nw);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq (%r8), %rax
testq %rax, %rax
jne 0x1a223
xorl %r15d, %r15d
xorl %edx, %edx
jmp 0x1a28a
pushq $0x40
popq %rcx
subq 0x18(%rdi), %rcx
movq 0x10(%r8), %rdi
xorl %edx, %edx
xorl %r15d, %r15d
movq (%rdi), %r8
addq %r8, %r8
shrq %cl, %r8
movq 0x8(%rdi), %r9
addq %r9, %r9
shrq %cl, %r9
cmpq %r9, %r8
je 0x1a281
movq (%rsi), %r11
movq 0x80(%rsi), %r10
movl (%r11,%r8,4), %r8d
incq %r10
cmpq %r8, %r10
jb 0x1a281
movl (%r11,%r9,4), %r8d
cmpq %r8, %r10
jb 0x1a281
movq 0x18(%rdi), %r8
movl %r8d, %r9d
shrq $0x20, %r8
addq %rdx, %r9
addq %r8, %r9
incq %r15
movq %r9, %rdx
addq $0x20, %rdi
decq %rax
jne 0x1a233
movq 0x27ad4f(%rip), %r14    # 0x294fe0
movq (%r14), %rdi
leaq 0x222287(%rip), %rsi    # 0x23c522
xorl %eax, %eax
callq 0x22b0
movq (%r14), %rdi
leaq 0x222297(%rip), %rsi    # 0x23c543
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
cmpq $0x0, (%rbx)
je 0x1a329
pushq $0x20
popq %r14
xorl %r15d, %r15d
movq 0x10(%rbx), %rbp
movl -0x18(%rbp,%r14), %r12d
movl -0xc(%rbp,%r14), %r13d
movq (%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x144201
movq 0x27acf7(%rip), %rcx    # 0x294fe0
movq (%rcx), %rdi
leal 0x1(%r12), %edx
leal 0x1(%r13), %ecx
movq 0x10(%rax), %rax
movq %rax, %r8
shrq $0x3, %r8
cmpq $-0x1, %rax
cmoveq %rax, %r8
movsd (%rbp,%r14), %xmm0
leaq 0x22224e(%rip), %rsi    # 0x23c564
movb $0x1, %al
callq 0x22b0
incq %r15
addq $0x30, %r14
cmpq (%rbx), %r15
jb 0x1a2c3
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/hic.cpp
// Function: verbose_het_stat(bubble_type*)
void verbose_het_stat(bubble_type *bub)
{
    uint64_t i, hetBase = 0, homBase = 0;
    for (i = 0; i < bub->ug->g->n_seq; i++)
    {
        if(IF_HOM(i, *bub)) homBase += bub->ug->g->seq[i].len;
        else hetBase += bub->ug->g->seq[i].len;
    }

    fprintf(stderr, "[M::stat] # heterozygous bases: %lu; # homozygous bases: %lu\n", hetBase, homBase);
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rax), %rcx
movl 0x14(%rcx), %eax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jne 0x1a4ee
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x1a533
movq (%rdi), %rsi
movq 0x80(%rdi), %rdi
incq %rdi
movq 0x20(%rcx), %r8
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %edx, %edx
xorl %r10d, %r10d
movl (%rsi,%r10,4), %r11d
movl (%r8,%r10,8), %ebx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
cmpq %r11, %rdi
movq %rbx, %r11
cmovbq %r9, %r11
cmovaeq %r9, %rbx
addq %r11, %rdx
addq %rbx, %rcx
incq %r10
cmpq %r10, %rax
jne 0x1a509
movq 0x27aaa6(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x22207c(%rip), %rsi    # 0x23c5c0
xorl %eax, %eax
popq %rbx
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: print_kv_u_trans_t(kv_u_trans_t*, ma_ug_t*)
void print_kv_u_trans_t(kv_u_trans_t *ta, ma_ug_t* ug)
{
    uint32_t i;
    u_trans_t *p = NULL;
    for (i = 0; i < ta->n; i++)
    {
        p = &(ta->a[i]);
        fprintf(stderr, "q-utg%.6ul\tql(%u)\tqs(%u)\tqe(%u)\tt-utg%.6ul\ttl(%u)\tts(%u)\tte(%u)\trev(%u)\tw(%f)\tf(%u)\n", 
        p->qn+1, ug->u.a[p->qn].len, p->qs, p->qe, p->tn+1, ug->u.a[p->tn].len, p->ts, p->te, p->rev, p->nw, p->f);
    }
    fprintf(stderr, "[M::%s::] \n", __func__);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
je 0x1a60b
movq %rsi, %r14
pushq $0x1
popq %rbp
xorl %ecx, %ecx
movq %rdi, (%rsp)
movq 0x10(%rdi), %rax
imulq $0x30, %rcx, %rbx
movq 0x27aa64(%rip), %rcx    # 0x294fe0
movq (%rcx), %rdi
movl 0x8(%rax,%rbx), %ecx
leal 0x1(%rcx), %edx
movq 0x10(%r14), %r11
imulq $0x28, %rcx, %rcx
movl (%r11,%rcx), %ecx
movl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
andl %r15d, %ecx
movl (%rax,%rbx), %r8d
movl 0x4(%rax,%rbx), %r9d
movl 0x14(%rax,%rbx), %r12d
leal 0x1(%r12), %r10d
imulq $0x28, %r12, %r12
movl (%r11,%r12), %r11d
andl %r15d, %r11d
movl 0xc(%rax,%rbx), %r12d
movl 0x10(%rax,%rbx), %r15d
movsd 0x20(%rax,%rbx), %xmm0
movzbl 0x28(%rax,%rbx), %r13d
movl %r13d, %ebx
shrl $0x6, %ebx
andl $0x1, %ebx
andl $0x3f, %r13d
leaq 0x222074(%rip), %rsi    # 0x23c657
movb $0x1, %al
pushq %r13
pushq %rbx
pushq %r15
pushq %r12
pushq %r11
pushq %r10
callq 0x22b0
movq 0x30(%rsp), %rdi
addq $0x30, %rsp
movl %ebp, %ecx
incl %ebp
cmpq %rcx, (%rdi)
ja 0x1a56d
movq 0x27a9ce(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x222090(%rip), %rsi    # 0x23c6ac
leaq 0x222095(%rip), %rdx    # 0x23c6b8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: round_test(ps_t*, unsigned long, bubble_type*, kv_u_trans_t*, hc_links*, sldat_t*, ha_ug_index*, unsigned long, unsigned long)
void round_test(ps_t *s, uint64_t seed, bubble_type *bub, kv_u_trans_t *k_trans, hc_links *link, sldat_t *sl, 
ha_ug_index* idx, uint64_t test_block_flip, uint64_t n_perturb)
{
    s->xs = seed; memset(s->s, 0, s->n);
    bub->round_id = 0; asm_opt.n_perturb = n_perturb;

    fprintf(stderr, "[M::%s] ----> test_block_flip: %lu, n_perturb: %lu\n", 
    __func__, test_block_flip, n_perturb);
    renew_kv_u_trans(k_trans, link, &sl->hits, &(idx->t_ch->k_trans), idx, bub, s->s, NULL, 0);    
    mc_solve(NULL, NULL, k_trans, idx->ug, idx->read_g, 0.8, R_INF.trio_flag, 
        (bub->round_id == 0? 1 : 0), s->s, 1, NULL, test_block_flip?&(idx->t_ch->k_trans):0, 0, 0);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbp
movq %r8, 0x38(%rsp)
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %r12
movq 0x80(%rsp), %r14
movq 0x90(%rsp), %rbx
movq %rsi, 0x8(%rdi)
movq (%rdi), %rdi
movq 0x10(%r12), %rdx
xorl %esi, %esi
callq 0x20e0
andl $0x0, 0x8(%r15)
leaq 0x27a73b(%rip), %rax    # 0x295758
movl %ebx, 0x1d0(%rax)
movq 0x279fb6(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x2217e1(%rip), %rsi    # 0x23c815
leaq 0x22180e(%rip), %rdx    # 0x23c849
movq 0x88(%rsp), %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x22b0
addq $0x38, %rbp
movl $0x138, %ebx            # imm = 0x138
movq 0x10(%r14), %rcx
addq %rbx, %rcx
movq (%r12), %rax
andl $0x0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
movq %rax, (%rsp)
movq %r13, 0x40(%rsp)
movq %r13, %rdi
movq 0x38(%rsp), %rsi
movq %rbp, %rdx
movq %r14, %r8
movq %r15, %r9
callq 0x1a338
movq (%r14), %rcx
movq 0x8(%r14), %r8
leaq 0x27b197(%rip), %rax    # 0x296230
movq 0x28(%rax), %r9
movl 0x8(%r15), %edx
movq (%r12), %rax
cmpq $0x0, 0x88(%rsp)
je 0x1b0b6
addq 0x10(%r14), %rbx
jmp 0x1b0b8
xorl %ebx, %ebx
xorl %esi, %esi
testl %edx, %edx
sete %sil
movq %rbx, 0x20(%rsp)
movq %rax, 0x8(%rsp)
andl $0x0, 0x30(%rsp)
movl %esi, (%rsp)
andl $0x0, 0x28(%rsp)
andq $0x0, 0x18(%rsp)
movl $0x1, 0x10(%rsp)
movsd 0x2164c3(%rip), %xmm0   # 0x2315b0
xorl %edi, %edi
xorl %esi, %esi
movq 0x40(%rsp), %rdx
callq 0x1e07b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: hic_pre_analysis(ma_ug_t*, asg_t*, trans_chain*, ug_opt_t*, kvec_pe_hit**)
spg_t *hic_pre_analysis(ma_ug_t *ug, asg_t* read_g, trans_chain* t_ch, ug_opt_t *opt, kvec_pe_hit **rhits)
{
    ug_index = NULL;
    int exist = (asm_opt.load_index_from_disk? 
                    load_hc_pt_index(&ug_index, ug, asm_opt.output_file_name) : 0);
    if(exist == 0) ug_index = build_unitig_index(ug, asm_opt.hic_mer_length, asm_opt.hap_occ, 0, asm_opt.thread_num);
    if(exist == 0) write_hc_pt_index(ug_index, asm_opt.output_file_name);
    ug_index->ug = ug;
    ug_index->read_g = read_g;
    ug_index->t_ch = t_ch;
    return hic_short_pre_align(asm_opt.hic_reads[0], asm_opt.hic_reads[1], ug_index, opt, rhits);    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
andq $0x0, 0x27a6c2(%rip)    # 0x296530
movq %rdi, %r13
leaq 0x2798e0(%rip), %rbp    # 0x295758
cmpl $0x0, 0xf0(%rbp)
je 0x1be98
movq 0x10(%rbp), %rdx
leaq 0x27a6a4(%rip), %rdi    # 0x296530
movq %r13, %rsi
callq 0x13ab6a
testl %eax, %eax
jne 0x1bec6
movl 0x84(%rbp), %esi
movslq 0x1b8(%rbp), %rdx
movslq 0x7c(%rbp), %r8
movq %r13, %rdi
xorl %ecx, %ecx
callq 0x14de3
movq %rax, 0x27a676(%rip)    # 0x296530
movq 0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x13a94b
movq 0x27a663(%rip), %rax    # 0x296530
movq %r13, (%rax)
movq 0x27a659(%rip), %rdx    # 0x296530
movq %r12, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq 0x50(%rbp), %rdi
movq 0x58(%rbp), %rsi
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b6a2
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: hic_short_align_bench(enzyme const*, enzyme const*, char const*, ha_ug_index*)
int hic_short_align_bench(const enzyme *fn1, const enzyme *fn2, const char *output_file_name, ha_ug_index* idx)
{
    double index_time = yak_realtime();
    sldat_t sl;
    sl.idx = idx;
    ///sl.link = NULL;
    sl.chunk_size = 20000000;
    sl.n_thread = asm_opt.thread_num;
    sl.total_base = sl.total_pair = 0;
    idx->hap_cnt = asm_opt.hap_occ;
    kv_init(sl.hits.a);
    fprintf(stderr, "u.n: %d, uID_bits: %lu, pos_bits: %lu\n", (uint32_t)idx->ug->u.n, idx->uID_bits, idx->pos_bits);
    
    if(!load_hc_hits(&sl.hits, idx->ug, output_file_name))
    {
        // kt_pipeline(3, worker_pipeline, &sl, 3);
        // dedup_hits(&sl.hits);
        alignment_worker_pipeline(&sl, fn1, fn2);
        write_hc_hits(&sl.hits, idx->ug, output_file_name);
    }
    bench_idx bench;
    init_bench_idx(&bench, idx->read_g, idx->ug);
    ///print_bench_idx(&bench, idx->ug);
    evaluate_bench_idx(&bench, &sl.hits, idx->ug);

    destory_bench_idx(&bench);
    kv_destroy(sl.hits.a);
    fprintf(stderr, "[M::%s::%.3f] processed %lu pairs; %lu bases\n", __func__, yak_realtime()-index_time, sl.total_pair, sl.total_base);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x1365ef
leaq 0x48(%rsp), %r14
movq %rbx, -0x38(%r14)
movq $0x1312d00, -0x20(%r14) # imm = 0x1312D00
leaq 0x27981e(%rip), %rax    # 0x295758
movslq 0x7c(%rax), %rcx
movq %rcx, -0x18(%r14)
xorps %xmm1, %xmm1
movups %xmm1, -0x10(%r14)
movslq 0x1b8(%rax), %rax
movq %rax, 0x48(%rbx)
andq $0x0, 0x10(%r14)
movsd %xmm0, 0x8(%rsp)
movups %xmm1, (%r14)
movq 0x279075(%rip), %rbp    # 0x294fe0
movq (%rbp), %rdi
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movl (%rax), %edx
movq 0x28(%rbx), %r8
leaq 0x220c88(%rip), %rsi    # 0x23cc0b
xorl %eax, %eax
callq 0x22b0
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x146d08
testl %eax, %eax
jne 0x1bfba
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x15d602
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1461bb
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0x16515e
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1653c6
movq %r15, %rdi
callq 0x165513
movq 0x58(%rsp), %rdi
callq 0x2220
movq (%rbp), %rbx
callq 0x1365ef
subsd 0x8(%rsp), %xmm0
movq 0x38(%rsp), %r8
movq 0x40(%rsp), %rcx
leaq 0x2209c8(%rip), %rsi    # 0x23c9d9
leaq 0x220c1a(%rip), %rdx    # 0x23cc32
movq %rbx, %rdi
movb $0x1, %al
callq 0x22b0
pushq $0x1
popq %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: hic_benchmark(ma_ug_t*, asg_t*)
void hic_benchmark(ma_ug_t *ug, asg_t* read_g)
{
    char *output_file_name = (char*)calloc(strlen(asm_opt.output_file_name) + 25, 1);
	sprintf(output_file_name, "%s.bench", asm_opt.output_file_name);
    ug_index = NULL;
    int exist = load_hc_pt_index(&ug_index, ug, output_file_name);
    if(exist == 0) ug_index = build_unitig_index(ug, asm_opt.hic_mer_length, asm_opt.hap_occ, 0, asm_opt.thread_num);
    if(exist == 0) write_hc_pt_index(ug_index, output_file_name);
    ug_index->ug = ug;
    ug_index->read_g = read_g;

    hic_short_align_bench(asm_opt.hic_reads[0], asm_opt.hic_reads[1], output_file_name, ug_index);

    free(output_file_name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x27970b(%rip), %r13    # 0x295758
movq 0x10(%r13), %r12
movq %r12, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x2120
movq %rax, %r15
leaq 0x220bd9(%rip), %rsi    # 0x23cc48
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
andq $0x0, 0x27a4ac(%rip)    # 0x296530
leaq 0x27a4a5(%rip), %rdi    # 0x296530
movq %r14, %rsi
movq %r15, %rdx
callq 0x13ab6a
testl %eax, %eax
jne 0x1c0c8
movl 0x84(%r13), %esi
movslq 0x1b8(%r13), %rdx
movslq 0x7c(%r13), %r8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x14de3
movq %rax, 0x27a473(%rip)    # 0x296530
movq %rax, %rdi
movq %r15, %rsi
callq 0x13a94b
movq 0x27a461(%rip), %rax    # 0x296530
movq %r14, (%rax)
movq 0x27a457(%rip), %rcx    # 0x296530
movq %rbx, 0x8(%rcx)
movq 0x50(%r13), %rdi
movq 0x58(%r13), %rsi
movq %r15, %rdx
callq 0x1bf00
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/rcut.cpp
// Function: mc_solve_bp(mc_bp_t*)
void mc_solve_bp(mc_bp_t *bp)
{
	double index_time = yak_realtime();
	uint32_t r = 1;
	t_w_t sc_opt, sc;
	mc_reset_z_all(bp->ma, bp->b_aux);
	sc_opt = mc_score_all(bp->ma, bp->b_aux);

	while (1)
	{
		sc = mc_solve_bp_cc(bp);
		// fprintf(stderr, "[M::%s::# round: %u] sc_opt: %ld, sc: %ld\n", __func__, r, sc_opt, sc);
		fprintf(stderr, "[M::%s::# round: %u] sc_opt: %f, sc: %f\n", __func__, r, sc_opt, sc);
		if(sc <= sc_opt) break;
		sc_opt = sc;
		r++;
	}
	fprintf(stderr, "[M::%s::%.3f] ==> round %u\n", __func__, yak_realtime()-index_time, r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x1365ef
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdi
callq 0x16afa8
movq 0x40(%rbx), %rax
movl 0x38(%rax), %eax
xorpd %xmm2, %xmm2
testq %rax, %rax
je 0x1d612
movq 0x38(%rbx), %rdx
movq 0x40(%rdx), %rcx
movq 0x50(%rdx), %rdx
addq $0x8, %rcx
xorl %esi, %esi
movsbl (%rdx,%rsi), %edi
cvtsi2sd %edi, %xmm0
movsd -0x8(%rcx), %xmm1
subsd (%rcx), %xmm1
mulsd %xmm0, %xmm1
subsd %xmm1, %xmm2
incq %rsi
addq $0x10, %rcx
cmpq %rsi, %rax
jne 0x1d5ed
xorl %ebp, %ebp
movq 0x2779c5(%rip), %r12    # 0x294fe0
leaq 0x21f958(%rip), %r14    # 0x23cf7a
leaq 0x21f97a(%rip), %r15    # 0x23cfa3
movsd %xmm2, 0x8(%rsp)
incl %ebp
movq %rbx, %rdi
callq 0x16aef5
movapd %xmm0, %xmm1
movsd %xmm0, 0x18(%rsp)
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x22b0
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
ucomisd %xmm2, %xmm0
jb 0x1d629
movq (%r12), %rbx
callq 0x1365ef
subsd 0x10(%rsp), %xmm0
leaq 0x21f92b(%rip), %rsi    # 0x23cfaf
leaq 0x21f918(%rip), %rdx    # 0x23cfa3
movq %rbx, %rdi
movl %ebp, %ecx
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/rcut.cpp
// Function: mc_status_all(mc_match_t const*, signed char*)
void mc_status_all(const mc_match_t *ma, int8_t *s)
{
	t_w_t tt_w = mc_score_all_advance(ma, s);
	uint64_t k, nn = 0, ne = 0;
	for (k = 0; k < ma->n_seq; ++k) {
		if((uint32_t)ma->idx.a[k]) nn++;
		ne += (uint32_t)ma->idx.a[k];
	}
	fprintf(stderr, "[M::%s::] ==> # nodes: %lu, # edges: %lu, weight: %f\n", __func__, nn, ne, tt_w);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x16b051
movl 0x38(%rbx), %eax
testq %rax, %rax
jne 0x1d6bb
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x1d6dc
movq 0x10(%rbx), %rdx
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %esi, %esi
movl (%rdx,%rsi,8), %edi
cmpq $0x1, %rdi
sbbq $-0x1, %rcx
addq %rdi, %r8
incq %rsi
cmpq %rsi, %rax
jne 0x1d6c6
movq 0x2778fd(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21f8de(%rip), %rsi    # 0x23cfcb
leaq 0x21f90d(%rip), %rdx    # 0x23d001
movb $0x1, %al
popq %rbx
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/rcut.cpp
// Function: print_mc_node(mc_match_t const*, mc_svaux_t*, unsigned int)
void print_mc_node(const mc_match_t *ma, mc_svaux_t *b, uint32_t id)
{
	fprintf(stderr, "[M::%s::utg%.6ul-hap%u]\n", __func__, id, b->s[id]>0?1:b->s[id]<0?2:0);
	w_t w[128], z[4];
	uint32_t o, n, i, hn = 4;
	int8_t s;
	for (i = 0; i < hn; i++) w[i] = 0;
	o = ma->idx.a[id] >> 32;
    n = (uint32_t)ma->idx.a[id];
	for (i = 0; i < n; ++i)
	{
		s = b->s[ma_y(ma->ma.a[o + i])];
		w[s>0?1:s<0?2:0] += ma->ma.a[o + i].w;
	}	
	z[0] = z[3] = 0; z[1] = b->z[id].z[0]; z[2] = b->z[id].z[1];
	for (i = 0; i < hn; i++) fprintf(stderr, "w[%u]-%f, z[%u]-%f\n", i, w[i], i, z[i]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movl %edx, %ecx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsi), %rax
movl %edx, %r12d
movb (%rax,%r12), %al
xorl %r8d, %r8d
testb %al, %al
setne %r8b
addl %r8d, %r8d
testb %al, %al
movq 0x27783f(%rip), %r15    # 0x294fe0
movq (%r15), %rdi
pushq $0x1
popq %rbp
cmovgl %ebp, %r8d
leaq 0x21f892(%rip), %rsi    # 0x23d044
leaq 0x21f8a4(%rip), %rdx    # 0x23d05d
xorl %eax, %eax
callq 0x22b0
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x30(%rsp)
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rsi
testl %esi, %esi
je 0x1d82b
movq %rsi, %rax
shrq $0x20, %rax
movq 0x50(%rbx), %rcx
movq 0x28(%r14), %rdx
movl %esi, %esi
movl %eax, %edi
shlq $0x4, %rdi
movl (%rdx,%rdi), %r8d
movb (%rcx,%r8), %r8b
xorl %r9d, %r9d
testb %r8b, %r8b
setne %r9b
addl %r9d, %r9d
testb %r8b, %r8b
movsd 0x8(%rdx,%rdi), %xmm0
cmovgl %ebp, %r9d
addsd 0x20(%rsp,%r9,8), %xmm0
movsd %xmm0, 0x20(%rsp,%r9,8)
incq %rax
decq %rsi
jne 0x1d7ed
andq $0x0, 0x18(%rsp)
andq $0x0, (%rsp)
movq 0x40(%rbx), %rax
shlq $0x4, %r12
movups (%rax,%r12), %xmm0
movups %xmm0, 0x8(%rsp)
xorl %ebx, %ebx
leaq 0x21f81a(%rip), %r14    # 0x23d06b
movq (%r15), %rdi
movsd 0x20(%rsp,%rbx,8), %xmm0
movsd (%rsp,%rbx,8), %xmm1
movq %r14, %rsi
movl %ebx, %edx
movl %ebx, %ecx
movb $0x2, %al
callq 0x22b0
incq %rbx
cmpq $0x4, %rbx
jne 0x1d851
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/rcut.cpp
// Function: prt_bub(unsigned int*, unsigned int, char const*)
void prt_bub(uint32_t *a, uint32_t a_n, const char *cmd) 
{
	uint32_t k;
	fprintf(stderr, "%s\n", cmd);
	for (k = 0; k < a_n; k++) {
		fprintf(stderr, "utg%.6dl\t", (int32_t)a[k]+1);
	}
	fprintf(stderr, "\n");
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x277743(%rip), %r15    # 0x294fe0
movq (%r15), %rdi
leaq 0x21eaa6(%rip), %rsi    # 0x23c34d
xorl %eax, %eax
callq 0x22b0
testl %ebp, %ebp
je 0x1d8da
movl %ebp, %r12d
leaq 0x21f869(%rip), %r14    # 0x23d125
xorl %r13d, %r13d
movq (%r15), %rdi
movl (%rbx,%r13,4), %edx
incl %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x22b0
incq %r13
cmpq %r13, %r12
jne 0x1d8bf
movq (%r15), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/rcut.cpp
// Function: mc_solve_core(mc_opt_t const*, mc_g_t*, bubble_type*)
void mc_solve_core(const mc_opt_t *opt, mc_g_t *mg, bubble_type* bub)
{
	double index_time = yak_realtime();
	uint32_t st, i;
	mc_svaux_t *b;
	mc_bp_t *bp = NULL;
	mc_g_cc(mg->e);
	b = mc_svaux_init(mg, opt->seed);
	if(bub) bp = mc_bp_t_init(mg->e, b, bub, asm_opt.thread_num);
	/*******************************for debug************************************/
	if(bp) mc_init_spin_all(opt, mg, NULL, b);
	if(bp) mc_solve_bp(bp);
	/*******************************for debug************************************/
	if(VERBOSE_CUT)
	{
		fprintf(stderr, "\n\n\n\n\n*************beg-[M::%s::score->%f] ==> Partition\n", __func__, mc_score_all_advance(mg->e, mg->s.a));
	}
	
	for (st = 0, i = 1; i <= mg->e->n_seq; ++i) {
		if (i == mg->e->n_seq || mg->e->cc[st]>>32 != mg->e->cc[i]>>32) {
			mc_solve_cc(opt, mg, b, st, i - st);
			st = i;
		}
	}

	if(VERBOSE_CUT)
	{
		fprintf(stderr, "##############end-[---M::%s::score->%f] ==> Partition\n", __func__, mc_score_all(mg->e, b));
		mc_status_all(mg->e, mg->s.a);
	}
	

	if(bp) mc_solve_bp(bp);	
	///mc_write_info(g, b);
	mc_svaux_destroy(b);
	if(bp) destroy_mc_bp_t(&bp);
	fprintf(stderr, "[M::%s::%.3f] ==> Partition\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1365ef
movsd %xmm0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
movq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x1696cc
movq %rax, 0x30(%r15)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x16992c
movq %rax, %r15
movb $0x1, %r13b
testq %r12, %r12
je 0x1dde7
movq 0x28(%rbx), %rdi
leaq 0x27798a(%rip), %rax    # 0x295758
movslq 0x7c(%rax), %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x1d3db
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1ddec
xorl %r12d, %r12d
jmp 0x1de07
movq %rax, %r12
xorl %r13d, %r13d
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x16e1ef
movq %r12, %rdi
callq 0x1d5a4
movq 0x28(%rbx), %rax
movl 0x38(%rax), %edx
testl %edx, %edx
je 0x1de54
pushq $0x1
popq %rbp
xorl %ecx, %ecx
cmpl %edx, %ebp
je 0x1de31
movq 0x30(%rax), %rdx
movl %ecx, %esi
movl %ebp, %edi
movq (%rdx,%rdi,8), %rdi
xorq (%rdx,%rsi,8), %rdi
shrq $0x20, %rdi
je 0x1de4b
movl %ebp, %r8d
subl %ecx, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x16b1a4
movq 0x28(%rbx), %rax
movl %ebp, %ecx
incl %ebp
movl 0x38(%rax), %edx
cmpl %edx, %ebp
jbe 0x1de17
testb %r13b, %r13b
je 0x1de63
movq %r15, %rdi
callq 0x169a43
jmp 0x1de7d
movq %r12, %rdi
callq 0x1d5a4
movq %r15, %rdi
callq 0x169a43
leaq 0x8(%rsp), %rdi
callq 0x1698c7
movq 0x27715c(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd 0x10(%rsp), %xmm0
leaq 0x21f433(%rip), %rsi    # 0x23d2cc
leaq 0x21f457(%rip), %rdx    # 0x23d2f7
movq %rbx, %rdi
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0