LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x273035(%rip), %r13    # 0x289fe0
movq (%r13), %rdi
movl 0x10(%r12,%rbx), %ecx
leaq 0x218caa(%rip), %rsi    # 0x22fc65
xorl %ebp, %ebp
movl %edx, 0x4(%rsp)
xorl %eax, %eax
callq 0x22b0
cmpl $0x0, 0x10(%r12,%rbx)
je 0x1707a
addq %rbx, %r12
leaq 0x218cb7(%rip), %r15    # 0x22fc95
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 0x17030
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 0x17017
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 0x16fe2
movq (%r13), %rdi
leaq 0x218c46(%rip), %rsi    # 0x22fccb
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_O1/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 $0x18, %rsp
movl %ecx, 0x4(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x2715e3(%rip), %rax    # 0x289fe0
movq (%rax), %rcx
leaq 0x2173a3(%rip), %rdi    # 0x22fdaa
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
cmpq $0x0, (%r15)
je 0x18b46
xorl %r12d, %r12d
movq 0x10(%r15), %r14
imulq $0x48, %r12, %rbx
movl 0x18(%r14,%rbx), %ecx
movl 0x1c(%r14,%rbx), %r13d
leaq (,%rcx,4), %rax
addq 0x10(%r14,%rbx), %rax
testl %r13d, %r13d
movl $0x0, %ebp
cmovneq %rax, %rbp
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
testq %rcx, %rcx
je 0x18a71
movq 0x10(%r14,%rbx), %rdx
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x14e64c
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
testl %r13d, %r13d
je 0x18a95
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movl %r13d, %ecx
movsd %xmm2, 0x8(%rsp)
callq 0x14e64c
movsd 0x8(%rsp), %xmm2
movsd 0x30(%r14,%rbx), %xmm1
xorl %ebp, %ebp
ucomisd %xmm1, %xmm2
jne 0x18ace
jp 0x18ace
movq 0x10(%r15), %rax
movsd 0x38(%rax,%rbx), %xmm1
ucomisd %xmm1, %xmm0
jne 0x18b11
jp 0x18b11
testl %ebp, %ebp
jne 0x18b46
incl %r12d
cmpq %r12, (%r15)
ja 0x18a1f
jmp 0x18b46
cvttsd2si %xmm2, %rax
cvttsd2si %xmm1, %rcx
xorl %ebp, %ebp
cmpl %ecx, %eax
setne %bpl
movq 0x2714f9(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x2172c6(%rip), %rsi    # 0x22fdb7
movl %r12d, %edx
movl 0x4(%rsp), %ecx
movsd %xmm0, 0x8(%rsp)
movapd %xmm2, %xmm0
movb $0x2, %al
callq 0x22b0
movsd 0x8(%rsp), %xmm0
jmp 0x18aa6
cvttsd2si %xmm0, %rax
cvttsd2si %xmm1, %rcx
cmpl %ecx, %eax
je 0x18b22
pushq $0x1
popq %rbp
movq 0x2714b7(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x2172b2(%rip), %rsi    # 0x22fde5
movl %r12d, %edx
movl 0x4(%rsp), %ecx
movb $0x2, %al
callq 0x22b0
jmp 0x18ab8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/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 0x2710ff(%rip), %r12    # 0x289fe0
movq (%r12), %rdi
leaq 0x216ff7(%rip), %rsi    # 0x22fee3
movl %ecx, 0x4(%rsp)
movl %ecx, %edx
xorl %eax, %eax
callq 0x22b0
movl 0x10(%r14,%rbx), %r8d
testl %r8d, %r8d
je 0x18fe2
addq %rbx, %r14
xorl %ebp, %ebp
movq %r14, 0x10(%rsp)
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %rbx
movq (%r12), %rdi
leaq 0x216fe2(%rip), %rsi    # 0x22ff06
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 0x18fcd
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 0x216f70(%rip), %rsi    # 0x22ff2c
movl %eax, %ecx
xorl %eax, %eax
callq 0x22b0
incq %r14
cmpq %r14, %rbx
jne 0x18f65
incq %rbp
movq 0x10(%rsp), %r14
movl 0x10(%r14), %r8d
cmpq %r8, %rbp
jb 0x18f11
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/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, %ebx
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
callq 0x1303c7
movsd %xmm0, (%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movq %rbx, %r15
movl %ebx, %ebx
movq %rbx, %rdi
callq 0x2280
movq %rax, %r13
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x2280
movq %rax, %rbp
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rax, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x20e0
xorl %eax, %eax
cmpq %rax, 0xc8(%r14)
je 0x190c3
pushq $0x1
popq %rbx
xorl %eax, %eax
movq 0xd8(%r14), %rcx
shlq $0x5, %rax
cmpb $0x0, 0x18(%rcx,%rax)
jne 0x190b6
addq %rax, %rcx
movl 0x10(%rcx), %eax
subq $0x8, %rsp
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
leaq 0x38(%rsp), %rcx
leaq 0x18(%rsp), %r8
movq %r13, %r9
pushq %rax
pushq %r15
pushq %rbp
callq 0x150c5e
addq $0x20, %rsp
movl %ebx, %eax
incl %ebx
cmpq %rax, 0xc8(%r14)
ja 0x19075
movq 0x40(%rsp), %rdi
callq 0x2220
movq 0x10(%rsp), %rdi
callq 0x2220
movq %r13, %rdi
callq 0x2220
movq %rbp, %rdi
callq 0x2220
movq 0x270ef2(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd (%rsp), %xmm0
leaq 0x216899(%rip), %rsi    # 0x22f99b
leaq 0x216f01(%rip), %rdx    # 0x23000a
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_O1/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 0x26f74a(%rip), %r12    # 0x289fe0
movq (%r12), %rdi
leaq 0x215a1e(%rip), %rsi    # 0x2302bf
leaq 0x215a21(%rip), %rdx    # 0x2302c9
xorl %eax, %eax
callq 0x22b0
movq (%r12), %rdi
movl (%r14), %edx
leaq 0x215a1c(%rip), %rsi    # 0x2302d9
xorl %eax, %eax
callq 0x22b0
cmpq $0x0, (%r14)
je 0x1a914
pushq $0x1
popq %rbp
xorl %eax, %eax
leaq 0x215a17(%rip), %r15    # 0x2302ed
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 0x1a8d6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq (%r8), %rax
testq %rax, %rax
jne 0x1a93b
xorl %r15d, %r15d
xorl %edx, %edx
jmp 0x1a9a2
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 0x1a999
movq (%rsi), %r11
movq 0x80(%rsi), %r10
movl (%r11,%r8,4), %r8d
incq %r10
cmpq %r8, %r10
jb 0x1a999
movl (%r11,%r9,4), %r8d
cmpq %r8, %r10
jb 0x1a999
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 0x1a94b
movq 0x26f637(%rip), %r12    # 0x289fe0
movq (%r12), %rdi
leaq 0x215962(%rip), %rsi    # 0x230316
xorl %eax, %eax
callq 0x22b0
movq (%r12), %rdi
leaq 0x215971(%rip), %rsi    # 0x230337
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
cmpq $0x0, (%rbx)
je 0x1aa46
xorl %r13d, %r13d
leaq 0x215978(%rip), %r15    # 0x230358
movq 0x10(%rbx), %rax
imulq $0x30, %r13, %rsi
movl 0x8(%rax,%rsi), %edx
movl 0x14(%rax,%rsi), %ecx
movq 0x10(%r14), %rdi
imulq $0x30, %rdx, %r8
movq 0x10(%rdi,%r8), %r8
addq $0x18, %r8
cmpb $0x0, (%r8)
js 0x1aa0d
cmpl %ecx, -0x10(%r8)
je 0x1aa13
addq $0x28, %r8
jmp 0x1aa01
movq (%r12), %rdi
incl %edx
incl %ecx
movq -0x8(%r8), %r9
movq %r9, %r8
shrq $0x3, %r8
cmpq $-0x1, %r9
cmoveq %r9, %r8
movsd 0x20(%rax,%rsi), %xmm0
movq %r15, %rsi
movb $0x1, %al
callq 0x22b0
incq %r13
cmpq (%rbx), %r13
jb 0x1a9e0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x10(%rdi), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %esi
andq $0x7fffffff, %rsi       # imm = 0x7FFFFFFF
jne 0x1ac0a
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x1ac55
movq (%rdi), %r8
movq 0x80(%rdi), %rdi
incq %rdi
xorl %ecx, %ecx
xorl %edx, %edx
xorl %r9d, %r9d
movl (%r8,%r9,4), %r10d
cmpq %r10, %rdi
jae 0x1ac3b
movq 0x20(%rax), %r10
movl (%r10,%r9,8), %r10d
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
addq %r10, %rcx
jmp 0x1ac4d
movq 0x20(%rax), %r10
movl (%r10,%r9,8), %r10d
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
addq %r10, %rdx
incq %r9
cmpq %r9, %rsi
jne 0x1ac1e
movq 0x26f384(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x21574e(%rip), %rsi    # 0x2303b4
xorl %eax, %eax
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ad2c
movq %rsi, %r14
pushq $0x1
popq %rbp
xorl %ecx, %ecx
movq %rdi, (%rsp)
movq 0x10(%rdi), %rax
imulq $0x30, %rcx, %rbx
movq 0x26f343(%rip), %rcx    # 0x289fe0
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 0x215747(%rip), %rsi    # 0x23044b
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 0x1ac8e
movq 0x26f2ad(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x215763(%rip), %rsi    # 0x2304a0
leaq 0x215768(%rip), %rdx    # 0x2304ac
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_O1/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 0x26f075(%rip), %rax    # 0x28a758
movl %ebx, 0x1d0(%rax)
movq 0x26e8f0(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x214f0f(%rip), %rsi    # 0x230609
leaq 0x214f3c(%rip), %rdx    # 0x23063d
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 0x1aa50
movq (%r14), %rcx
movq 0x8(%r14), %r8
leaq 0x26fad1(%rip), %rax    # 0x28b230
movq 0x28(%rax), %r9
movl 0x8(%r15), %edx
movq (%r12), %rax
cmpq $0x0, 0x88(%rsp)
je 0x1b77c
addq 0x10(%r14), %rbx
jmp 0x1b77e
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 0x209cfd(%rip), %xmm0   # 0x2254b0
xorl %edi, %edi
xorl %esi, %esi
movq 0x40(%rsp), %rdx
callq 0x1edea
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x26efe5(%rip)    # 0x28b530
movq %rdi, %r13
leaq 0x26e203(%rip), %rbp    # 0x28a758
cmpl $0x0, 0xf0(%rbp)
je 0x1c575
movq 0x10(%rbp), %rdx
leaq 0x26efc7(%rip), %rdi    # 0x28b530
movq %r13, %rsi
callq 0x134a44
testl %eax, %eax
jne 0x1c5a3
movl 0x84(%rbp), %esi
movslq 0x1b8(%rbp), %rdx
movslq 0x7c(%rbp), %r8
movq %r13, %rdi
xorl %ecx, %ecx
callq 0x156a8
movq %rax, 0x26ef99(%rip)    # 0x28b530
movq 0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x13481e
movq 0x26ef86(%rip), %rax    # 0x28b530
movq %r13, (%rax)
movq 0x26ef7c(%rip), %rdx    # 0x28b530
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 0x1bd63
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1303c7
leaq 0x48(%rsp), %r14
movq %rbx, -0x38(%r14)
movq $0x1312d00, -0x20(%r14) # imm = 0x1312D00
leaq 0x26e141(%rip), %rax    # 0x28a758
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 0x26d998(%rip), %rbp    # 0x289fe0
movq (%rbp), %rdi
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movl (%rax), %edx
movq 0x28(%rbx), %r8
leaq 0x21439f(%rip), %rsi    # 0x2309ff
xorl %eax, %eax
callq 0x22b0
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x14107b
testl %eax, %eax
jne 0x1c697
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x156cbb
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x14050c
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0x15e775
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x15e9d3
movq %r15, %rdi
callq 0x15eb12
movq 0x58(%rsp), %rdi
callq 0x2220
movq (%rbp), %rbx
callq 0x1303c7
subsd 0x8(%rsp), %xmm0
movq 0x38(%rsp), %r8
movq 0x40(%rsp), %rcx
leaq 0x2140df(%rip), %rsi    # 0x2307cd
leaq 0x214331(%rip), %rdx    # 0x230a26
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_O1/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 0x26e02e(%rip), %r13    # 0x28a758
movq 0x10(%r13), %r12
movq %r12, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x2120
movq %rax, %r15
leaq 0x2142f0(%rip), %rsi    # 0x230a3c
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
andq $0x0, 0x26edcf(%rip)    # 0x28b530
leaq 0x26edc8(%rip), %rdi    # 0x28b530
movq %r14, %rsi
movq %r15, %rdx
callq 0x134a44
testl %eax, %eax
jne 0x1c7a5
movl 0x84(%r13), %esi
movslq 0x1b8(%r13), %rdx
movslq 0x7c(%r13), %r8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x156a8
movq %rax, 0x26ed96(%rip)    # 0x28b530
movq %rax, %rdi
movq %r15, %rsi
callq 0x13481e
movq 0x26ed84(%rip), %rax    # 0x28b530
movq %r14, (%rax)
movq 0x26ed7a(%rip), %rcx    # 0x28b530
movq %rbx, 0x8(%rcx)
movq 0x50(%r13), %rdi
movq 0x58(%r13), %rsi
movq %r15, %rdx
callq 0x1c5dd
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1303c7
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdi
callq 0x16460a
movq 0x40(%rbx), %rax
movl 0x38(%rax), %eax
xorpd %xmm2, %xmm2
testq %rax, %rax
je 0x1e3af
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 0x1e38a
xorl %ebp, %ebp
movq 0x26bc28(%rip), %r12    # 0x289fe0
leaq 0x21296b(%rip), %r14    # 0x230d2a
leaq 0x21298d(%rip), %r15    # 0x230d53
movsd %xmm2, 0x8(%rsp)
incl %ebp
movq %rbx, %rdi
callq 0x164557
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 0x1e3c6
movq (%r12), %rbx
callq 0x1303c7
subsd 0x10(%rsp), %xmm0
leaq 0x21293e(%rip), %rsi    # 0x230d5f
leaq 0x21292b(%rip), %rdx    # 0x230d53
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_O1/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 0x1646ab
movl 0x38(%rbx), %eax
testq %rax, %rax
jne 0x1e458
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x1e479
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 0x1e463
movq 0x26bb60(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x2128f1(%rip), %rsi    # 0x230d7b
leaq 0x212920(%rip), %rdx    # 0x230db1
movb $0x1, %al
popq %rbx
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26baa2(%rip), %r15    # 0x289fe0
movq (%r15), %rdi
pushq $0x1
popq %rbp
cmovgl %ebp, %r8d
leaq 0x2128a5(%rip), %rsi    # 0x230df4
leaq 0x2128b7(%rip), %rdx    # 0x230e0d
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 0x1e5c8
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 0x1e58a
andq $0x0, 0x18(%rsp)
andq $0x0, (%rsp)
movq 0x40(%rbx), %rax
shlq $0x4, %r12
movsd (%rax,%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rax,%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x21281e(%rip), %r14    # 0x230e1b
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 0x1e5fd
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26b997(%rip), %r15    # 0x289fe0
movq (%r15), %rdi
leaq 0x211aee(%rip), %rsi    # 0x230141
xorl %eax, %eax
callq 0x22b0
testl %ebp, %ebp
je 0x1e686
movl %ebp, %r12d
leaq 0x21286d(%rip), %r14    # 0x230ed5
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 0x1e66b
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_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1303c7
movsd %xmm0, 0x8(%rsp)
andq $0x0, (%rsp)
movq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x162d3f
movq %rax, 0x30(%r15)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x162f9b
movq %rax, %r15
testq %r12, %r12
je 0x1eb5c
movq 0x28(%rbx), %rdi
leaq 0x26bc0f(%rip), %rax    # 0x28a758
movslq 0x7c(%rax), %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x1e16d
movq %rax, (%rsp)
movq (%rsp), %r12
testq %r12, %r12
je 0x1eb7a
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1677d5
movq %r12, %rdi
callq 0x1e341
movq 0x28(%rbx), %rax
movl 0x38(%rax), %edx
testl %edx, %edx
je 0x1ebc7
pushq $0x1
popq %rbp
xorl %ecx, %ecx
cmpl %edx, %ebp
je 0x1eba4
movq 0x30(%rax), %rax
movl %ecx, %edx
movl %ebp, %esi
movq (%rax,%rsi,8), %rsi
xorq (%rax,%rdx,8), %rsi
shrq $0x20, %rsi
je 0x1ebba
movl %ebp, %r8d
subl %ecx, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x164816
movl %ebp, %ecx
incl %ebp
movq 0x28(%rbx), %rax
movl 0x38(%rax), %edx
cmpl %edx, %ebp
jbe 0x1eb8a
testq %r12, %r12
jne 0x1ebd6
movq %r15, %rdi
callq 0x1630bd
jmp 0x1ebee
movq %r12, %rdi
callq 0x1e341
movq %r15, %rdi
callq 0x1630bd
movq %rsp, %rdi
callq 0x162f36
movq 0x26b3eb(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd 0x8(%rsp), %xmm0
leaq 0x212472(%rip), %rsi    # 0x23107c
leaq 0x212496(%rip), %rdx    # 0x2310a7
movq %rbx, %rdi
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/rcut.cpp
// Function: mc_solve_core_adv(mc_opt_t const*, mc_g_t*, bubble_type*, kv_u_trans_t*)
void mc_solve_core_adv(const mc_opt_t *opt, mc_g_t *mg, bubble_type* bub, kv_u_trans_t *ref)
{
	double index_time = yak_realtime();
	uint32_t st, i;
	mc_svaux_t *b; mc_clus_t *bc; 
	// mc_bp_t *bp = NULL;
	mc_g_cc(mg->e);
	b = mc_svaux_init(mg, opt->seed);
	bc = init_mc_clus_t(opt, mg, bub, asm_opt.thread_num, b, 16); 
	if(ref && bc) bc->asn = gen_ref_bub(bc, ref);
	// bc = gen_mc_clus_t(mg->e, b, bub, ref, asm_opt.thread_num);
	// 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_adv(opt, mg, b, st, i - st, bc);
			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); des_mc_clus_t(bc); 
	// 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
pushq %rax
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1303c7
movsd %xmm0, (%rsp)
movq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x162d3f
movq %rax, 0x30(%r15)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x162f9b
movq %rax, %r15
leaq 0x26baea(%rip), %rax    # 0x28a758
movl 0x7c(%rax), %ecx
pushq $0x10
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %r8
callq 0x168169
movq %rax, %r12
testq %r13, %r13
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x1eca9
movq %r12, %rdi
movq %r13, %rsi
callq 0x168359
movq %rax, 0x70(%r12)
movq 0x28(%rbx), %rax
movl 0x38(%rax), %edx
testl %edx, %edx
je 0x1ecf9
pushq $0x1
popq %rbp
xorl %ecx, %ecx
cmpl %edx, %ebp
je 0x1ecd3
movq 0x30(%rax), %rax
movl %ecx, %edx
movl %ebp, %esi
movq (%rax,%rsi,8), %rsi
xorq (%rax,%rdx,8), %rsi
shrq $0x20, %rsi
je 0x1ecec
movl %ebp, %r8d
subl %ecx, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %r9
callq 0x166aad
movl %ebp, %ecx
incl %ebp
movq 0x28(%rbx), %rax
movl 0x38(%rax), %edx
cmpl %edx, %ebp
jbe 0x1ecb9
movq %r15, %rdi
callq 0x1630bd
movq %r12, %rdi
callq 0x1682c7
movq 0x26b2d0(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd (%rsp), %xmm0
leaq 0x212358(%rip), %rsi    # 0x23107c
leaq 0x2123dc(%rip), %rdx    # 0x231107
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/rcut.cpp
// Function: print_hap_s(signed char*, unsigned int)
void print_hap_s(int8_t *s, uint32_t sn)
{
	fprintf(stderr, "\n[M::%s]\n", __func__);
	uint32_t i;
	for (i = 0; i < sn; i++)
	{
		fprintf(stderr,"utg%.6ul\t", i + 1);
		if(s[i] > 0) fprintf(stderr, "h%u\n", 1);
		else if(s[i] < 0) fprintf(stderr, "h%u\n", 2);
		else 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 0x26b286(%rip), %r12    # 0x289fe0
movq (%r12), %rdi
leaq 0x21155a(%rip), %rsi    # 0x2302bf
leaq 0x2123b9(%rip), %rdx    # 0x231125
xorl %eax, %eax
callq 0x22b0
testl %ebp, %ebp
je 0x1eddb
movl %ebp, %r15d
leaq 0x2114d8(%rip), %r14    # 0x230259
xorl %r13d, %r13d
movq %r13, %rbp
movq (%r12), %rdi
incq %r13
movq %r14, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x22b0
cmpb $0x0, (%rbx,%rbp)
jg 0x1edb6
movq (%r12), %rsi
js 0x1edc5
pushq $0xa
popq %rdi
callq 0x2270
cmpq %r13, %r15
jne 0x1ed84
jmp 0x1eddb
movq (%r12), %rdi
leaq 0x212370(%rip), %rsi    # 0x231131
pushq $0x1
jmp 0x1edd1
movq %rsi, %rdi
leaq 0x212362(%rip), %rsi    # 0x231131
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x1edaf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/rcut.cpp
// Function: dump_debug_phasing(char const*, kv_u_trans_t*, ma_ug_t*, asg_t*, double, unsigned int, signed char*, unsigned int, bubble_type*, kv_u_trans_t*)
void dump_debug_phasing(const char* fn, kv_u_trans_t *ta, ma_ug_t *ug, asg_t *read_g, double f_rate, 
uint32_t renew_s, int8_t *s, uint32_t is_sys, bubble_type* bub, kv_u_trans_t *ref)
{
	fprintf(stderr, "\n[M::%s]\n", __func__);
    char *buf = (char*)calloc(strlen(fn) + 50, 1);
    sprintf(buf, "%s.hic.dbg.dump.bin", fn);
    FILE *fp = fopen(buf, "w");

	dump_kv_u_trans_t(ta, fp);///ta
	dump_ma_ug_t(ug, fp);///ug
	dump_asg_t(read_g, fp);///read_g
	fwrite(&f_rate, sizeof(f_rate), 1, fp);///f_rate
	fwrite(&renew_s, sizeof(renew_s), 1, fp);///renew_s
	fwrite(s, sizeof((*s)), ug->g->n_seq, fp);///s
	fwrite(&is_sys, sizeof(is_sys), 1, fp);///is_sys
	dump_bubble_type(bub, fp);///bub
	dump_kv_u_trans_t(ref, fp);///ta
	dump_rid(&R_INF, fp);

	fclose(fp);
    free(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
leaq 0x4(%rsp), %rax
movl %r8d, (%rax)
movq 0x26afc5(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x21129a(%rip), %rsi    # 0x2302bf
leaq 0x212250(%rip), %rdx    # 0x23127c
xorl %eax, %eax
callq 0x22b0
movq %rbp, %rdi
callq 0x2090
leaq 0x32(%rax), %rdi
pushq $0x1
popq %rbx
movq %rbx, %rsi
callq 0x2120
movq %rax, %r12
leaq 0x2121fa(%rip), %rsi    # 0x23124e
movq %rax, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x21d396(%rip), %rsi    # 0x23c3fe
movq %r12, %rdi
callq 0x2210
movq %rax, %rbp
movq %r15, %rdi
movq %rax, %rsi
callq 0x16ae77
movq %r13, %rdi
movq %rbp, %rsi
callq 0x16afda
movq %r14, %rdi
movq %rbp, %rsi
callq 0x16aed9
pushq $0x8
popq %rsi
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
movq %rbp, %rcx
callq 0x2410
pushq $0x4
popq %r14
leaq 0x4(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
callq 0x2410
movq 0x18(%r13), %rax
movl 0x14(%rax), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x2410
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
callq 0x2410
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x16b108
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x16ae77
leaq 0x26c121(%rip), %rdi    # 0x28b230
movq %rbp, %rsi
callq 0x16b1f8
movq %rbp, %rdi
callq 0x2190
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/rcut.cpp
// Function: debug_hapM(mc_gg_status*, char const*)
void debug_hapM(mc_gg_status *s, const char* cmd)
{
	uint32_t i, cn, hn = s->h[s->hc];
	mcg_node_t ref = s->s;
	for (i = cn = 0; i < 32; i++) cn += ((ref>>i)&1);
	if (cn != hn) fprintf(stderr, "%s-ERROR-cn, cn-%u, hn-%u\n", cmd, cn, hn);
	else fprintf(stderr, "%s-pass-cn, cn-%u, hn-%u\n", cmd, cn, hn);
}

// Assembly:
movq %rsi, %rdx
movzwl 0x8(%rdi), %eax
movzwl 0x4(%rdi,%rax,2), %r8d
movl (%rdi), %eax
xorl %esi, %esi
xorl %ecx, %ecx
btl %esi, %eax
adcl $0x0, %ecx
incl %esi
cmpl $0x20, %esi
jne 0x1f41e
cmpl %r8d, %ecx
movq 0x26abab(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x211d4a(%rip), %rax    # 0x231189
leaq 0x211d28(%rip), %rsi    # 0x23116e
cmoveq %rax, %rsi
xorl %eax, %eax
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/rcut.cpp
// Function: print_mcgg_node(mc_match_t const*, mcgg_svaux_t*, unsigned int)
void print_mcgg_node(const mc_match_t *ma, mcgg_svaux_t *b, uint32_t id)
{
	fprintf(stderr, "[M::%s::utg%.6ul-hap%u]\n", __func__, id, b->s[id].s);
	w_t w[128];
	uint32_t o, n, i, hn = (1<<b->z->hapN);
	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) w[b->s[ma_y(ma->ma.a[o + i])].s] += ma->ma.a[o + i].w;
	for (i = 0; i < hn; i++) fprintf(stderr, "w[%u]-%f, z[%u]-%f\n", i, w[i], i, mcp_de(*(b->z), id, i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x26ab6f(%rip), %r13    # 0x289fe0
movq (%r13), %rdi
movq 0x50(%rsi), %rax
movl %edx, %ebp
movq %rbp, %rcx
shlq $0x5, %rcx
movl (%rax,%rcx), %r8d
leaq 0x211967(%rip), %rsi    # 0x230df4
leaq 0x211d0f(%rip), %rdx    # 0x2311a3
movl %ebx, %ecx
xorl %eax, %eax
callq 0x22b0
movq 0x40(%r14), %rax
movb 0x8(%rax), %cl
pushq $0x1
popq %r12
shlq %cl, %r12
movq %r12, %rdx
shlq $0x3, %rdx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x20e0
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %rsi
testl %esi, %esi
je 0x1f501
movq %rsi, %rax
shrq $0x20, %rax
movq 0x28(%r15), %rcx
movq 0x50(%r14), %rdx
movl %esi, %esi
movl %eax, %edi
shlq $0x4, %rdi
movsd 0x8(%rcx,%rdi), %xmm0
movl (%rcx,%rdi), %edi
shlq $0x5, %rdi
movl (%rdx,%rdi), %edi
addsd (%rsp,%rdi,8), %xmm0
movsd %xmm0, (%rsp,%rdi,8)
incq %rax
decq %rsi
jne 0x1f4d9
movl %r12d, %ebp
xorl %r15d, %r15d
leaq 0x21190d(%rip), %r12    # 0x230e1b
movq (%r13), %rdi
movq 0x40(%r14), %rax
movb 0x8(%rax), %cl
movl %ebx, %edx
shll %cl, %edx
movsd (%rsp,%r15,8), %xmm0
movq (%rax), %rax
addl %r15d, %edx
movsd (%rax,%rdx,8), %xmm1
movq %r12, %rsi
movl %r15d, %edx
movl %r15d, %ecx
movb $0x2, %al
callq 0x22b0
incq %r15
cmpq %r15, %rbp
jne 0x1f50e
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/rcut.cpp
// Function: mc_solve_core_genral(mc_opt_t const*, mc_gg_t*, unsigned int)
void mc_solve_core_genral(const mc_opt_t *opt, mc_gg_t *mg, uint32_t hapN)
{
	double index_time = yak_realtime();
	uint32_t st, i;
	mcgg_svaux_t *b;
	mc_g_cc(mg->e);
	b = mcgg_svaux_init(mg, opt->seed, hapN);
	// 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) {
			mcgg_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_write_info(g, b);
	mcgg_svaux_destroy(b);
	fprintf(stderr, "[M::%s::%.3f] ==> Partition\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1303c7
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %r15
movq %r15, %rdi
callq 0x162d3f
movq %rax, 0x30(%r15)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x169769
movq %rax, %r15
movq 0x10(%rbx), %rax
movl 0x38(%rax), %edx
testl %edx, %edx
je 0x1f5df
pushq $0x1
popq %rbp
xorl %ecx, %ecx
cmpl %edx, %ebp
je 0x1f5bc
movq 0x30(%rax), %rax
movl %ecx, %edx
movl %ebp, %esi
movq (%rax,%rsi,8), %rsi
xorq (%rax,%rdx,8), %rsi
shrq $0x20, %rsi
je 0x1f5d2
movl %ebp, %r8d
subl %ecx, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x16a136
movl %ebp, %ecx
incl %ebp
movq 0x10(%rbx), %rax
movl 0x38(%rax), %edx
cmpl %edx, %ebp
jbe 0x1f5a2
movq %r15, %rdi
callq 0x169894
movq 0x26a9f2(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd (%rsp), %xmm0
leaq 0x211a7a(%rip), %rsi    # 0x23107c
leaq 0x211be9(%rip), %rdx    # 0x2311f2
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22b0