LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_utg_hap(ma_ug_t*, asg_t*, unsigned int, ma_hit_t_alloc*, R_to_U*)
void print_utg_hap(ma_ug_t *ug, asg_t* read_g, uint32_t uid, ma_hit_t_alloc* reverse_sources, 
R_to_U* ruIndex)
{
    
    uint32_t k, rId, qn, i, is_Unitig;
    ma_utg_t* u = &(ug->u.a[uid]);
    fprintf(stderr, "\nuid: %u, u->n: %u\n", uid, u->n);
    for (k = 0; k < u->n; k++)
    {
        rId = u->a[k]>>33;
        fprintf(stderr, "self[%u]: %u\n", k, rId);
    }

    for (k = 0; k < u->n; k++)
    {
        qn = u->a[k]>>33;
        fprintf(stderr, "****self[%u]: %u, Len: %u\n", k, qn, reverse_sources[qn].length);
        for (i = 0; i < reverse_sources[qn].length; i++)
        {
            rId = Get_tn(reverse_sources[qn].buffer[i]);
            if(read_g->seq[rId].del == 1)
            {
                ///get the id of read that contains it 
                get_R_to_U(ruIndex, rId, &rId, &is_Unitig);
                if(rId == (uint32_t)-1 || is_Unitig == 1 || read_g->seq[rId].del == 1) continue;
            }
            fprintf(stderr, "hap[%u]: %u\n", i, rId);
        }
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rsi, %r15
movq 0x10(%rdi), %r14
movl %edx, %eax
imulq $0x28, %rax, %r12
leaq (%r14,%r12), %r13
movq 0x27c75a(%rip), %rbp    # 0x289fe0
movq (%rbp), %rdi
movl 0x10(%r14,%r12), %ecx
leaq 0x21efe7(%rip), %rsi    # 0x22c87d
xorl %eax, %eax
callq 0x22b0
cmpl $0x0, 0x10(%r14,%r12)
movq %r13, %r14
je 0xd8db
leaq 0x21efe2(%rip), %r12    # 0x22c891
xorl %r13d, %r13d
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rcx
shrq $0x21, %rcx
movq (%rbp), %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x22b0
incq %r13
movl 0x10(%r14), %eax
cmpq %rax, %r13
jb 0xd8b2
cmpl $0x0, 0x10(%r14)
je 0xd9ca
xorl %ebp, %ebp
movq %r14, 0x10(%rsp)
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %rcx
shrq $0x21, %rcx
movq 0x27c6e0(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
imulq $0x18, %rcx, %r14
movq 0x8(%rsp), %r12
movl 0xc(%r12,%r14), %r8d
leaq 0x21ef87(%rip), %rsi    # 0x22c89f
movl %ebp, %edx
xorl %eax, %eax
callq 0x22b0
pushq $-0x1
popq %rdi
cmpl $0x0, 0xc(%r12,%r14)
je 0xd9b5
addq 0x8(%rsp), %r14
pushq $0xc
popq %r13
xorl %r12d, %r12d
movq (%r14), %rax
movl (%rax,%r13), %ecx
movq 0x20(%r15), %rax
cmpl $0x0, (%rax,%rcx,8)
jns 0xd995
cmpq %rcx, (%rbx)
jbe 0xd96b
movq 0x8(%rbx), %rdx
movl (%rdx,%rcx,4), %edx
cmpl $-0x1, %edx
je 0xd96b
movl %edx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shrl $0x1f, %edx
jmp 0xd96f
xorl %edx, %edx
movl %edi, %ecx
cmpl $-0x1, %ecx
sete %sil
orb %dl, %sil
jne 0xd983
movl %ecx, %edx
cmpl $0x0, (%rax,%rdx,8)
jns 0xd995
incq %r12
movl 0xc(%r14), %eax
addq $0x28, %r13
cmpq %rax, %r12
jb 0xd93c
jmp 0xd9b5
movq 0x27c644(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x21ef14(%rip), %rsi    # 0x22c8ba
movl %r12d, %edx
xorl %eax, %eax
callq 0x22b0
pushq $-0x1
popq %rdi
jmp 0xd983
incq %rbp
movq 0x10(%rsp), %r14
movl 0x10(%r14), %eax
cmpq %rax, %rbp
jb 0xd8ed
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/Overlaps.cpp
// Function: prt_dbg_gfa(asg_t*, char const*, ma_sub_t*, ma_hit_t_alloc*, R_to_U*, long, long)
void prt_dbg_gfa(asg_t *sg, const char *suffix, ma_sub_t *cov, ma_hit_t_alloc* src, R_to_U* ruIndex, int64_t max_hang, int64_t min_ovlp)
{
    char *o_file = get_outfile_name(asm_opt.output_file_name);
    char* gfa_name; MALLOC(gfa_name, strlen(o_file)+strlen(suffix)+50); sprintf(gfa_name, "%s.%s", o_file, suffix);
    print_debug_gfa(sg, NULL, cov, gfa_name, src, ruIndex, max_hang, min_ovlp, 0, 0, 1);
    free(gfa_name); free(o_file);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
movl 0x50(%rsp), %eax
movq %rax, 0x8(%rsp)
leaq 0x27b716(%rip), %rax    # 0x28a758
movq 0x10(%rax), %rdi
callq 0xffed8
movq %rax, %r14
movq %rax, %rdi
callq 0x2090
movq %rax, %rbx
movq %r15, %rdi
callq 0x2090
leaq (%rbx,%rax), %rdi
addq $0x32, %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x21ddaa(%rip), %rsi    # 0x22ce22
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2050
subq $0x8, %rsp
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq 0x8(%rsp), %r9
pushq $0x1
pushq $0x0
pushq $0x0
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0xa632
addq $0x30, %rsp
movq %rbx, %rdi
callq 0x2220
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_peak_line(int, int, int, long)
void print_peak_line(int c, int x, int exceed, int64_t cnt)
{
	int j;
	if (c >= 0) fprintf(stderr, "[M::%s] %5d: ", __func__, c);
	else fprintf(stderr, "[M::%s] %5s: ", __func__, "rest");
	for (j = 0; j < x; ++j) fputc('*', stderr);
	if (exceed) fputc('>', stderr);
	fprintf(stderr, " %lld\n", (long long)cnt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %ecx
movq 0x2778b8(%rip), %r12    # 0x289fe0
movq (%r12), %rdi
testl %ecx, %ecx
js 0x12747
leaq 0x21adc1(%rip), %rsi    # 0x22d4f8
leaq 0x21adc8(%rip), %rdx    # 0x22d506
xorl %eax, %eax
callq 0x22b0
jmp 0x12763
leaq 0x21adc8(%rip), %rsi    # 0x22d516
leaq 0x21adb1(%rip), %rdx    # 0x22d506
leaq 0x21adc8(%rip), %rcx    # 0x22d524
xorl %eax, %eax
callq 0x22b0
testl %r14d, %r14d
jle 0x1277d
pushq $0x2a
popq %r15
movq (%r12), %rsi
movl %r15d, %edi
callq 0x2270
decl %r14d
jne 0x1276c
testl %ebp, %ebp
je 0x1278d
movq (%r12), %rsi
pushq $0x3e
popq %rdi
callq 0x2270
movq (%r12), %rdi
leaq 0x21a33a(%rip), %rsi    # 0x22cad2
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_peak(long long*, long long, long long)
void print_peak(long long* cov_buf, long long cov_buf_length, long long max_i)
{
    long long i;
    const long long hist_max = 100;
    // print histogram
	for (i = 0; i < cov_buf_length; ++i) 
    {
		long long x, exceed = 0;
		x = (int)((double)hist_max * cov_buf[i] / cov_buf[max_i] + .499);
		if (x > hist_max) exceed = 1, x = hist_max; // may happen if cnt[2] is higher
		if (i > max_i && x == 0) break;
		print_peak_line(i, x, exceed, cov_buf[i]);
	}
	{
		long long x, exceed = 0;
		long long rest = 0;
		for (; i < cov_buf_length; ++i) rest += cov_buf[i];
		x = (int)((double)hist_max * rest / cov_buf[max_i] + .499);
		if (x > hist_max) exceed = 1, x = hist_max;
		print_peak_line(-1, x, exceed, rest);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
pushq $0x64
popq %rbx
xorl %r13d, %r13d
testq %rsi, %rsi
jle 0x12815
movq (%r15,%r13,8), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0x21acc8(%rip), %xmm0   # 0x22d4a0
cvtsi2sdq (%r15,%r14,8), %xmm1
divsd %xmm1, %xmm0
addsd 0x20f826(%rip), %xmm0   # 0x222010
cvttsd2si %xmm0, %esi
cmpq %r14, %r13
jle 0x127f7
testl %esi, %esi
je 0x12815
xorl %edx, %edx
cmpl $0x64, %esi
cmovgel %ebx, %esi
setg %dl
movl %r13d, %edi
callq 0x1270f
incq %r13
cmpq %r13, %r12
jne 0x127c7
movq %r12, %r13
xorl %ecx, %ecx
cmpq %r12, %r13
jge 0x12828
addq (%r15,%r13,8), %rcx
incq %r13
cmpq %r13, %r12
jne 0x1281c
cvtsi2sd %rcx, %xmm0
mulsd 0x21ac6b(%rip), %xmm0   # 0x22d4a0
cvtsi2sdq (%r15,%r14,8), %xmm1
divsd %xmm1, %xmm0
addsd 0x20f7c9(%rip), %xmm0   # 0x222010
cvttsd2si %xmm0, %eax
xorl %edx, %edx
cmpl $0x65, %eax
setge %dl
cmpl $0x64, %eax
cmovll %eax, %ebx
pushq $-0x1
popq %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1270f
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_debug_unitig(ma_utg_t*, unsigned long*, char const*)
void print_debug_unitig(ma_utg_t *xReads, uint64_t* position_index, const char* infor)
{
    uint32_t k;
    fprintf(stderr, "\n%s: n = %u\n", infor, xReads->n);
    for (k = 0; k < xReads->n; k++)
    {
        fprintf(stderr, "(%u)v: %u, len: %u, index: %u, pos: %u\n", 
        k, (uint32_t)(xReads->a[k]>>32), (uint32_t)xReads->a[k], (uint32_t)(position_index[xReads->a[k]>>33]),
        (uint32_t)(position_index[xReads->a[k]>>33]>>32));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27775a(%rip), %r13    # 0x289fe0
movq (%r13), %rdi
movl 0x10(%r14), %ecx
leaq 0x21ac94(%rip), %rsi    # 0x22d529
xorl %eax, %eax
callq 0x22b0
cmpl $0x0, 0x10(%r14)
je 0x128ee
leaq 0x21ac8c(%rip), %r15    # 0x22d536
xorl %r12d, %r12d
movq (%r13), %rdi
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %r8
movq %r8, %rcx
shrq $0x20, %rcx
movq %r8, %rax
shrq $0x21, %rax
movq (%rbx,%rax,8), %r9
movq %r9, %rax
shrq $0x20, %rax
movl %eax, (%rsp)
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x22b0
incq %r12
movl 0x10(%r14), %eax
cmpq %rax, %r12
jb 0x128ad
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_asg_arc_t_offset(asg_arc_t_offset*, long long, char const*)
void print_asg_arc_t_offset(asg_arc_t_offset* x, long long n, const char* info)
{
    fprintf(stderr,"\n\n(%s)n: %lld\n", info, n);
    long long i, x_off, y_off;
    for (i = 0; i < n; i++)
    {
        x_off = (long long)(x[i].Off>>32);
        y_off = (long long)((uint32_t)x[i].Off);
        fprintf(stderr, "i: %lld, x_off: %lld, y_off: %lld, weight: %lu, rev: %u, ol: %u\n", 
        i, x_off, y_off, (unsigned long)x[i].weight, x[i].x.el, x[i].x.ol);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2776cc(%rip), %r13    # 0x289fe0
movq (%r13), %rdi
leaq 0x21ac3f(%rip), %rsi    # 0x22d55e
movq %rbx, %rcx
xorl %eax, %eax
callq 0x22b0
testq %rbx, %rbx
jle 0x1297e
addq $0x20, %r14
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
leaq 0x21ac2f(%rip), %r15    # 0x22d56d
xorl %r12d, %r12d
movq -0x8(%r14), %rcx
movq (%r14), %r9
movl %ecx, %r8d
shrq $0x20, %rcx
movq (%r13), %rdi
movzbl -0xe(%r14), %r10d
movl -0x14(%r14), %r11d
andl %ebp, %r11d
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x22b0
popq %rcx
popq %rdx
incq %r12
addq $0x28, %r14
cmpq %r12, %rbx
jne 0x12941
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_hap_paf(ma_ug_t*, hap_overlaps*)
void print_hap_paf(ma_ug_t *ug, hap_overlaps* ovlp)
{
    fprintf(stderr, "utg%.6d%c\t%u(%u)\t%u(%u)\t%u(%u)\t%c\tutg%.6d%c\t%u(%u)\t%u(%u)\t%u(%u)\t%u\t%u\t%lld(%u)\n", 
    ovlp->xUid+1, "lc"[ug->u.a[ovlp->xUid].circ], ug->u.a[ovlp->xUid].len, ug->u.a[ovlp->xUid].n,
    ovlp->x_beg_pos, ovlp->x_beg_id, ovlp->x_end_pos, ovlp->x_end_id, "+-"[ovlp->rev], 
    ovlp->yUid+1, "lc"[ug->u.a[ovlp->yUid].circ], ug->u.a[ovlp->yUid].len, ug->u.a[ovlp->yUid].n,
    ovlp->y_beg_pos, ovlp->y_beg_id, ovlp->y_end_pos, ovlp->y_end_id, ovlp->type, ovlp->weight, 
    ovlp->score, ovlp->status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r10
movq %rdi, %rax
movq 0x277638(%rip), %rcx    # 0x289fe0
movq (%rcx), %rdi
movl 0x24(%rsi), %ecx
leal 0x1(%rcx), %edx
movq 0x10(%rax), %rax
imulq $0x28, %rcx, %rcx
movl (%rax,%rcx), %r8d
movl 0x10(%rax,%rcx), %r9d
movl %r8d, %ecx
shrl $0x1f, %ecx
leaq 0x215c5c(%rip), %rsi    # 0x22862b
movsbl (%rcx,%rsi), %ecx
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
andl %ebx, %r8d
movl 0x14(%r10), %r11d
movq %r11, 0x38(%rsp)
movl 0x4(%r10), %r11d
movq %r11, 0x40(%rsp)
movzbl (%r10), %r11d
leaq 0x2137cb(%rip), %r14    # 0x2261c3
movsbl (%r11,%r14), %r11d
movq %r11, 0x30(%rsp)
movl 0x28(%r10), %r14d
imulq $0x28, %r14, %r11
movl (%rax,%r11), %r13d
movl 0x10(%rax,%r11), %eax
movq %rax, 0x10(%rsp)
movl %r13d, %eax
shrl $0x1f, %eax
movsbl (%rax,%rsi), %eax
movq %rax, 0x18(%rsp)
movl 0x8(%r10), %eax
movq %rax, 0x28(%rsp)
andl %ebx, %r13d
movl 0x18(%r10), %eax
movq %rax, 0x20(%rsp)
leal 0x1(%r14), %eax
movq %rax, 0x8(%rsp)
movl 0xc(%r10), %eax
movq %rax, (%rsp)
movl 0x1c(%r10), %r15d
movl 0x10(%r10), %r12d
movl 0x20(%r10), %ebp
movzbl 0x1(%r10), %r11d
movl 0x2c(%r10), %ebx
movzbl 0x2(%r10), %r14d
subq $0x8, %rsp
leaq 0x21ab79(%rip), %rsi    # 0x22d5eb
xorl %eax, %eax
pushq %r14
pushq 0x30(%r10)
pushq %rbx
pushq %r11
pushq %rbp
pushq %r12
pushq %r15
pushq 0x40(%rsp)
pushq 0x58(%rsp)
pushq %r13
pushq 0x70(%rsp)
pushq 0x68(%rsp)
pushq 0x98(%rsp)
pushq 0x90(%rsp)
pushq 0xa0(%rsp)
pushq 0xb8(%rsp)
pushq 0xc8(%rsp)
callq 0x22b0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_chain_data(int*, int*, int*, long long)
void print_chain_data(int32_t* Scores, int32_t* Pres, int32_t* Begs, long long n)
{
    fprintf(stderr,"*****\nn_chain: %lld\n", n);
    long long i;
    for (i = 0; i < n; i++)
    {
        fprintf(stderr, "i: %lld, Scores: %d, Pres: %d, Begs: %d\n", 
        i, Scores[i], Pres[i], Begs[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x2774f4(%rip), %r13    # 0x289fe0
movq (%r13), %rdi
leaq 0x21ab45(%rip), %rsi    # 0x22d63c
movq %rcx, %rdx
xorl %eax, %eax
callq 0x22b0
testq %rbx, %rbx
jle 0x12b31
xorl %ebp, %ebp
movq (%r13), %rdi
movl (%r12,%rbp,4), %ecx
movl (%r15,%rbp,4), %r8d
movl (%r14,%rbp,4), %r9d
leaq 0x21ab32(%rip), %rsi    # 0x22d651
movq %rbp, %rdx
xorl %eax, %eax
callq 0x22b0
incq %rbp
cmpq %rbp, %rbx
jne 0x12b08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_all_purge_ovlp(ma_ug_t*, hap_overlaps_list*, char const*)
void print_all_purge_ovlp(ma_ug_t *ug, hap_overlaps_list* all_ovlp, const char* cmd)
{
    fprintf(stderr, "\n%s--->ug->u.n: %u\n", cmd, (uint32_t)ug->u.n);
    uint32_t v, uId, i;
    for (v = 0; v < all_ovlp->num; v++)
    {
        uId = v;
        for (i = 0; i < all_ovlp->x[uId].a.n; i++)
        {
            print_hap_paf(ug, &(all_ovlp->x[uId].a.a[i]));
        }
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x277488(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
movl (%r14), %ecx
leaq 0x21ad35(%rip), %rsi    # 0x22d89a
xorl %eax, %eax
callq 0x22b0
cmpl $0x0, 0x8(%rbx)
je 0x12bb6
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movq (%rbx), %rax
imulq $0x18, %r15, %r12
cmpq $0x0, (%rax,%r12)
je 0x12bab
movl %ebp, %r13d
xorl %esi, %esi
shlq $0x6, %rsi
addq 0x10(%rax,%r12), %rsi
movq %r14, %rdi
callq 0x1298d
movl %r13d, %esi
movq (%rbx), %rax
incl %r13d
cmpq %rsi, (%rax,%r12)
ja 0x12b8b
incq %r15
movl 0x8(%rbx), %eax
cmpq %rax, %r15
jb 0x12b78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_p_g_t_interval(p_g_t*, hap_cov_t*)
void print_p_g_t_interval(p_g_t* pg, hap_cov_t *cov)
{
    fprintf(stderr, "----------[M::%s]----------\n", __func__);
    uint32_t i, v, sid, eid;
    p_node_t *t = NULL;
    ma_utg_t *u = NULL;

    for (v = 0; v < pg->pg_het_node.n; v++)
    {
        t = &(pg->pg_het_node.a[v]);
        sid = t->nodeBeg;
        eid = t->nodeEnd;

        u = &(pg->ug->u.a[t->c_ug_id]);
        fprintf(stderr, "\nu->n=%u, sid=%u, eid=%u, h_status=%u\n", 
                                                (uint32_t)u->n, sid, eid, t->h_status);
        for (i = sid; i <= eid; i++)
        {
            fprintf(stderr, "id:i:%u------>utg%.6ul\n", 
                        (uint32_t)(u->a[i]>>33), (get_origin_uid(u->a[i]>>32, cov->t_ch, NULL, NULL)>>1)+1);
        }
    }
    fprintf(stderr, "----------[M::%s]----------\n", __func__);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x277108(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x21dccd(%rip), %rsi    # 0x230baf
leaq 0x21aa28(%rip), %rdx    # 0x22d911
xorl %eax, %eax
callq 0x22b0
cmpq $0x0, 0x8(%r15)
je 0x12fc1
leaq 0x21aa4b(%rip), %r12    # 0x22d94d
xorl %eax, %eax
xorl %r14d, %r14d
movq %r15, 0x8(%rsp)
movq (%r15), %rcx
movq 0x18(%r15), %rsi
imulq $0x1c, %rax, %rax
movl 0x8(%rsi,%rax), %ebp
movl 0xc(%rsi,%rax), %r13d
movq 0x10(%rcx), %r15
movl 0x18(%rsi,%rax), %ecx
imulq $0x28, %rcx, %rdx
movq 0x2770ad(%rip), %rcx    # 0x289fe0
movq (%rcx), %rdi
movq %rdx, 0x10(%rsp)
movl 0x10(%r15,%rdx), %edx
movl 0x14(%rsi,%rax), %r9d
leaq 0x21a9da(%rip), %rsi    # 0x22d926
movl %ebp, %ecx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x22b0
cmpl %r13d, %ebp
ja 0x12fac
addq 0x10(%rsp), %r15
movq 0x18(%r15), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rdx
shrq $0x21, %rdx
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rsi
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq $-0x1, (%rsi,%rdx,8)
je 0x12f91
movq (%rax), %rax
movl (%rax,%rdx,4), %ecx
shrl %ecx
incl %ecx
movq 0x277048(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x22b0
incl %ebp
cmpl %r13d, %ebp
jbe 0x12f62
incl %r14d
movq %r14, %rax
movq 0x8(%rsp), %r15
cmpq %r14, 0x8(%r15)
ja 0x12f0c
movq 0x277018(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x21dbdd(%rip), %rsi    # 0x230baf
leaq 0x21a938(%rip), %rdx    # 0x22d911
xorl %eax, %eax
addq $0x18, %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/htab.cpp
// Function: ha_ft_ul_gen(hifiasm_opt_t const*, ma_utg_v*, int, int, int)
void *ha_ft_ul_gen(const hifiasm_opt_t *asm_opt, ma_utg_v *us, int k, int w, int cutoff)
{
	yak_ft_t *flt_tab;
    ha_ct_t *h;
	///HAF_COUNT_EXACT ---> no bf; HAF_COUNT_ALL ---> no minimizer
	h = ha_count(asm_opt, HAF_COUNT_ALL|HAF_UG_READ, !(asm_opt->flag&HA_F_NO_HPC), k, w, NULL, NULL, NULL, us, 0, NULL, 0);
	
	// cutoff = (int)(asm_opt->hom_cov * asm_opt->high_factor);
    if (cutoff > YAK_MAX_COUNT - 1) cutoff = YAK_MAX_COUNT - 1;
	// fprintf(stderr, "[M::%s::] cutoff->%d\n\n", __func__, cutoff);
	ha_ct_shrink(h, cutoff, YAK_MAX_COUNT, asm_opt->thread_num);
	flt_tab = gen_hh(h, asm_opt->max_kmer_cnt);
	ha_ct_destroy(h);
	fprintf(stderr, "[M::%s::%.3f*%.2f@%.3fGB] ==> filtered out %ld k-mers occurring %d or more times\n", __func__,
            yak_realtime(), yak_cpu_usage(), yak_peakrss_in_gb(), (long)kh_size(flt_tab), cutoff);
	return (void*)flt_tab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movl %ecx, %r8d
movl %edx, %ecx
movq %rdi, %r14
movl (%rdi), %edx
notl %edx
andl $0x1, %edx
movq %rsi, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andl $0x0, 0x28(%rsp)
andq $0x0, 0x20(%rsp)
andl $0x0, 0x18(%rsp)
movl $0x82, %esi
xorl %r9d, %r9d
callq 0x11445e
movq %rax, %r15
movl $0xffe, %ebx            # imm = 0xFFE
cmpl %ebx, %ebp
cmovll %ebp, %ebx
movl 0x7c(%r14), %ecx
movq %rax, %rdi
movl %ebx, %esi
movl $0xfff, %edx            # imm = 0xFFF
callq 0x13ee8
movl 0xb0(%r14), %esi
movq %r15, %rdi
callq 0x114bd0
movq %rax, %r14
movq %r15, %rdi
callq 0x114db6
movq 0x276152(%rip), %rax    # 0x289fe0
movq (%rax), %r15
callq 0x1303c7
movsd %xmm0, 0x40(%rsp)
callq 0x130490
movsd %xmm0, 0x38(%rsp)
callq 0x13045d
movaps %xmm0, %xmm2
movl 0x4(%r14), %ecx
leaq 0x219ed4(%rip), %rsi    # 0x22dd8e
leaq 0x219f1f(%rip), %rdx    # 0x22dde0
movq %r15, %rdi
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movl %ebx, %r8d
movb $0x3, %al
callq 0x22b0
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_shrink(ha_ct_t*, int, int, int)
static void ha_ct_shrink(ha_ct_t *h, int min, int max, int n_thread)
{
	int i;
	shrink_aux_t a;
	a.h = h, a.min = min, a.max = max;
	///still start 4096 threads
	kt_for(n_thread, worker_ct_shrink, &a, 1<<h->pre);
	for (i = 0, h->tot = 0; i < 1<<h->pre; ++i)
		h->tot += kh_size(h->h[i].h);
	fprintf(stderr, "[M::%s::%.3f*%.2f] ==> counted %ld distinct minimizer k-mers\n", __func__,
			yak_realtime(), yak_cpu_usage(), (long)h->tot);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %ecx, %eax
movq %rdi, %rbx
leaq 0x10(%rsp), %r8
movq %rdi, 0x8(%r8)
movl %esi, (%r8)
movl %edx, 0x4(%r8)
movb 0x4(%rdi), %cl
pushq $0x1
popq %rbp
movl %ebp, %edx
shll %cl, %edx
movslq %edx, %rcx
leaq 0x104b32(%rip), %rsi    # 0x118a4b
movl %eax, %edi
movq %r8, %rdx
callq 0x1047b4
andq $0x0, 0x10(%rbx)
movl 0x4(%rbx), %ecx
cmpl $0x1f, %ecx
je 0x13f5f
movl %ebp, %eax
shll %cl, %eax
movq 0x10(%rbx), %rcx
movq 0x20(%rbx), %rdx
cmpl $0x2, %eax
cmovll %ebp, %eax
shlq $0x4, %rax
xorl %esi, %esi
movq (%rdx,%rsi), %rdi
movl 0x4(%rdi), %edi
addq %rdi, %rcx
addq $0x10, %rsi
cmpq %rsi, %rax
jne 0x13f48
movq %rcx, 0x10(%rbx)
movq 0x27607a(%rip), %rax    # 0x289fe0
movq (%rax), %r14
callq 0x1303c7
movsd %xmm0, 0x8(%rsp)
callq 0x130490
movaps %xmm0, %xmm1
movq 0x10(%rbx), %rcx
leaq 0x219e94(%rip), %rsi    # 0x22de1b
leaq 0x21a471(%rip), %rdx    # 0x22e3ff
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x22b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ft_ug_gen(hifiasm_opt_t const*, ma_utg_v*, int, int, int, int, int)
void *ha_ft_ug_gen(const hifiasm_opt_t *asm_opt, ma_utg_v *us, int is_HPC, int k, int w, int min_freq, int max_freq)
{
	yak_ft_t *flt_tab;
	ha_ct_t *h;
	///HAF_COUNT_EXACT ---> no bf; HAF_COUNT_ALL ---> no minimizer
	h = ha_count(asm_opt, HAF_COUNT_ALL|HAF_UG_READ|HAF_COUNT_EXACT, is_HPC, k, w, NULL, NULL, NULL, us, 0, NULL, 0);
	ha_ct_shrink(h, min_freq, max_freq>YAK_MAX_COUNT-1?YAK_MAX_COUNT-1:max_freq, asm_opt->thread_num);
	flt_tab = gen_hh(h, YAK_MAX_COUNT);
	ha_ct_destroy(h);
	return (void*)flt_tab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movq %rdi, %r14
movl 0x60(%rsp), %ebp
movq %rsi, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andl $0x0, 0x28(%rsp)
andq $0x0, 0x20(%rsp)
andl $0x0, 0x18(%rsp)
movl $0x83, %esi
xorl %r9d, %r9d
callq 0x11445e
movq %rax, %r15
movl $0xffe, %edx            # imm = 0xFFE
cmpl %edx, %ebp
cmovll %ebp, %edx
movl 0x7c(%r14), %ecx
movq %rax, %rdi
movl %ebx, %esi
callq 0x13ee8
movq %r15, %rdi
movl $0xfff, %esi            # imm = 0xFFF
callq 0x114bd0
movq %rax, %rbx
movq %r15, %rdi
callq 0x114db6
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_ug_gen(hifiasm_opt_t const*, void const*, ma_utg_v*, int, int, int, int)
ha_pt_t *ha_pt_ug_gen(const hifiasm_opt_t *asm_opt, const void *flt_tab, ma_utg_v *us, int is_HPC, int k, int w, int min_freq)
{
	ha_ct_t *ct;
	ha_pt_t *pt;
	///HAF_COUNT_EXACT: no bf
	ct = ha_count(asm_opt, HAF_COUNT_EXACT|HAF_UG_READ, is_HPC, k, w, NULL, flt_tab, NULL, us, 0, NULL, 1);
	fprintf(stderr, "[M::%s::%.3f*%.2f] ==> counted %ld distinct minimizer k-mers\n", __func__,
			yak_realtime(), yak_cpu_usage(), (long)ct->tot);
	///minimizer with YAK_MAX_COUNT occ may apper > YAK_MAX_COUNT times, so it may lead to overflow at ha_pt_gen
	ha_ct_shrink(ct, min_freq, YAK_MAX_COUNT - 1, asm_opt->thread_num);

	pt = ha_pt_gen(ct, asm_opt->thread_num, 1);
	ha_count(asm_opt, HAF_COUNT_EXACT|HAF_UG_READ, is_HPC, k, w, pt, flt_tab, NULL, us, 0, NULL, 1);
	//ha_pt_sort(pt, asm_opt->thread_num);
	fprintf(stderr, "[M::%s::%.3f*%.2f] ==> indexed %ld positions\n", __func__,
			yak_realtime(), yak_cpu_usage(), (long)pt->tot_pos);
	return pt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, 0x10(%rsp)
movq %rsi, (%rsp)
movq %rdi, %r13
subq $0x30, %rsp
andq $0x0, 0x20(%rsp)
pushq $0x1
popq %rax
andl $0x0, 0x18(%rsp)
movl %eax, 0x28(%rsp)
andq $0x0, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, (%rsp)
movl $0x81, %esi
movl %ecx, %edx
movl %r8d, %ecx
movl %r9d, %r8d
xorl %r9d, %r9d
callq 0x11445e
addq $0x30, %rsp
movq %rax, %rbx
movq 0x275c35(%rip), %rax    # 0x289fe0
movq (%rax), %r14
callq 0x1303c7
movsd %xmm0, 0x8(%rsp)
callq 0x130490
movaps %xmm0, %xmm1
movq 0x10(%rbx), %rcx
leaq 0x219a4f(%rip), %rsi    # 0x22de1b
leaq 0x219ac1(%rip), %rdx    # 0x22de94
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x22b0
movl 0x7c(%r13), %ecx
movq %rbx, %rdi
movl 0x50(%rsp), %esi
movl $0xffe, %edx            # imm = 0xFFE
callq 0x13ee8
movl 0x7c(%r13), %esi
movq %rbx, %rdi
pushq $0x1
popq %r14
movl %r14d, %edx
callq 0x1131c9
movq %rax, %rbx
movq %r13, %rdi
movl $0x81, %esi
movl %r12d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
movq %rax, %r9
pushq %r14
pushq $0x0
pushq $0x0
pushq 0x28(%rsp)
pushq $0x0
pushq 0x28(%rsp)
callq 0x11445e
addq $0x30, %rsp
movq 0x275b9e(%rip), %rax    # 0x289fe0
movq (%rax), %r14
callq 0x1303c7
movsd %xmm0, (%rsp)
callq 0x130490
movaps %xmm0, %xmm1
movq 0x10(%rbx), %rcx
leaq 0x219a04(%rip), %rsi    # 0x22de66
movq %r14, %rdi
leaq 0x219a28(%rip), %rdx    # 0x22de94
movsd (%rsp), %xmm0
movb $0x2, %al
callq 0x22b0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/hic.cpp
// Function: test_unitig_index(ha_ug_index*, ma_ug_t*)
void test_unitig_index(ha_ug_index* idx, ma_ug_t *ug)
{
    double index_time = yak_realtime();
    uint32_t i, j;
    ma_utg_t *u = NULL;
    hc_pt1_t *h = NULL;
    idx->ug = ug;
    for (i = 0; i < idx->ug->u.n; i++)
    {
        u = &(idx->ug->u.a[i]);
        if(u->m == 0) continue;
        test_hc_pt1(u->s, u->len, i, idx);
    }

    for (i = 0; i < idx->tot; i++)
    {
        h = &(idx->idx_buf[i]);
        for (j = 0; j < h->n; j++)
        {
            if(h->a[j] != (uint64_t)-1)
            {
                fprintf(stderr, "ERROR j\n");
            }
        }
        
    }

    fprintf(stderr, "[M::%s::%.3f] ==> Test has been passed\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1303c7
movsd %xmm0, (%rsp)
movq %r14, (%rbx)
cmpq $0x0, (%r14)
je 0x15600
pushq $0x1
popq %rbp
xorl %edx, %edx
movq 0x10(%r14), %rax
imulq $0x28, %rdx, %rcx
cmpl $0x0, 0xc(%rax,%rcx)
je 0x155f4
addq %rcx, %rax
movq 0x20(%rax), %rdi
movl (%rax), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rcx
callq 0x134365
movl %ebp, %edx
movq (%rbx), %r14
incl %ebp
cmpq %rdx, (%r14)
ja 0x155ce
cmpq $0x0, 0x58(%rbx)
je 0x1566e
xorl %eax, %eax
pushq $0x8
popq %r15
pushq $0x1
popq %r12
xorl %ebp, %ebp
movq 0x78(%rbx), %r13
shlq $0x5, %rax
cmpq $0x0, 0x8(%r13,%rax)
je 0x15663
addq %rax, %r13
pushq $0x1
popq %r14
xorl %eax, %eax
movq 0x10(%r13), %rcx
cmpq $-0x1, (%rcx,%rax,8)
jne 0x15645
movl %r14d, %eax
incl %r14d
cmpq %rax, 0x8(%r13)
ja 0x1562c
jmp 0x15663
movq 0x274994(%rip), %rax    # 0x289fe0
movq (%rax), %rcx
leaq 0x219a1b(%rip), %rdi    # 0x22f071
movq %r15, %rsi
movq %r12, %rdx
callq 0x2410
jmp 0x15637
incl %ebp
movq %rbp, %rax
cmpq %rbp, 0x58(%rbx)
ja 0x15613
movq 0x27496b(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd (%rsp), %xmm0
leaq 0x2199f1(%rip), %rsi    # 0x22f07a
leaq 0x219a12(%rip), %rdx    # 0x22f0a2
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/hic.cpp
// Function: dedup_hits(kvec_pe_hit*, unsigned long)
void dedup_hits(kvec_pe_hit* hits, uint64_t is_dup)
{
    double index_time = yak_realtime();
    uint64_t k, l, m = 0, cur;
    radix_sort_pe_hit_an1(hits->a.a, hits->a.a + hits->a.n);
    for (k = 1, l = 0; k <= hits->a.n; ++k) 
    {   
        if (k == hits->a.n || hits->a.a[k].s != hits->a.a[l].s) 
        {
            if (k - l > 1) radix_sort_pe_hit_an2(hits->a.a + l, hits->a.a + k);
            if(is_dup)
            {
                cur = (uint64_t)-1;
                while (l < k)
                {
                    if(hits->a.a[l].e != cur)
                    {
                        cur = hits->a.a[l].e;
                        hits->a.a[m++] = hits->a.a[l];
                    }
                    l++;
                }
            }
            l = k;
        }
    }
    if(is_dup) hits->a.n = m;
    fprintf(stderr, "[M::%s::%.3f] ==> Dedup\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1303c7
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x10(%rbx), %rdi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x130e2c
movq (%rbx), %rax
testq %rax, %rax
jne 0x158d0
xorl %r15d, %r15d
jmp 0x159a1
pushq $0x1
popq %r12
xorl %r15d, %r15d
pushq $-0x1
popq %r13
xorl %ebp, %ebp
cmpq %rax, %r12
je 0x15902
movq 0x10(%rbx), %rax
movq %r12, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rcx
movq %rbp, %rdx
shlq $0x5, %rdx
cmpq (%rax,%rdx), %rcx
je 0x15992
movq %r12, %rax
subq %rbp, %rax
cmpq $0x2, %rax
jb 0x1592b
movq 0x10(%rbx), %rax
movq %rbp, %rdi
shlq $0x5, %rdi
addq %rax, %rdi
movq %r12, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
callq 0x1310a4
testq %r14, %r14
setne %al
cmpq %rbp, %r12
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1598f
movq %rbp, %rax
shlq $0x5, %rax
orq $0x8, %rax
movq %r13, %rcx
movq 0x10(%rbx), %rsi
movq (%rsi,%rax), %rdx
cmpq %rcx, %rdx
je 0x15983
leaq (%rsi,%rax), %rcx
addq $-0x8, %rcx
leaq 0x1(%r15), %rdi
shlq $0x5, %r15
movupd (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rsi,%r15)
movupd %xmm0, (%rsi,%r15)
movq %rdi, %r15
movq %rdx, %rcx
incq %rbp
addq $0x20, %rax
cmpq %rbp, %r12
jne 0x1594c
movq %r12, %rbp
incq %r12
movq (%rbx), %rax
cmpq %rax, %r12
jbe 0x158dd
testq %r14, %r14
je 0x159a9
movq %r15, (%rbx)
movq 0x274630(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd (%rsp), %xmm0
leaq 0x21987b(%rip), %rsi    # 0x22f23f
leaq 0x21988d(%rip), %rdx    # 0x22f258
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/hic.cpp
// Function: sort_hits(kvec_pe_hit*)
void sort_hits(kvec_pe_hit* hits)
{
    double index_time = yak_realtime();
    uint64_t k, l;
    radix_sort_pe_hit_an1(hits->a.a, hits->a.a + hits->a.n);
    for (k = 1, l = 0; k <= hits->a.n; ++k) 
    {   
        if (k == hits->a.n || (hits->a.a[k].s<<1) != (hits->a.a[l].s<<1)) 
        {
            if (k - l > 1) radix_sort_pe_hit_an2(hits->a.a + l, hits->a.a + k);
            l = k;
        }
    }
    fprintf(stderr, "[M::%s::%.3f] ==> Sort\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x1303c7
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rsi
movq 0x10(%rbx), %rdi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x130e2c
movq (%rbx), %rax
testq %rax, %rax
je 0x15a7b
pushq $0x1
popq %r14
pushq $0x20
popq %r15
xorl %edi, %edi
cmpq %rax, %r14
je 0x15a3f
movq 0x10(%rbx), %rax
movq %rdi, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rcx
xorq (%rax,%r15), %rcx
shlq %rcx
testq %rcx, %rcx
je 0x15a66
movq %r14, %rax
subq %rdi, %rax
movq %r14, %rcx
cmpq $0x2, %rax
jb 0x15a69
movq 0x10(%rbx), %rsi
shlq $0x5, %rdi
addq %rsi, %rdi
addq %r15, %rsi
callq 0x1310a4
movq %r14, %rcx
jmp 0x15a69
movq %rdi, %rcx
incq %r14
movq (%rbx), %rax
addq $0x20, %r15
movq %rcx, %rdi
cmpq %rax, %r14
jbe 0x15a1f
movq 0x27455e(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd 0x8(%rsp), %xmm0
leaq 0x2197cc(%rip), %rsi    # 0x22f263
leaq 0x2197dd(%rip), %rdx    # 0x22f27b
movq %rbx, %rdi
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/hic.cpp
// Function: write_hc_links(hc_links*, char const*)
void write_hc_links(hc_links* link, const char *fn)
{
    uint64_t k;
    char *buf = (char*)calloc(strlen(fn) + 25, 1);
	sprintf(buf, "%s.hic.link.bin", fn);
    FILE* fp = fopen(buf, "w");

    fwrite(&link->a.n, sizeof(link->a.n), 1, fp);
    for (k = 0; k < link->a.n; k++)
    {
        fwrite(&link->a.a[k].e.n, sizeof(link->a.a[k].e.n), 1, fp);
        fwrite(link->a.a[k].e.a, sizeof(hc_edge), link->a.a[k].e.n, fp);

        fwrite(&link->a.a[k].f.n, sizeof(link->a.a[k].f.n), 1, fp);
        fwrite(link->a.a[k].f.a, sizeof(hc_edge), link->a.a[k].f.n, fp);
    }
    
    fwrite(&link->enzymes.n, sizeof(link->enzymes.n), 1, fp);
    fwrite(link->enzymes.a, sizeof(uint64_t), link->enzymes.n, fp);
    
    fclose(fp);
    free(buf);
    fprintf(stderr, "[M::%s::] ==> Hi-C linkages have been written\n", __func__);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
pushq $0x1
popq %r12
movq %r12, %rsi
callq 0x2120
movq %rax, %rbx
leaq 0x2191c1(%rip), %rsi    # 0x22f559
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x226052(%rip), %rsi    # 0x23c3fe
movq %rbx, (%rsp)
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
pushq $0x8
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0x2410
cmpq $0x0, (%r14)
je 0x1644a
xorl %ebx, %ebx
xorl %r12d, %r12d
pushq $0x8
popq %r13
pushq $0x1
popq %rbp
movq 0x10(%r14), %rdi
addq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x2410
movq 0x10(%r14), %rax
movq (%rax,%rbx), %rdx
movq 0x10(%rax,%rbx), %rdi
pushq $0x28
popq %rsi
movq %r15, %rcx
callq 0x2410
movq 0x10(%r14), %rax
leaq (%rax,%rbx), %rdi
addq $0x18, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x2410
movq 0x10(%r14), %rax
movq 0x18(%rax,%rbx), %rdx
movq 0x28(%rax,%rbx), %rdi
pushq $0x28
popq %rsi
movq %r15, %rcx
callq 0x2410
incq %r12
addq $0x30, %rbx
cmpq (%r14), %r12
jb 0x163de
leaq 0x18(%r14), %rdi
pushq $0x8
popq %r12
pushq $0x1
popq %rdx
movq %r12, %rsi
movq %r15, %rcx
callq 0x2410
movq 0x18(%r14), %rdx
movq 0x28(%r14), %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x2410
movq %r15, %rdi
callq 0x2190
movq (%rsp), %rdi
callq 0x2220
movq 0x273b55(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x2190d4(%rip), %rsi    # 0x22f569
leaq 0x2190fc(%rip), %rdx    # 0x22f598
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: print_src_dest(unsigned long, min_cut_t*, char const*)
void print_src_dest(uint64_t src, min_cut_t* x, const char* command)
{
    uint64_t i;
    fprintf(stderr, "********************\n%s\n", command);
    if(src >= x->n)
    {
        for (i = 0; i < x->rGraph.a[src].n; i++)
        {
            if(x->rGraph.a[src].a[i].del) continue;
            fprintf(stderr, "utg%.6ul\n", x->rGraph.a[src].a[i].uID + 1);
        }
        
    }
    else
    {
        fprintf(stderr, "utg%.6lul\n", src+1);
    }
    fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!\n");
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x273b17(%rip), %r15    # 0x289fe0
movq (%r15), %rdi
leaq 0x2192fb(%rip), %rsi    # 0x22f7ce
xorl %eax, %eax
callq 0x22b0
cmpq %r14, 0x148(%rbx)
jbe 0x164fc
movq (%r15), %rdi
incq %r14
leaq 0x2192f7(%rip), %rsi    # 0x22f7e7
movq %r14, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x1650b
movq 0x10(%rbx), %rax
imulq $0x18, %r14, %r12
cmpq $0x0, (%rax,%r12)
jne 0x1652e
movq (%r15), %rcx
leaq 0x2192dd(%rip), %rdi    # 0x22f7f2
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2410
pushq $0x18
popq %r13
leaq 0x219441(%rip), %r14    # 0x22f97a
xorl %ebp, %ebp
movq 0x10(%rax,%r12), %rax
cmpb $0x0, (%rax,%r13)
jns 0x1655a
incq %rbp
movq 0x10(%rbx), %rax
addq $0x28, %r13
cmpq (%rax,%r12), %rbp
jb 0x1653b
jmp 0x1650b
movq (%r15), %rdi
movl -0x10(%rax,%r13), %edx
incl %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x22b0
jmp 0x16547
// File: /workspace/github_cpp_makefile_star2_O1/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 0x273a5b(%rip), %rax    # 0x289fe0
movq (%rax), %rcx
leaq 0x219279(%rip), %rdi    # 0x22f808
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
cmpq $0x0, 0xb0(%rbx)
je 0x1663a
xorl %r13d, %r13d
movq 0xf0(%rbx), %rax
cmpb $0x0, (%rax,%r13)
je 0x1662a
movq 0x10(%rbx), %rax
imulq $0x18, %r13, %rbp
cmpq $0x0, (%rax,%rbp)
je 0x1662a
leaq 0x1(%r13), %r15
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x10(%rax,%rbp), %rax
cmpb $0x0, 0x18(%rax,%r12)
js 0x165f1
movl 0x8(%rax,%r12), %ecx
movq 0xf0(%rbx), %rdx
cmpb $0x0, (%rdx,%rcx)
jne 0x16604
incq %r14
movq 0x10(%rbx), %rax
addq $0x28, %r12
cmpq (%rax,%rbp), %r14
jb 0x165d2
jmp 0x1662a
movq 0x2739d5(%rip), %rdx    # 0x289fe0
movq (%rdx), %rdi
incq %rcx
movsd (%rax,%r12), %xmm0
leaq 0x2191fe(%rip), %rsi    # 0x22f81c
movq %r15, %rdx
movb $0x1, %al
callq 0x22b0
jmp 0x165f1
incq %r13
cmpq 0xb0(%rbx), %r13
jb 0x165ab
movq 0x27399f(%rip), %rax    # 0x289fe0
movq (%rax), %rcx
leaq 0x2191bd(%rip), %rdi    # 0x22f808
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_O1/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 0x1303c7
movsd %xmm0, 0x8(%rsp)
andq $0x0, 0x20(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
cmpq $0x0, 0x148(%rbx)
je 0x16768
leaq 0x150(%rbx), %r15
leaq 0x158(%rbx), %r12
xorl %r13d, %r13d
movq 0x28(%rbx), %rax
movq 0x138(%rbx), %rbp
andq (%rax,%r13,8), %rbp
movq 0x10(%r14), %rcx
imulq $0x30, %rbp, %rdx
movq 0x18(%rcx,%rdx), %rax
testq %rax, %rax
je 0x16758
addq %rdx, %rcx
addq $0x18, %rcx
movq 0x10(%rcx), %rdx
addq $0x18, %rdx
xorl %ecx, %ecx
cmpb $0x0, (%rdx)
js 0x166fd
movq 0xd8(%rbx), %rsi
movl -0x10(%rdx), %edi
cmpb $0x0, (%rsi,%rdi)
je 0x1670c
incq %rcx
addq $0x28, %rdx
cmpq %rcx, %rax
jne 0x166e8
movq %rax, %rcx
cmpq %rax, %rcx
je 0x16758
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1419c3
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r12, %r8
leaq 0x10(%rsp), %r9
callq 0x141ef2
movq 0x150(%rbx), %rdi
movq 0x158(%rbx), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x141ff9
movq 0xd8(%rbx), %rax
movb $0x1, (%rax,%rbp)
incq %r13
cmpq 0x148(%rbx), %r13
jb 0x166b2
movq 0xc8(%rbx), %rdx
movq 0xd8(%rbx), %rdi
xorl %esi, %esi
callq 0x20e0
movq 0x20(%rsp), %rdi
callq 0x2220
movq 0x273852(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd 0x8(%rsp), %xmm0
leaq 0x2190a7(%rip), %rsi    # 0x22f84a
leaq 0x2190b0(%rip), %rdx    # 0x22f85a
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_O1/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 0x1303c7
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movapd %xmm0, (%r15)
andq $0x0, 0x10(%r15)
pushq $0x1
popq %r13
pushq $-0x1
popq %r12
xorl %ebx, %ebx
movq 0x148(%r14), %rax
testq %rax, %rax
setne %dil
je 0x1684c
movq 0x28(%r14), %rcx
movq 0xc0(%r14), %rdx
movq 0x138(%r14), %rsi
movq (%rcx), %rbp
andq %rsi, %rbp
cmpb $0x0, (%rdx,%rbp)
je 0x1684c
movq %r13, %r8
movq %r8, %rdi
cmpq %r8, %rax
je 0x16845
movq (%rcx,%rdi,8), %rbp
andq %rsi, %rbp
leaq 0x1(%rdi), %r8
cmpb $0x0, (%rdx,%rbp)
jne 0x1682c
cmpq %rax, %rdi
setb %dil
testb %dil, %dil
je 0x168ef
andq $0x0, 0x10(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x141ff9
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0x168c1
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 0x168b4
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 0x1689d
incq %rsi
cmpq %rcx, %rsi
jne 0x16884
shrq %r8
jmp 0x168c4
xorl %r8d, %r8d
cmpq $0x2, %rcx
jae 0x168d2
incq %rbx
jmp 0x167fb
movq 0x273707(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x218f88(%rip), %rsi    # 0x22f86b
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x168ca
movq 0x20(%rsp), %rdi
callq 0x2220
movq 0x2736e0(%rip), %rax    # 0x289fe0
movq (%rax), %r14
callq 0x1303c7
subsd 0x8(%rsp), %xmm0
leaq 0x218f83(%rip), %rsi    # 0x22f898
leaq 0x218fa7(%rip), %rdx    # 0x22f8c3
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
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xa8, %rsp
movq %rcx, %rbx
movq %rdx, 0x20(%rsp)
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
callq 0x1303c7
movsd %xmm0, 0x28(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x90(%rsp)
movapd %xmm0, 0x80(%rsp)
movapd %xmm0, 0x70(%rsp)
movapd %xmm0, 0x60(%rsp)
movapd %xmm0, 0x50(%rsp)
movapd %xmm0, 0x40(%rsp)
movapd %xmm0, 0x30(%rsp)
movq %rbx, %r13
movq 0x18(%rbx), %rax
movl 0x14(%rax), %ebp
leal (%rbp,%rbp), %edi
pushq $0x38
popq %rsi
callq 0x2120
movq %rax, 0x30(%rsp)
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
pushq $0x1
popq %rbx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2120
movq %rax, 0x10(%rsp)
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x2120
movq %rax, %r14
leaq (,%rbp,4), %rbx
movq %rbx, %rdi
callq 0x2280
andq $0x0, 0x10(%r14)
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14)
movq %r14, %r15
movq %rax, 0x18(%r14)
testq %rbp, %rbp
je 0x16bdc
movq %rax, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x20e0
cmpq $0x0, 0x80(%r12)
movq %r15, 0x8(%rsp)
movq 0x20(%rsp), %rbp
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %rbx
je 0x16c2c
xorl %r14d, %r14d
movq %r14, %rdi
leaq 0x30(%rsp), %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq %rbp, %r9
pushq 0x8(%rsp)
pushq %r15
callq 0x14385b
popq %rax
popq %rcx
incq %r14
cmpq 0x80(%r12), %r14
jb 0x16bfe
movq 0x30(%rsp), %rdi
callq 0x2220
movq 0x48(%rsp), %rdi
callq 0x2220
movq 0x60(%rsp), %rdi
callq 0x2220
movq 0x78(%rsp), %rdi
callq 0x2220
movq 0x90(%rsp), %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2220
movq 0x273370(%rip), %rax    # 0x289fe0
movq (%rax), %rbx
callq 0x1303c7
subsd 0x28(%rsp), %xmm0
leaq 0x218d16(%rip), %rsi    # 0x22f99b
leaq 0x218d1e(%rip), %rdx    # 0x22f9aa
movq %rbx, %rdi
movb $0x1, %al
callq 0x22b0
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq