LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1365ef
movsd %xmm0, (%rsp)
movq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x1696cc
movq %rax, 0x30(%r15)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x16992c
movq %rax, %r15
leaq 0x277859(%rip), %rax    # 0x295758
movl 0x7c(%rax), %ecx
pushq $0x10
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %r8
callq 0x16ebcc
movq %rax, %r12
testq %r13, %r13
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x1df3a
movq %r12, %rdi
movq %r13, %rsi
callq 0x16edc2
movq %rax, 0x70(%r12)
movq 0x28(%rbx), %rax
movl 0x38(%rax), %edx
testl %edx, %edx
je 0x1df8a
pushq $0x1
popq %rbp
xorl %ecx, %ecx
cmpl %edx, %ebp
je 0x1df64
movq 0x30(%rax), %rdx
movl %ecx, %esi
movl %ebp, %edi
movq (%rdx,%rdi,8), %rdi
xorq (%rdx,%rsi,8), %rdi
shrq $0x20, %rdi
je 0x1df81
movl %ebp, %r8d
subl %ecx, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %r9
callq 0x16d46c
movq 0x28(%rbx), %rax
movl %ebp, %ecx
incl %ebp
movl 0x38(%rax), %edx
cmpl %edx, %ebp
jbe 0x1df4a
movq %r15, %rdi
callq 0x169a43
movq %r12, %rdi
callq 0x16ed30
movq 0x27703f(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd (%rsp), %xmm0
leaq 0x21f317(%rip), %rsi    # 0x23d2cc
leaq 0x21f39b(%rip), %rdx    # 0x23d357
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_O3/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 0x276ff5(%rip), %r12    # 0x294fe0
movq (%r12), %rdi
leaq 0x21e4d5(%rip), %rsi    # 0x23c4cb
leaq 0x21f378(%rip), %rdx    # 0x23d375
xorl %eax, %eax
callq 0x22b0
testl %ebp, %ebp
je 0x1e06c
movl %ebp, %r15d
leaq 0x21e453(%rip), %r14    # 0x23c465
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 0x1e047
movq (%r12), %rsi
js 0x1e056
pushq $0xa
popq %rdi
callq 0x2270
cmpq %r13, %r15
jne 0x1e015
jmp 0x1e06c
movq (%r12), %rdi
leaq 0x21f32f(%rip), %rsi    # 0x23d381
pushq $0x1
jmp 0x1e062
movq %rsi, %rdi
leaq 0x21f321(%rip), %rsi    # 0x23d381
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x1e040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/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 0x276d44(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21e225(%rip), %rsi    # 0x23c4cb
leaq 0x21f21f(%rip), %rdx    # 0x23d4cc
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 0x21f1c9(%rip), %rsi    # 0x23d49e
movq %rax, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x22a3f9(%rip), %rsi    # 0x2486e2
movq %r12, %rdi
callq 0x2210
movq %rax, %rbp
movq %r15, %rdi
movq %rax, %rsi
callq 0x1718c2
movq %r13, %rdi
movq %rbp, %rsi
callq 0x171a25
movq %r14, %rdi
movq %rbp, %rsi
callq 0x171924
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 0x171b53
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x1718c2
leaq 0x277ea0(%rip), %rdi    # 0x296230
movq %rbp, %rsi
callq 0x171c43
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_O3/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 0x2767f4(%rip), %r13    # 0x294fe0
movq (%r13), %rdi
movq 0x50(%rsi), %rax
movl %edx, %r12d
movq %r12, %rcx
shlq $0x5, %rcx
movl (%rax,%rcx), %r8d
leaq 0x21e83b(%rip), %rsi    # 0x23d044
leaq 0x21ebe3(%rip), %rdx    # 0x23d3f3
movl %ebx, %ecx
xorl %eax, %eax
callq 0x22b0
movq 0x40(%r14), %rax
movb 0x8(%rax), %cl
pushq $0x1
popq %rbp
shlq %cl, %rbp
leaq (,%rbp,8), %rdx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x20e0
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rsi
testl %esi, %esi
je 0x1e87d
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 0x1e855
xorl %r15d, %r15d
leaq 0x21e7e4(%rip), %r12    # 0x23d06b
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 0x1e887
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1365ef
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %r15
movq %r15, %rdi
callq 0x1696cc
movq %rax, 0x30(%r15)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x17018b
movq %rax, %r15
movq 0x10(%rbx), %rax
movl 0x38(%rax), %edx
testl %edx, %edx
je 0x1e958
pushq $0x1
popq %rbp
xorl %ecx, %ecx
cmpl %edx, %ebp
je 0x1e935
movq 0x30(%rax), %rdx
movl %ecx, %esi
movl %ebp, %edi
movq (%rdx,%rdi,8), %rdi
xorq (%rdx,%rsi,8), %rdi
shrq $0x20, %rdi
je 0x1e94f
movl %ebp, %r8d
subl %ecx, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x170bca
movq 0x10(%rbx), %rax
movl %ebp, %ecx
incl %ebp
movl 0x38(%rax), %edx
cmpl %edx, %ebp
jbe 0x1e91b
movq %r15, %rdi
callq 0x1702b6
movq 0x276679(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd (%rsp), %xmm0
leaq 0x21e951(%rip), %rsi    # 0x23d2cc
leaq 0x21eac0(%rip), %rdx    # 0x23d442
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/rcut.cpp
// Function: print_hap_p(kv_gg_status*)
void print_hap_p(kv_gg_status *s)
{
	fprintf(stderr, "\n[M::%s]\n", __func__);
	uint32_t i, h;
	mcg_node_t m;
	for (i = 0; i < s->n; i++)
	{
		fprintf(stderr,"utg%.6ul\t", i + 1);
		m = s->a[i].s; h = 0;
		while (m) {
			h++;
			if(m&1) fprintf(stderr, "h%u\t", h);
			m>>=1;
		}
		fprintf(stderr,"\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x276635(%rip), %r14    # 0x294fe0
movq (%r14), %rdi
leaq 0x21db16(%rip), %rsi    # 0x23c4cb
leaq 0x21eac0(%rip), %rdx    # 0x23d47c
xorl %eax, %eax
callq 0x22b0
cmpq $0x0, 0x8(%rbx)
je 0x1ea3d
leaq 0x21eab7(%rip), %r15    # 0x23d488
xorl %r13d, %r13d
xorl %r12d, %r12d
movq (%r14), %rdi
incl %r12d
leaq 0x21da81(%rip), %rsi    # 0x23c465
movl %r12d, %edx
xorl %eax, %eax
callq 0x22b0
movq (%rbx), %rax
shlq $0x5, %r13
movl (%rax,%r13), %ebp
testl %ebp, %ebp
je 0x1ea29
pushq $0x1
popq %r13
testb $0x1, %bpl
jne 0x1ea17
movl %ebp, %eax
shrl %eax
incl %r13d
cmpl $0x1, %ebp
movl %eax, %ebp
ja 0x1ea01
jmp 0x1ea29
movq (%r14), %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x22b0
jmp 0x1ea07
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x2270
movl %r12d, %r13d
cmpq %r13, 0x8(%rbx)
ja 0x1e9d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/rcut.cpp
// Function: write_mc_gg_dump(kv_u_trans_t*, unsigned int, kv_gg_status*, unsigned short, char const*)
void write_mc_gg_dump(kv_u_trans_t *ta, uint32_t un, kv_gg_status *s, uint16_t hapN, const char* fn)
{
	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");

	fwrite(&ta->n, sizeof(ta->n), 1, fp);
    fwrite(ta->a, sizeof(u_trans_t), ta->n, fp);

    fwrite(&ta->idx.n, sizeof(ta->idx.n), 1, fp);
    fwrite(ta->idx.a, sizeof(uint64_t), ta->idx.n, fp);

	fwrite(&un, sizeof(un), 1, fp);

	fwrite(&(s->n), sizeof(s->n), 1, fp);
    fwrite(s->a, sizeof(mc_gg_status), s->n, fp);

	fwrite(&hapN, sizeof(hapN), 1, fp);

	fclose(fp);
    free(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, %rbp
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x2(%rsp), %rax
movw %cx, (%rax)
movq 0x27656a(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21da4b(%rip), %rsi    # 0x23c4cb
leaq 0x21ea06(%rip), %rdx    # 0x23d48d
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
callq 0x2090
leaq 0x32(%rax), %rdi
pushq $0x1
popq %r12
movq %r12, %rsi
callq 0x2120
movq %rax, %r15
leaq 0x21e9ee(%rip), %rsi    # 0x23d49e
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x229c1e(%rip), %rsi    # 0x2486e2
movq %r15, %rdi
callq 0x2210
movq %rax, %rbx
pushq $0x8
popq %r13
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x2410
movq (%rbp), %rdx
movq 0x10(%rbp), %rdi
pushq $0x30
popq %rsi
movq %rbx, %rcx
callq 0x2410
leaq 0x18(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2410
movq 0x18(%rbp), %rdx
movq 0x28(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rcx
callq 0x2410
pushq $0x4
popq %rsi
leaq 0x4(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2410
leaq 0x8(%r14), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2410
movq (%r14), %rdi
movq 0x8(%r14), %rdx
pushq $0x20
popq %rsi
movq %rbx, %rcx
callq 0x2410
pushq $0x2
popq %rsi
leaq 0x2(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2410
movq %rbx, %rdi
callq 0x2190
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/horder.cpp
// Function: print_N50(ma_ug_t*)
void print_N50(ma_ug_t* ug)
{
    kvec_t(uint64_t) b; kv_init(b);
    uint64_t i, s, len;
    for (i = s = 0; i < ug->u.n; ++i) 
    {
        kv_push(uint64_t, b, ug->u.a[i].len);
        s += ug->u.a[i].len;
    }
    len = s;
    
    radix_sort_ho64(b.a, b.a+b.n);
    fprintf(stderr, "[M::%s::] Genome Size: %lu, # Contigs: %u, Largest Contig: %lu\n", 
    __func__, len, (uint32_t)ug->u.n, b.a[b.n-1]);
    i = b.n; s = 0;
    while (i > 0)
    {
        i--;
        s += b.a[i];
        if(s >= (len>>1))
        {
            fprintf(stderr, "[M::%s::] N50: %lu\n", __func__, b.a[i]);
            break;
        }
    }
    
    kv_destroy(b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r13d, %r13d
movq %rdi, (%rsp)
cmpq $0x0, (%rdi)
movl $0x0, %r14d
movl $0x0, %edi
je 0x1f7ba
xorl %r12d, %r12d
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %ebp, %ebp
xorl %ebx, %ebx
xorl %edi, %edi
xorl %r14d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r15, %r13
jne 0x1f78a
testq %rbx, %rbx
movq %rbp, %r15
pushq $0x2
popq %rax
cmoveq %rax, %r15
leaq (,%r15,8), %rsi
callq 0x2370
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rax, %rdi
movq (%rsp), %rdx
movq 0x10(%rdx), %rax
movl (%rax,%r12), %ecx
andq %rsi, %rcx
incq %r13
movq %rcx, (%rdi,%rbp,4)
movl (%rax,%r12), %eax
andq %rsi, %rax
addq %rax, %r14
decq %rbx
addq $0x2, %rbp
addq $0x28, %r12
cmpq (%rdx), %r13
jb 0x1f763
leaq (%rdi,%r13,8), %r12
movq %rdi, %rbp
movq %r12, %rsi
callq 0x172ebc
movq 0x275810(%rip), %rbx    # 0x294fe0
movq (%rbx), %rdi
movq (%rsp), %rax
movl (%rax), %r8d
decq %r13
movq -0x8(%r12), %r9
leaq 0x21df58(%rip), %rsi    # 0x23d741
leaq 0x21df91(%rip), %rdx    # 0x23d781
xorl %r15d, %r15d
movq %r14, %rcx
xorl %eax, %eax
callq 0x22b0
movq %rbp, %rdi
shrq %r14
cmpq $-0x1, %r13
je 0x1f833
movq (%rdi,%r13,8), %rcx
addq %rcx, %r15
decq %r13
cmpq %r14, %r15
jb 0x1f803
movq (%rbx), %rdi
leaq 0x21df69(%rip), %rsi    # 0x23d78b
leaq 0x21df58(%rip), %rdx    # 0x23d781
xorl %eax, %eax
callq 0x22b0
movq %rbp, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/horder.cpp
// Function: print_N50_layout(ma_ug_t*, sc_lay_t*)
void print_N50_layout(ma_ug_t* ug, sc_lay_t* sl)
{
    kvec_t(uint64_t) b; kv_init(b);
    lay_t *p = NULL;
    uint64_t i, k, s, ulen, len, occ = 0;
    for (i = s = 0; i < sl->n; ++i) 
    {
        p = &(sl->a[i]);
        for (k = ulen = 0; k < p->n; k+=2)
        {
            ulen += ug->u.a[p->a[k]>>1].len;
        }
        occ += p->n;
        
        kv_push(uint64_t, b, ulen);
        s += ulen;
    }
    len = s;
    
    radix_sort_ho64(b.a, b.a+b.n);
    fprintf(stderr, "[M::%s::] Scaffold Size: %lu, # Scaffolds: %u (occ-%lu), Largest Scaffold: %lu\n", 
    __func__, len, (uint32_t)sl->n, occ, b.a[b.n-1]);
    i = b.n; s = 0;
    while (i > 0)
    {
        i--;
        s += b.a[i];
        if(s >= (len>>1))
        {
            fprintf(stderr, "[M::%s::] N50: %lu\n", __func__, b.a[i]);
            break;
        }
    }
    
    kv_destroy(b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r8
xorl %ebp, %ebp
cmpq $0x0, 0x8(%rsi)
movq %rdi, 0x8(%rsp)
movl $0x0, %r14d
movl $0x0, %edi
movl $0x0, %r15d
je 0x1f920
xorl %r15d, %r15d
xorl %edi, %edi
xorl %r14d, %r14d
xorl %ebp, %ebp
xorl %r9d, %r9d
movq (%r8), %rcx
imulq $0x18, %rbp, %rax
movq 0x8(%rcx,%rax), %rbx
testq %rbx, %rbx
je 0x1f8cc
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rcx), %rcx
xorl %r12d, %r12d
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
shrl %esi
imulq $0x28, %rsi, %rsi
movl (%rax,%rsi), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
addq %rsi, %r12
addq $0x2, %rdx
cmpq %rbx, %rdx
jb 0x1f8ac
jmp 0x1f8cf
xorl %r12d, %r12d
cmpq %r9, %rbp
jne 0x1f909
movq %r14, 0x10(%rsp)
leaq (,%rbp,2), %r14
testq %rbp, %rbp
pushq $0x2
popq %rax
cmoveq %rax, %r14
leaq (,%r14,8), %rsi
movq %r8, %r13
callq 0x2370
movq %r14, %r9
movq 0x10(%rsp), %r14
movq %r13, %r8
movq %rax, %rdi
addq %rbx, %r15
movq %r12, (%rdi,%rbp,8)
incq %rbp
addq %r12, %r14
cmpq 0x8(%r8), %rbp
jb 0x1f887
leaq (%rdi,%rbp,8), %r13
movq %rdi, %rbx
movq %r13, %rsi
movq %r8, %r12
callq 0x172ebc
movq 0x2756a7(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
movl 0x8(%r12), %r8d
decq %rbp
movq -0x8(%r13), %rax
movq %rax, (%rsp)
leaq 0x21de4c(%rip), %rsi    # 0x23d79f
leaq 0x21de95(%rip), %rdx    # 0x23d7ef
xorl %r12d, %r12d
movq %r14, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
shrq %r14
cmpq $-0x1, %rbp
je 0x1f9a7
movq (%rdi,%rbp,8), %rcx
addq %rcx, %r12
decq %rbp
cmpq %r14, %r12
jb 0x1f970
movq 0x275654(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21ddf5(%rip), %rsi    # 0x23d78b
leaq 0x21de52(%rip), %rdx    # 0x23d7ef
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/horder.cpp
// Function: verbose_misjoin(unsigned long*, unsigned long)
void verbose_misjoin(uint64_t *a, uint64_t a_n)
{
    radix_sort_ho64(a, a + a_n);
    uint64_t k, l, i, len, s, C[2], N[2];
    C[0] = C[1] = N[0] = N[1] = 0;
    for (k = 1, l = 0; k <= a_n; ++k) 
    {   
        if (k == a_n || (a[k]>>63) != (a[l]>>63))
        {
            for (i = l, s = 0; i < k; i++) s += ((a[i]<<1)>>1);
            len = s;

            i = k; s = 0;
            while (i > l)
            {
                i--;
                s += ((a[i]<<1)>>1);
                if(s >= (len>>1))
                {
                    N[a[l]>>63] = ((a[i]<<1)>>1);
                    C[a[l]>>63] = k - l;
                    // fprintf(stderr, "[M::%s::] N50: %lu\n", __func__, b.a[i]);
                    break;
                }
            }
            
            l = k;
        }
    }

    fprintf(stderr, "[M::stat] # misjoined unitigs: %lu (N50: %lu); # corrected unitigs: %lu (N50: %lu)\n", 
    C[0], N[0], C[1], N[1]);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq (%rdi,%rsi,8), %rsi
callq 0x172ebc
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
testq %rbx, %rbx
jne 0x1fc30
xorl %r9d, %r9d
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x1fcd0
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%rbx), %rdx
cmpq $0x3, %rdx
pushq $0x2
popq %rcx
cmovaeq %rdx, %rcx
pushq $0x1
popq %rdx
xorl %esi, %esi
cmpq %rbx, %rdx
je 0x1fc5d
movq (%r14,%rsi,8), %rdi
xorq (%r14,%rdx,8), %rdi
jns 0x1fcb5
movq %rdx, %rdi
xorl %r8d, %r8d
subq %rsi, %rdi
jbe 0x1fc80
movq %rsi, %r9
movq (%r14,%r9,8), %r10
andq %rax, %r10
addq %r10, %r8
incq %r9
cmpq %r9, %rdx
jne 0x1fc6b
shrq %r8
movq %rdx, %r9
xorl %r11d, %r11d
cmpq %rsi, %r9
jbe 0x1fcb2
movq -0x8(%r14,%r9,8), %r10
andq %rax, %r10
decq %r9
addq %r10, %r11
cmpq %r8, %r11
jb 0x1fc86
movq (%r14,%rsi,8), %rsi
shrq $0x3f, %rsi
shll $0x3, %esi
movq %r10, (%rsp,%rsi)
movq %rdi, 0x10(%rsp,%rsi)
movq %rdx, %rsi
incq %rdx
cmpq %rcx, %rdx
jne 0x1fc4e
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %r8
movq (%rsp), %rcx
movq 0x8(%rsp), %r9
movq 0x275309(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21dc3e(%rip), %rsi    # 0x23d91f
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/horder.cpp
// Function: renew_scaffold(horder_t*)
void renew_scaffold(horder_t *h)
{
    double index_time = yak_realtime();
    while (1)
    {
        update_u_hits(&(h->u_hits), &(h->r_hits), h->ug, h->r_g);
        if(!break_scaffold(h, 5, 15, (uint64_t)-1, (uint64_t)-1, 2500000, 1, NULL)) break;
        print_N50(h->ug);
    }
    fprintf(stderr, "[M::%s::%.3f] \n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1365ef
movsd %xmm0, (%rsp)
leaq 0x70(%rbx), %r14
leaq 0x18(%rbx), %r15
pushq $0x5
popq %r12
pushq $0xf
popq %r13
pushq $-0x1
popq %rbp
movq 0xc8(%rbx), %rdx
movq 0xd0(%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x17650e
movl $0x2625a0, %r9d         # imm = 0x2625A0
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %rbp, %r8
pushq $0x0
pushq $0x1
callq 0x17b0fc
popq %rcx
popq %rdx
testq %rax, %rax
je 0x21150
movq 0xc8(%rbx), %rdi
callq 0x1f729
jmp 0x21104
movq 0x273e89(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd (%rsp), %xmm0
leaq 0x21a92f(%rip), %rsi    # 0x23ba9a
leaq 0x21c9f3(%rip), %rdx    # 0x23db65
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_O3/chhylp123[P]hifiasm/horder.cpp
// Function: print_scaffold(ma_ug_t*, asg_t*, ma_sub_t*, char*, ma_hit_t_alloc*, ma_hit_t_alloc*, long long, float, long long, R_to_U*, float, float, int, int)
void print_scaffold(ma_ug_t *ug, asg_t *sg, ma_sub_t* coverage_cut, char* output_file_name, 
ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, 
long long tipsLen, float tip_drop_ratio, long long stops_threshold, R_to_U* ruIndex, 
float chimeric_rate, float drop_ratio, int max_hang, int min_ovlp)
{
    char* gfa_name = (char*)malloc(strlen(output_file_name)+100);
    sprintf(gfa_name, "%s.%s.p_ctg.gfa", output_file_name, "stg");
    fprintf(stderr, "Writing %s to disk... \n", gfa_name);
    FILE* output_file = NULL;
    output_file = fopen(gfa_name, "w");


    kvec_asg_arc_t_warp new_rtg_edges;
    kv_init(new_rtg_edges.a);
    ma_ug_seq_scaffold(ug, sg, coverage_cut, sources, &new_rtg_edges, max_hang, min_ovlp, 0, 1);
    ma_ug_print(ug, sg, coverage_cut, sources, ruIndex, "stg", output_file);
    fclose(output_file);

    sprintf(gfa_name, "%s.%s.p_ctg.noseq.gfa", output_file_name, "stg");
    output_file = fopen(gfa_name, "w");
    ma_ug_print_simple(ug, sg, coverage_cut, sources, ruIndex, "stg", output_file);
    fclose(output_file);

    free(gfa_name);
    kv_destroy(new_rtg_edges.a);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movl 0xb0(%rsp), %r15d
movq %rcx, %rdi
movq %rcx, 0x28(%rsp)
callq 0x2090
leaq 0x64(%rax), %rdi
callq 0x2280
movq %rax, %rbp
leaq 0x216559(%rip), %rsi    # 0x23772a
leaq 0x21c99c(%rip), %rcx    # 0x23db74
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x273df4(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21587d(%rip), %rsi    # 0x236a73
movq %rbp, %rdx
xorl %eax, %eax
callq 0x22b0
leaq 0x2274db(%rip), %rsi    # 0x2486e2
movq %rbp, %rdi
callq 0x2210
movq %rax, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, %r8
andq $0x0, 0x8(%rsp)
movl %r15d, (%rsp)
movl $0x1, 0x10(%rsp)
movq %r13, %r15
movq %r13, %rdi
movq %r12, %r13
movq %r12, %rsi
movq %r14, %r12
movq %r14, %rdx
movq 0x20(%rsp), %r14
movq %r14, %rcx
movl 0xa8(%rsp), %r9d
callq 0xb6e9c
movq %rbx, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq 0xa0(%rsp), %r8
leaq 0x21c8f7(%rip), %r14    # 0x23db74
movq %r14, %r9
callq 0xb7eea
movq %rbx, %rdi
callq 0x2190
leaq 0x2164ba(%rip), %rsi    # 0x23774e
movq %rbp, %rdi
movq 0x28(%rsp), %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2050
movq %rbp, %rdi
leaq 0x227432(%rip), %rsi    # 0x2486e2
callq 0x2210
movq %rax, %rbx
movq %rax, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %rcx
movq 0xa0(%rsp), %r8
movq %r14, %r9
callq 0xb8ee0
movq %rbx, %rdi
callq 0x2190
movq %rbp, %rdi
callq 0x2220
leaq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2220
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/horder.cpp
// Function: renew_scaffold_utg(horder_t*, sc_lay_t*, ma_ug_t*)
void renew_scaffold_utg(horder_t *h, sc_lay_t *sl, ma_ug_t* i_ug)
{
    double index_time = yak_realtime();
    h_covs b; kv_init(b);
    while (1)
    {
        update_u_hits(&(h->u_hits), &(h->r_hits), h->ug, h->r_g);
        if(!break_scaffold(h, 5, 15, 15, 25, 2500000, 1, &b)) break;
        update_sc_lay(sl, &b);
        update_ug_by_layout(h, sl, i_ug);
        print_N50(h->ug);
    }
    fprintf(stderr, "[M::%s::%.3f] \n", __func__, yak_realtime()-index_time);
    kv_destroy(b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r15
callq 0x1365ef
movsd %xmm0, (%rsp)
leaq 0x70(%r15), %r12
leaq 0x18(%r15), %r13
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
andq $0x0, 0x10(%rbp)
movapd %xmm0, (%rbp)
pushq $0xf
popq %rbx
movq 0xc8(%r15), %rdx
movq 0xd0(%r15), %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0x17650e
movl $0x2625a0, %r9d         # imm = 0x2625A0
movq %r15, %rdi
pushq $0x5
popq %rsi
movq %rbx, %rdx
movq %rbx, %rcx
pushq $0x19
popq %r8
pushq %rbp
pushq $0x1
callq 0x17b0fc
popq %rcx
popq %rdx
testq %rax, %rax
je 0x217d5
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17ea86
movq %r15, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x17d438
movq 0xc8(%r15), %rdi
callq 0x1f729
jmp 0x2176e
movq 0x273804(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd (%rsp), %xmm0
leaq 0x21a2aa(%rip), %rsi    # 0x23ba9a
leaq 0x21c6e6(%rip), %rdx    # 0x23dedd
movq %rbx, %rdi
movb $0x1, %al
callq 0x22b0
movq 0x10(%rsp), %rdi
callq 0x2220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/horder.cpp
// Function: horder_utg(kvec_pe_hit*, unsigned long, unsigned long, asg_t*, ma_ug_t*, bubble_type*, ug_opt_t*)
spg_t *horder_utg(kvec_pe_hit *i_hits, uint64_t i_hits_uid_bits, uint64_t i_hits_pos_mode, 
asg_t *i_rg, ma_ug_t* i_ug, bubble_type* bub, ug_opt_t *opt)
{
    horder_t *h = NULL; CALLOC(h, 1);
    sc_lay_t sl; kv_init(sl);
    get_r_hits(i_hits, &(h->r_hits), i_rg, i_ug, bub, i_hits_uid_bits, i_hits_pos_mode);
    h->r_g = copy_read_graph(i_rg);
    horder_clean_sg_by_utg(h->r_g, i_ug);///udate rg by ug
    h->ug = copy_untig_graph(i_ug); asg_destroy(h->ug->g); h->ug->g = NULL;
    cpy_u_hits(&(h->u_hits), i_hits, h->ug->u.n);

    update_scg(h, NULL);
    layout_scg(h, ((double)1)/((double)0.75), 19, &sl);
    renew_scaffold_utg(h, &sl, i_ug);
    
    spg_t *scg = scf_g(&sl, i_ug);
    destory_sc_lay_t(&sl);
    destory_horder_t(&h);
    return scg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %rbx
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
pushq $0x1
popq %rdi
movl $0xe0, %esi
callq 0x2120
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq %r12, (%rax)
leaq 0x18(%r12), %rsi
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %r14, (%rsp)
movq %r15, %rdi
movq %rbp, %rdx
movq %rbx, %rcx
movq 0x10(%rsp), %r8
movq %r13, %r9
callq 0x175db3
movq %rbp, %rdi
callq 0xc8dad
movq %rax, 0xd0(%r12)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1769f0
movq %rbx, %rdi
callq 0xc8eab
movq %rax, 0xc8(%r12)
movq 0x18(%rax), %rdi
callq 0xa0494
movq 0xc8(%r12), %rax
andq $0x0, 0x18(%rax)
leaq 0x70(%r12), %rdi
movl (%rax), %edx
movq %r15, %rsi
callq 0x17e966
movq %r12, %rdi
callq 0x1fe67
movsd 0x21bc35(%rip), %xmm0   # 0x23d518
pushq $0x13
popq %rsi
movq %r12, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rdx
callq 0x20daa
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2172d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17ed74
movq %rax, %rbx
movq %r14, %rdi
callq 0x17d55e
leaq 0x18(%rsp), %rdi
callq 0x17eeba
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/horder.cpp
// Function: ha_aware_order(kvec_pe_hit*, asg_t*, ma_ug_t*, ma_ug_t*, kv_u_trans_t*, ug_opt_t*, unsigned int)
void ha_aware_order(kvec_pe_hit *r_hits, asg_t *rg, ma_ug_t *ug_fa, ma_ug_t *ug_mo, kv_u_trans_t *ref, 
ug_opt_t *opt, uint32_t round)
{
    horder_t *h = NULL; CALLOC(h, 1);
    h->r_hits = *r_hits;
    h->r_g = rg;
    scaffold_ug(h, ug_fa, opt, round, asm_opt.output_file_name, FATHER);
    scaffold_ug(h, ug_mo, opt, round, asm_opt.output_file_name, MOTHER);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl 0x40(%rsp), %ebp
pushq $0x1
popq %rdi
movl $0xe0, %esi
callq 0x2120
movq %rax, %r14
leaq 0x18(%rax), %rdi
pushq $0xb
popq %rcx
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, 0xd0(%rax)
leaq 0x273cbc(%rip), %r12    # 0x295758
movq 0x10(%r12), %r8
pushq $0x1
popq %r9
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x214cf
movq 0x10(%r12), %r8
pushq $0x2
popq %r9
movq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x214cf
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_ec_multiple(ec_ovec_buf_t*, unsigned long, unsigned long, unsigned long*)
uint64_t cal_ec_multiple(ec_ovec_buf_t *b, uint64_t n_thre, uint64_t n_a, uint64_t *r_base)
{
    double tt0 = yak_realtime_0();
    uint64_t k, num_base = 0, num_correct = 0; (*r_base) = 0;

    if(!(scc.a)) {
        scc.n = scc.m = n_a; CALLOC(scc.a, n_a); CALLOC(scc.f, n_a);
    }

    if(!(scb.a)) {
        scb.n = scb.m = n_a; CALLOC(scb.a, n_a);
    }

    for (k = 0; k < n_thre; ++k) b->a[k].cnt[0] = b->a[k].cnt[1] = 0;

    kt_for(n_thre, worker_hap_ec, b, n_a);///debug_for_fix

    for (k = 0; k < n_thre; ++k) {
        num_base += b->a[k].cnt[0];
        num_correct += b->a[k].cnt[1];
    }

    // fprintf(stderr, "\n[M::%s] # reads->%lu\n", __func__, n_a);
    // fprintf(stderr, "[M::%s] # input bases->%lu\n", __func__, num_base);
    // fprintf(stderr, "[M::%s] # corrected bases->%lu\n", __func__, num_correct);
    // fprintf(stderr, "[M::%s::%.3f] running time\n", __func__, yak_realtime_0()-tt0);
    fprintf(stderr, "[M::pec::%.3f] # bases: %lu; # corrected bases: %lu\n", yak_realtime_0()-tt0, num_base, num_correct);

    (*r_base) = num_base;
    return num_correct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x13662b
andq $0x0, (%rbx)
movsd %xmm0, 0x8(%rsp)
cmpq $0x0, 0x27479c(%rip)    # 0x296548
jne 0x21de0
movq %r12, 0x27478b(%rip)    # 0x296540
movq %r12, 0x27477c(%rip)    # 0x296538
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x27477a(%rip)    # 0x296548
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x274770(%rip)    # 0x296550
cmpq $0x0, 0x274780(%rip)    # 0x296568
jne 0x21e0a
movq %r12, 0x27476f(%rip)    # 0x296560
movq %r12, 0x274760(%rip)    # 0x296558
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x27475e(%rip)    # 0x296568
testq %r14, %r14
jne 0x21e2b
leaq 0x170ac9(%rip), %rsi    # 0x1928df
xorl %r13d, %r13d
xorl %edi, %edi
movq %r15, %rdx
movq %r12, %rcx
callq 0x108f2c
xorl %r15d, %r15d
jmp 0x21e7e
movl $0xc0, %eax
addq (%r15), %rax
xorpd %xmm0, %xmm0
movq %r14, %rcx
movupd %xmm0, (%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x21e3a
leaq 0x170a8f(%rip), %rsi    # 0x1928df
movl %r14d, %edi
movq %r15, %rdx
movq %r12, %rcx
callq 0x108f2c
movl $0xc8, %eax
addq (%r15), %rax
xorl %r15d, %r15d
xorl %r13d, %r13d
addq -0x8(%rax), %r13
addq (%rax), %r15
addq $0x5c0, %rax            # imm = 0x5C0
decq %r14
jne 0x21e6c
movq 0x27315b(%rip), %rax    # 0x294fe0
movq (%rax), %r14
callq 0x13662b
subsd 0x8(%rsp), %xmm0
leaq 0x21d6de(%rip), %rsi    # 0x23f578
movq %r14, %rdi
movq %r13, %rdx
movq %r15, %rcx
movb $0x1, %al
callq 0x22b0
movq %r13, (%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_update_ec_multiple(ec_ovec_buf_t*, unsigned long, unsigned long)
void cal_update_ec_multiple(ec_ovec_buf_t *b, uint64_t n_thre, uint64_t n_a)
{
    double tt0 = yak_realtime_0();
    uint64_t k, num_ec_o = 0, num_nec_o = 0; 

    for (k = 0; k < n_thre; ++k) b->a[k].cnt[0] = b->a[k].cnt[1] = 0;

    kt_for(n_thre, worker_update_dc_ec, b, n_a);///debug_for_fix

    for (k = 0; k < n_thre; ++k) {
        num_ec_o += b->a[k].cnt[0]; num_nec_o += b->a[k].cnt[1];
    }

    fprintf(stderr, "[M::pec::%.3f] # exact o: %lu; # non-exact o: %lu\n", yak_realtime_0()-tt0, num_ec_o, num_nec_o);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
callq 0x13662b
movsd %xmm0, (%rsp)
testq %rbx, %rbx
jne 0x21efa
leaq 0x170ed0(%rip), %rsi    # 0x192db5
xorl %r14d, %r14d
xorl %edi, %edi
movq %r15, %rdx
movq %r12, %rcx
callq 0x108f2c
xorl %r15d, %r15d
jmp 0x21f4c
movl $0xc0, %eax
addq (%r15), %rax
xorpd %xmm0, %xmm0
movq %rbx, %rcx
movupd %xmm0, (%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x21f09
leaq 0x170e96(%rip), %rsi    # 0x192db5
movl %ebx, %edi
movq %r15, %rdx
movq %r12, %rcx
callq 0x108f2c
movl $0xc8, %eax
addq (%r15), %rax
xorl %r15d, %r15d
xorl %r14d, %r14d
addq -0x8(%rax), %r14
addq (%rax), %r15
addq $0x5c0, %rax            # imm = 0x5C0
decq %rbx
jne 0x21f3a
movq 0x27308d(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x13662b
subsd (%rsp), %xmm0
leaq 0x21d646(%rip), %rsi    # 0x23f5ad
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_ec_r(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*)
void cal_ec_r(uint64_t n_thre, uint64_t round, uint64_t n_round, uint64_t n_a, uint64_t is_sv, uint64_t *tot_b, uint64_t *tot_e)
{
    // write_ec_reads("ec0.fa");

    // fprintf(stderr, "[M::%s]\tn_thre::%lu, round::%lu, n_round::%lu, n_a::%lu, is_sv::%lu\n", __func__, n_thre, round, n_round, n_a, is_sv);

    ec_ovec_buf_t *b = NULL; uint64_t k, is_cr = (round&1);
    (*tot_b) = (*tot_e) = 0;


    b = gen_ec_ovec_buf_t(n_thre);
    (*tot_e) += cal_ec_multiple(b, n_thre, n_a, tot_b); ///exit(1);
    sl_ec_r(n_thre, n_a);

    for (k = 0; k < n_round; k++) {
        (*tot_e) += cal_sec_ec_multiple(b, n_thre, n_a, k);
        sl_ec_r(n_thre, n_a);
    }

    cal_update_ec_multiple(b, n_thre, n_a);///update overlaps

    // if(is_sv) kt_for(n_thre, worker_hap_dc_ec, b, n_a);///update overlaps
    

    if((!is_sv) || (is_sv && is_cr)) {
        kt_for(n_thre, worker_hap_post_rev, b, n_a);
    }

    // cal_sec_ec_multiple(b, n_thre, n_a, -1);

    // gen_sec_ec_multiple(b, n_thre, n_a);

    destroy_ec_ovec_buf_t(b);

    // write_ec_reads("ec16.fa");

    // uint64_t z;
    // for (z = 0; z < scc.n; z++) {
    //     if(scc.f[z]) continue;
    //     fprintf(stderr, "[M::%s]\tid::%lu::%.*s\n", __func__, z, (int)Get_NAME_LENGTH(R_INF, z), Get_NAME((R_INF), z));
    // }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, 0x10(%rsp)
movq 0x50(%rsp), %r13
andq $0x0, (%r13)
movq %rdi, %r15
andq $0x0, (%r9)
callq 0x17fcf7
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x21d7c
addq %rax, (%r13)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19410d
testq %rbp, %rbp
je 0x22388
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x19331a
addq %rax, (%r13)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19410d
incq %r12
cmpq %r12, %rbp
jne 0x22360
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x21ebe
cmpq $0x0, 0x8(%rsp)
setne %al
testb $0x1, 0x10(%rsp)
sete %cl
testb %al, %cl
jne 0x223c0
leaq 0x171e22(%rip), %rsi    # 0x1941d4
movl %r15d, %edi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x108f2c
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18002d
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: handle_chemical_r(unsigned long, unsigned long)
void handle_chemical_r(uint64_t n_thre, uint64_t n_a)
{
    ec_ovec_buf_t *b = NULL; uint64_t k, chem_n = 0, dedup = 0;
    b = gen_ec_ovec_buf_t(n_thre);
    for (k = 0; k < n_thre; ++k) {
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 0;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_r, b, n_a);

    for (k = 0; k < n_thre; ++k) {
        chem_n += b->a[k].cnt[0]; 
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 1;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_r, b, n_a);
    
    for (k = 0; k < n_thre; ++k) {
        dedup += b->a[k].cnt[0]; 
        b->a[k].cnt[1] = 2;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_r, b, n_a);

    fprintf(stderr, "[M::%s] # chimeric reads: %lu, # arcs:: %lu\n", __func__, chem_n, dedup);

    destroy_ec_ovec_buf_t(b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x17fcf7
movq %rax, %rbx
testq %r15, %r15
jne 0x22426
leaq 0x17316d(%rip), %r12    # 0x195566
movl %r15d, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
movl %r15d, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
xorl %r12d, %r12d
xorl %r13d, %r13d
jmp 0x224b8
movl $0xc0, %eax
addq (%rbx), %rax
xorps %xmm0, %xmm0
movq %r15, %rcx
movups %xmm0, (%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x22434
leaq 0x17311d(%rip), %rsi    # 0x195566
movl %r15d, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
movl $0xc0, %eax
addq (%rbx), %rax
xorl %r12d, %r12d
movq %r15, %rcx
addq (%rax), %r12
andq $0x0, (%rax)
movq $0x1, 0x8(%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x22465
leaq 0x1730e0(%rip), %rsi    # 0x195566
movl %r15d, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
movl $0xc8, %eax
addq (%rbx), %rax
xorl %r13d, %r13d
movq %r15, %rcx
addq -0x8(%rax), %r13
movq $0x2, (%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x224a2
leaq 0x1730a7(%rip), %rsi    # 0x195566
movl %r15d, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
movq 0x272b0c(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21d2dc(%rip), %rsi    # 0x23f7ba
leaq 0x21d302(%rip), %rdx    # 0x23f7e7
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x18002d
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: handle_chemical_arc(unsigned long, unsigned long)
void handle_chemical_arc(uint64_t n_thre, uint64_t n_a)
{
    ec_ovec_buf_t *b = NULL; uint64_t k, chem_n = 0;
    b = gen_ec_ovec_buf_t(n_thre);
    for (k = 0; k < n_thre; ++k) {
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 0;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_arc, b, n_a);

    for (k = 0; k < n_thre; ++k) {
        chem_n += b->a[k].cnt[0]; 
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 1;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_arc, b, n_a);

    fprintf(stderr, "[M::%s] # chimeric reads: %lu\n", __func__, chem_n);

    destroy_ec_ovec_buf_t(b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x17fcf7
movq %rax, %rbx
testq %r15, %r15
jne 0x22538
leaq 0x173180(%rip), %rsi    # 0x1956a5
movl %r15d, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
xorl %r12d, %r12d
jmp 0x22591
movl $0xc0, %eax
addq (%rbx), %rax
xorps %xmm0, %xmm0
movq %r15, %rcx
movups %xmm0, (%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x22546
leaq 0x17314a(%rip), %rsi    # 0x1956a5
movl %r15d, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
movl $0xc0, %eax
addq (%rbx), %rax
xorl %r12d, %r12d
movq %r15, %rcx
addq (%rax), %r12
andq $0x0, (%rax)
movq $0x1, 0x8(%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x22577
leaq 0x17310d(%rip), %rsi    # 0x1956a5
movl %r15d, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
movq 0x272a33(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21d242(%rip), %rsi    # 0x23f7f9
leaq 0x21d25a(%rip), %rdx    # 0x23f818
movq %r12, %rcx
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18002d
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: gen_chemical_arc_rf(unsigned long, unsigned long)
uint8_t* gen_chemical_arc_rf(uint64_t n_thre, uint64_t n_a)
{
    ec_ovec_buf_t *b = NULL; uint64_t k, chem_n = 0; uint8_t *ra = NULL;
    b = gen_ec_ovec_buf_t(n_thre);
    for (k = 0; k < n_thre; ++k) {
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 0;
    }
    MALLOC(ra, n_a); ///memset(ra, -1, sizeof((*ra))*n_a); 
    b->cr = ra;

    kt_for(n_thre, worker_hap_dc_ec_chemical_arc_mark, b, n_a);

    for (k = 0; k < n_thre; ++k) {
        chem_n += b->a[k].cnt[0]; 
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 1;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_arc_mark, b, n_a);

    fprintf(stderr, "[M::%s] # chimeric reads: %lu\n", __func__, chem_n);

    b->cr = NULL; destroy_ec_ovec_buf_t(b);
    return ra;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x17fcf7
movq %rax, %rbx
testq %r15, %r15
je 0x22613
movl $0xc0, %eax
addq (%rbx), %rax
xorps %xmm0, %xmm0
movq %r15, %rcx
movups %xmm0, (%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x22605
movq %r14, %rdi
callq 0x2280
movq %rax, %r12
movq %rax, 0x10(%rbx)
leaq 0x1731f3(%rip), %rsi    # 0x19581c
movl %r15d, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
testq %r15, %r15
jne 0x22641
xorl %r13d, %r13d
jmp 0x22669
movl $0xc0, %eax
addq (%rbx), %rax
xorl %r13d, %r13d
movq %r15, %rcx
addq (%rax), %r13
andq $0x0, (%rax)
movq $0x1, 0x8(%rax)
addq $0x5c0, %rax            # imm = 0x5C0
decq %rcx
jne 0x2264f
leaq 0x1731ac(%rip), %rsi    # 0x19581c
movl %r15d, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x108f2c
movq 0x27295b(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21d16a(%rip), %rsi    # 0x23f7f9
leaq 0x21d196(%rip), %rdx    # 0x23f82c
movq %r13, %rcx
xorl %eax, %eax
callq 0x22b0
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x18002d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/tovlp.cpp
// Function: print_u_trans(kv_u_trans_t*)
void print_u_trans(kv_u_trans_t *ta)
{
    uint32_t i;
    u_trans_t *p = NULL;
    for (i = 0; i < ta->n; i++)
    {
        p = &(ta->a[i]);
        fprintf(stderr, "q-utg%.6ul\tqs(%u)\tqe(%u)\tt-utg%.6ul\tts(%u)\tte(%u)\trev(%u)\tw(%f)\tf(%u)\n", 
        p->qn+1, p->qs, p->qe, p->tn+1, 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 0x23774
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %eax, %eax
movq 0x2718d8(%rip), %r15    # 0x294fe0
leaq 0x219fa3(%rip), %r14    # 0x23d6b2
movq 0x10(%rbx), %rsi
imulq $0x30, %rax, %rax
movq (%r15), %rdi
movl 0x8(%rsi,%rax), %edx
incl %edx
movl (%rsi,%rax), %ecx
movl 0x4(%rsi,%rax), %r8d
movl 0x14(%rsi,%rax), %r9d
incl %r9d
movl 0xc(%rsi,%rax), %r10d
movl 0x10(%rsi,%rax), %r11d
movzbl 0x28(%rsi,%rax), %r12d
movl %r12d, %r13d
shrl $0x6, %r13d
andl $0x1, %r13d
movsd 0x20(%rsi,%rax), %xmm0
andl $0x3f, %r12d
movq %r14, %rsi
movb $0x1, %al
pushq %r12
pushq %r13
pushq %r11
pushq %r10
callq 0x22b0
addq $0x20, %rsp
movl %ebp, %eax
incl %ebp
cmpq %rax, (%rbx)
ja 0x2370f
movq 0x271865(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x218f27(%rip), %rsi    # 0x23c6ac
leaq 0x21c2e7(%rip), %rdx    # 0x23fa73
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/inter.cpp
// Function: uidx_build(ma_ug_t*, mg_idxopt_t*)
void uidx_build(ma_ug_t *ug, mg_idxopt_t *opt)
{
    int flag = asm_opt.flag;
    asm_opt.flag |= HA_F_NO_HPC;
    ha_flt_tab = ha_ft_ug_gen(&asm_opt, &(ug->u), opt->is_HPC, opt->k, opt->w, 1, opt->hap_n*5);
    ha_idx = ha_pt_ug_gen(&asm_opt, ha_flt_tab, &(ug->u), opt->is_HPC, opt->k, opt->w, 1);
    asm_opt.flag = flag;
	fprintf(stderr, "[M::%s] Index has been built.\n", __func__);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x271e26(%rip), %rbx    # 0x295758
movl (%rbx), %ebp
movl %ebp, %eax
orl $0x1, %eax
movl %eax, (%rbx)
movl 0x10(%rsi), %edx
movl (%rsi), %r8d
movl 0x4(%rsi), %ecx
imull $0x5, 0x14(%rsi), %eax
movl %eax, (%rsp)
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13891
leaq 0x272acf(%rip), %rcx    # 0x296430
movq %rax, (%rcx)
movl 0x10(%r15), %ecx
movl (%r15), %r9d
movl 0x4(%r15), %r8d
movl $0x1, (%rsp)
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x13c2a
leaq 0x272aad(%rip), %rcx    # 0x296438
movq %rax, (%rcx)
movl %ebp, (%rbx)
movq 0x271649(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x21c273(%rip), %rsi    # 0x23fc14
leaq 0x21c298(%rip), %rdx    # 0x23fc40
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22b0