LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: rescall_ul_pipeline(uldat_t*, enzyme const*)
int rescall_ul_pipeline(uldat_t* sl, const enzyme *fn)
{
    double index_time = yak_realtime();
    int32_t i; 
	///debug
	// overall_zdbg = init_mul_debug_prt_t(UL_INF.n);

    for (i = 0; i < fn->n; i++){
        gzFile fp;
        if ((fp = gzopen(fn->a[i], "r")) == 0) return 0;
        sl->ks = kseq_init(fp);
        kt_pipeline(3, worker_ul_rescall_pipeline, sl, 3);
        kseq_destroy(sl->ks);
        gzclose(fp);
    }
	sl->hits.total_base = sl->total_base;
	sl->hits.total_pair = sl->total_pair;
    fprintf(stderr, "[M::%s::%.3f] ==> Qualification\n", __func__, yak_realtime()-index_time);
	fprintf(stderr, "[M::%s::] ==> # reads: %lu, # bases: %lu, # fully corrected reads: %lu\n", 
	__func__, UL_INF.n, sl->total_base, sl->num_corrected_bases);
	// fprintf(stderr, "[M::%s::] ==> # bases: %lu; # corrected bases: %lu; # recorrected bases: %lu\n", 
	// __func__, sl->num_bases, sl->num_corrected_bases, sl->num_recorrected_bases);
	// gen_ul_vec_rid_t(&UL_INF);
	// for (i = 0; i < UL_INF.n; i++) {
	// 	fprintf(stderr, "[M::%s] rid::%d, dd::%u\n", __func__, i, UL_INF.a[i].dd);
	// }
	// print_mul_debug_prt_t(asm_opt.output_file_name, overall_zdbg);
	// print_raw_uls_seq_direct(sl->uu->ug, &UL_INF, asm_opt.output_file_name);

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
callq 0xefea7
movsd %xmm0, (%rsp)
leaq 0x5c846(%rip), %r15     # 0x1f16b7
pushq $0x3
popq %rbp
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x194edb
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x22d0
testq %rax, %rax
je 0x194eca
movq %rax, %r13
movq %rax, %rdi
callq 0x181b19
movq %rax, 0x48(%rbx)
movl %ebp, %edi
leaq 0x9e(%rip), %rsi        # 0x194f48
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xc6979
movq 0x48(%rbx), %rdi
callq 0x181f21
movq %r13, %rdi
callq 0x2390
incq %r12
jmp 0x194e74
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movupd 0x60(%rbx), %xmm0
movupd %xmm0, 0x88(%rbx)
movq 0xbe0f1(%rip), %r12     # 0x252fe0
movq (%r12), %r14
callq 0xefea7
subsd (%rsp), %xmm0
leaq 0x5945b(%rip), %rsi     # 0x1ee35f
leaq 0x61391(%rip), %r15     # 0x1f629c
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x22b0
movq (%r12), %rdi
leaq 0xbf3f5(%rip), %rax     # 0x254318
movq 0x50(%rax), %rcx
movq 0x60(%rbx), %r8
movq 0xd8(%rbx), %r9
leaq 0x61377(%rip), %rsi     # 0x1f62b0
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
pushq $0x1
popq %rax
jmp 0x194ecc
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: recorrect_ul_pipeline(uldat_t*, enzyme const*)
int recorrect_ul_pipeline(uldat_t* sl, const enzyme *fn)
{
    double index_time = yak_realtime();
    int32_t i; 

    for (i = 0; i < fn->n; i++){
        gzFile fp;
        if ((fp = gzopen(fn->a[i], "r")) == 0) return 0;
        sl->ks = kseq_init(fp);
        kt_pipeline(2, worker_ul_recorrect_pipeline, sl, 2);
        kseq_destroy(sl->ks);
        gzclose(fp);
    }
	sl->hits.total_base = sl->total_base;
	sl->hits.total_pair = sl->total_pair;
    fprintf(stderr, "[M::%s::%.3f] ==> Qualification\n", __func__, yak_realtime()-index_time);
	fprintf(stderr, "[M::%s::] ==> # reads: %lu, # processed reads: %lu, # fixed reads: %lu\n", 
	__func__, UL_INF.n, sl->num_bases, sl->num_corrected_bases);
	// fprintf(stderr, "[M::%s::] ==> # bases: %lu; # corrected bases: %lu; # recorrected bases: %lu\n", 
	// __func__, sl->num_bases, sl->num_corrected_bases, sl->num_recorrected_bases);
	// gen_ul_vec_rid_t(&UL_INF);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
callq 0xefea7
movsd %xmm0, (%rsp)
leaq 0x5c322(%rip), %r15     # 0x1f16b7
pushq $0x2
popq %rbp
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x1953ff
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x22d0
testq %rax, %rax
je 0x1953ee
movq %rax, %r13
movq %rax, %rdi
callq 0x181b19
movq %rax, 0x48(%rbx)
movl %ebp, %edi
leaq 0xa1(%rip), %rsi        # 0x19546f
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xc6979
movq 0x48(%rbx), %rdi
callq 0x181f21
movq %r13, %rdi
callq 0x2390
incq %r12
jmp 0x195398
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movupd 0x60(%rbx), %xmm0
movupd %xmm0, 0x88(%rbx)
movq 0xbdbcd(%rip), %r12     # 0x252fe0
movq (%r12), %r14
callq 0xefea7
subsd (%rsp), %xmm0
leaq 0x58f37(%rip), %rsi     # 0x1ee35f
leaq 0x60ec9(%rip), %r15     # 0x1f62f8
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x22b0
movq (%r12), %rdi
leaq 0xbeed1(%rip), %rax     # 0x254318
movq 0x50(%rax), %rcx
movq 0xd0(%rbx), %r8
movq 0xd8(%rbx), %r9
leaq 0x60eae(%rip), %rsi     # 0x1f630e
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
pushq $0x1
popq %rax
jmp 0x1953f0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: print_ul_rs(all_ul_t*)
int print_ul_rs(all_ul_t *U_INF)
{
	uint32_t i;
	UC_Read ur;
	init_UC_Read(&ur);
	for (i = 0; i < U_INF->n; i++) {
		retrieve_ul_t(&ur, NULL, U_INF, i, 0, 0, -1);
		fprintf(stderr, ">%s\n", U_INF->nid.a[i].a);
		fprintf(stderr, "%.*s\n", (int)ur.length, ur.seq);		
	}

	destory_UC_Read(&ur);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6bd1
movq 0xbd774(%rip), %rbp     # 0x252fe0
leaq 0x60ae3(%rip), %r15     # 0x1f6356
leaq 0x627f0(%rip), %r12     # 0x1f806a
xorl %eax, %eax
movl %eax, %r13d
cmpq %r13, 0x50(%rbx)
jbe 0x1958da
orq $-0x1, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x9a1b
movq (%rbp), %rdi
movq 0x10(%rbx), %rax
movq %r13, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x22b0
movq (%rbp), %rdi
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %rcx
movq %r12, %rsi
xorl %eax, %eax
callq 0x22b0
leal 0x1(%r13), %eax
jmp 0x19587c
leaq 0x8(%rsp), %rdi
callq 0x6b07
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: print_gaf(ma_ug_t const*, mg_gres_a*, mg_dbn_t*)
void print_gaf(const ma_ug_t *ug, mg_gres_a *hits, mg_dbn_t *name)
{
	uint64_t i, q;
	int32_t k, nl, m;
	char *nn; mg_gchain_t *gc; mg_lres_t *lc; 
	for (i = 0; i < hits->n; i++) {
		q = hits->a[i].qid;
		nn = name->cc.a + (q>0?name->a[q-1]:0);
		nl = name->a[q] - (q>0?name->a[q-1]:0);
		for (k = 0; k < hits->a[i].n_gc; k++) {
			gc = &(hits->a[i].gc[k]);
			fprintf(stderr, "S\t%.*s\tq:id:%lu\tl:n:%d\n", nl, nn, q, gc->cnt);
			for (m = 0; m < gc->cnt; m++) {
				lc = &(hits->a[i].lc[gc->off + m]);
				fprintf(stderr, "*\tA\tutg%.6d%c\t%c\tqs:%u\tqe:%u\tql:%lu\tts:%u\tte:%u\ttl:%u\tcnt:%d\n", 
				(lc->v>>1)+1, "lc"[ug->u.a[lc->v>>1].circ], "+-"[lc->v&1], lc->qs, lc->qe, hits->a[i].qlen, lc->ts, lc->te, ug->u.a[lc->v>>1].len, lc->cnt);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x28(%rsp)
xorl %ecx, %ecx
cmpq (%r12), %rcx
jae 0x195a8f
movq 0x10(%r12), %rax
movq %rcx, 0x10(%rsp)
imulq $0x28, %rcx, %r13
movq 0x18(%rax,%r13), %r8
movq 0x8(%rsp), %rdx
movq 0x10(%rdx), %rsi
movq 0x30(%rdx), %rcx
testq %r8, %r8
je 0x19594f
leaq (%rsi,%r8,8), %rsi
movq -0x8(%rsi), %rdx
addq %rdx, %rcx
jmp 0x195951
xorl %edx, %edx
movl (%rsi), %esi
subl %edx, %esi
movl %esi, 0x4(%rsp)
xorl %esi, %esi
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movslq (%rax,%r13), %rdx
cmpq %rdx, %rsi
jge 0x195a82
addq %r13, %rax
movq 0x8(%rax), %rax
movq %rsi, 0x30(%rsp)
imulq $0x48, %rsi, %rsi
leaq (%rax,%rsi), %r15
movq 0xbd653(%rip), %rdx     # 0x252fe0
movq (%rdx), %rdi
movl 0xc(%rax,%rsi), %r9d
leaq 0x609bf(%rip), %rsi     # 0x1f635b
movl 0x4(%rsp), %edx
xorl %eax, %eax
callq 0x22b0
xorl %ebp, %ebp
jmp 0x195a5c
movq 0x10(%r12), %r11
movslq 0x8(%r15), %rax
addq %rbp, %rax
imulq $0x1c, %rax, %rax
movq 0xbd61b(%rip), %rcx     # 0x252fe0
movq (%rcx), %rdi
movq 0x10(%r11,%r13), %rcx
movl (%rcx,%rax), %edx
movq %rdx, 0x40(%rsp)
movl 0x4(%rcx,%rax), %esi
movl %esi, %edx
shrl %edx
imulq $0x28, %rdx, %r8
incl %edx
movq 0x28(%rsp), %r9
movq 0x10(%r9), %r9
movl (%r9,%r8), %r14d
movl 0xc(%rcx,%rax), %r9d
movl 0x10(%rcx,%rax), %r8d
movq %r8, 0x38(%rsp)
movl 0x14(%rcx,%rax), %ebx
movq %r15, %r10
movl 0x18(%rcx,%rax), %r15d
movl %r14d, %eax
shrl $0x1f, %eax
leaq 0x50c73(%rip), %rcx     # 0x1e668b
movsbl (%rax,%rcx), %ecx
andl $0x1, %esi
leaq 0x4e7fd(%rip), %rax     # 0x1e4223
movsbl (%rsi,%rax), %r8d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
leaq 0x6093a(%rip), %rsi     # 0x1f6373
xorl %eax, %eax
pushq 0x40(%rsp)
pushq %r14
pushq %r15
movq %r10, %r15
pushq %rbx
pushq 0x20(%r11,%r13)
pushq 0x60(%rsp)
callq 0x22b0
addq $0x30, %rsp
incq %rbp
cmpl 0xc(%r15), %ebp
jl 0x1959ae
movq 0x30(%rsp), %rsi
incq %rsi
movq 0x10(%r12), %rax
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %rcx
jmp 0x195965
movq 0x10(%rsp), %rcx
incq %rcx
jmp 0x195913
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: get_asm_cov(ma_ug_t*, unsigned long, mul_ov_t*)
void get_asm_cov(ma_ug_t *ug, uint64_t ul_base, mul_ov_t *aov)
{
	int64_t ss = asm_opt.hg_size;
	if(ss < 0) {
		uint64_t i, k, an;
		int64_t sp;
		asg_t *g = ug->g;
		asg_arc_t *av = NULL;
		for (i = 0, ss = 0; i < g->n_seq; i++) {
			sp = g->seq[i].len; av = asg_arc_a(g, i); an = asg_arc_n(g, i);
			for (k = 0; k < an; k++) {
				if(av[k].del) continue;
				if((av[k].v) < i) {
					sp -= ((int64_t)av[k].ol);
				}
			}
			if(sp > 0) ss += sp;
		}		
	} else {
		ss *= asm_opt.polyploidy;
	}

	if(ss <= 0) ss = 1;
	
	aov->asm_cov = ul_base/ss; aov->asm_size = ss;
	fprintf(stderr, "[M::%s::] ==> asm_cov: %lu, asm_size: %lu\n", __func__, aov->asm_cov, aov->asm_size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rax
leaq 0xbd7f3(%rip), %rsi     # 0x253758
movq 0x200(%rsi), %rdx
testq %rdx, %rdx
jns 0x195ff6
movq 0x18(%rdi), %rsi
movl 0x14(%rsi), %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %edx, %edx
cmpq %rdi, %r9
je 0x196001
movq 0x8(%rsi), %rbx
movq 0x20(%rsi), %r10
movl (%r10,%r9,8), %r10d
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
movq 0x28(%rsi), %r11
movq (%r11,%r9,8), %r11
movl %r11d, %r14d
movq %r11, %r15
shrq $0x20, %r15
imulq $0x18, %r14, %r11
imulq $0x18, %r15, %r14
addq %r14, %rbx
addq $0xc, %rbx
xorl %r14d, %r14d
cmpq %r14, %r11
je 0x195fe7
movslq (%rbx,%r14), %r15
testq %r15, %r15
js 0x195fe1
movl -0x4(%rbx,%r14), %r12d
cmpq %r12, %r9
jbe 0x195fe1
subq %r15, %r10
addq $0x18, %r14
jmp 0x195fc6
testq %r10, %r10
cmovleq %r8, %r10
addq %r10, %rdx
incq %r9
jmp 0x195f8a
movslq 0x1bc(%rsi), %rsi
imulq %rsi, %rdx
cmpq $0x2, %rdx
movabsq $0x1, %r8
cmovgeq %rdx, %r8
xorl %edx, %edx
divq %r8
movq %rax, 0x8(%rcx)
movq %r8, (%rcx)
movq 0xbcfba(%rip), %rcx     # 0x252fe0
movq (%rcx), %rdi
leaq 0x60407(%rip), %rsi     # 0x1f6437
leaq 0x6042b(%rip), %rdx     # 0x1f6462
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: spec_ovlp_occ(eg_srt_t*, int, int, int, int)
int32_t spec_ovlp_occ(eg_srt_t *a, int32_t a_n, int32_t st, int32_t vv, int32_t c_thres)
{
	int32_t i, dst = a[st].d, occ = 1;
	if(occ >= c_thres) return 1;
	for (i = st + 1; i < a_n; i++) {
		if(a[i].id == a[st].id) continue;
		if(a[i].d - dst <= vv) {
			occ++;
			if(occ >= c_thres) return 1; 
		}
	}

	for (i = st - 1; i >= 0; i--) {
		if(a[i].id == a[st].id) continue;
		if(dst - a[i].d <= vv) {
			occ++;
			if(occ >= c_thres) return 1; 
		}
	}	
	return 0;
}

// Assembly:
cmpl $0x2, %r8d
jge 0x196054
movl $0x1, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq %edx, %r11
imulq $0x18, %r11, %rax
leaq (%rdi,%rax), %r9
movl 0x10(%rdi,%rax), %r10d
movslq %esi, %rbx
leaq 0x2c(%rdi), %r14
movl $0x1, %eax
movl %eax, %esi
imulq $0x18, %r11, %r15
incq %r11
addq %r14, %r15
cmpq %rbx, %r11
jge 0x1960ad
movl (%r15), %ebp
cmpl 0x14(%r9), %ebp
je 0x19609b
movl -0x4(%r15), %ebp
subl %r10d, %ebp
cmpl %ecx, %ebp
jle 0x1960a4
incq %r11
addq $0x18, %r15
jmp 0x196082
incl %esi
cmpl %r8d, %esi
jl 0x196078
jmp 0x1960ee
movl %edx, %edx
addq $-0x4, %rdi
movl %edx, %r11d
imulq $0x18, %rdx, %rbx
decq %rdx
addq %rdi, %rbx
testl %r11d, %r11d
jle 0x1960ec
movl (%rbx), %ebp
cmpl 0x14(%r9), %ebp
je 0x1960d7
movl %r10d, %ebp
subl -0x4(%rbx), %ebp
cmpl %ecx, %ebp
jle 0x1960e3
decl %r11d
decq %rdx
addq $-0x18, %rbx
jmp 0x1960c0
incl %esi
cmpl %r8d, %esi
jl 0x1960b3
jmp 0x1960ee
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: ul_align(mg_idxopt_t*, ug_opt_t const*, asg_t const*, enzyme const*, void*, ha_pt_s*, ma_ug_t*)
int ul_align(mg_idxopt_t *opt, const ug_opt_t *uopt, const asg_t *rg, const enzyme *fn, void *ha_flt_tab, ha_pt_t *ha_idx, ma_ug_t *ug)
{
    uldat_t sl; memset(&sl, 0, sizeof(sl));
    sl.ha_flt_tab = ha_flt_tab;
    sl.ha_idx = ha_idx;
    sl.opt = opt;   
    sl.chunk_size = 200000000;
    sl.n_thread = asm_opt.thread_num;
    sl.ug = ug;
	sl.rg = rg;
	sl.uopt = uopt;
	if(!load_ul_hits(&sl.hits, &sl.nn, asm_opt.output_file_name)) {
    	alignment_ul_pipeline(&sl, fn);
		write_ul_hits(&sl.hits, &sl.nn, asm_opt.output_file_name);
	}

	mul_ov_t aov; memset(&aov, 0, sizeof(aov));
	get_asm_cov(ug, sl.hits.total_base, &aov);
	fprintf(stderr, "[M::%s::] ==> total_pair: %lu, total_base: %lu, n: %d\n", 
										__func__, sl.hits.total_pair, sl.hits.total_base, (int32_t)sl.hits.n);



	get_ul_g(&aov, &sl.hits, ug, rg, 0.51, 0.1, 500, 1000);

	

	// print_gaf(ug, &(sl.hits), &(sl.nn));
	mg_gres_a_des(&(sl.hits)); free(sl.nn.a); free(sl.nn.cc.a);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %r9, %r15
movq %r8, %r13
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x50(%rsp), %r12
movl $0xb8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x20e0
movq %r13, -0x30(%r12)
movq %r15, -0x28(%r12)
movq %r14, -0x20(%r12)
movq $0xbebc200, 0x20(%r12)  # imm = 0xBEBC200
leaq 0xbc64a(%rip), %r14     # 0x253758
movslq 0x7c(%r14), %rax
movq %rax, 0x28(%r12)
movq 0x140(%rsp), %rax
movq %rax, -0x18(%r12)
movq %rbx, -0x10(%r12)
movq %rbp, -0x8(%r12)
leaq 0x90(%rsp), %r15
leaq 0xb8(%rsp), %r13
movq 0x10(%r14), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x195c9d
testl %eax, %eax
jne 0x19716f
leaq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x181a4c
movq 0x10(%r14), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x195a9e
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
movq 0xa8(%rsp), %rsi
movq 0x140(%rsp), %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x195f51
movq 0xbbe42(%rip), %rax     # 0x252fe0
movq (%rax), %rdi
movq 0xb0(%rsp), %rcx
movq 0xa8(%rsp), %r8
movl 0x90(%rsp), %r9d
leaq 0x5f3e8(%rip), %rsi     # 0x1f65a8
leaq 0x5f418(%rip), %rdx     # 0x1f65df
xorl %eax, %eax
callq 0x22b0
movsd 0x4c3c2(%rip), %xmm0    # 0x1e3598
movsd 0x4ba12(%rip), %xmm1    # 0x1e2bf0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl $0x1f4, %r8d            # imm = 0x1F4
movl $0x3e8, %r9d            # imm = 0x3E8
callq 0x1965e0
movq %r15, %rdi
callq 0x15ab30
movq 0xc8(%rsp), %rdi
callq 0x2220
movq 0xe8(%rsp), %rdi
callq 0x2220
pushq $0x1
popq %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: ul_resolve(ma_ug_t*, asg_t const*, ug_opt_t const*, int)
void ul_resolve(ma_ug_t *ug, const asg_t *rg, const ug_opt_t *uopt, int hap_n)
{
	fprintf(stderr, "[M::%s::] ==> UL\n", __func__);
    mg_idxopt_t opt;
    init_mg_opt(&opt, 0, 19, 10, hap_n, 0, 0, 0.05, asm_opt.ul_error_rate_low, asm_opt.ul_error_rate_hpc, asm_opt.ul_ec_round);
	int exist = (asm_opt.load_index_from_disk? uidx_load(&ha_flt_tab, &ha_idx, asm_opt.output_file_name, NULL) : 0);
    if(exist == 0) uidx_build(ug, &opt);
	if(exist == 0) uidx_write(ha_flt_tab, ha_idx, asm_opt.output_file_name, NULL);
    ul_align(&opt, uopt, rg, asm_opt.ar, ha_flt_tab, ha_idx, ug);
    uidx_destory();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0xbbd8d(%rip), %rax     # 0x252fe0
movq (%rax), %rdi
leaq 0x5f38b(%rip), %rsi     # 0x1f65e8
leaq 0x5f396(%rip), %rdx     # 0x1f65fa
xorl %eax, %eax
callq 0x22b0
leaq 0xbc4e6(%rip), %r12     # 0x253758
movl 0x240(%r12), %eax
movl %ebp, 0x24(%rsp)
andl $0x0, 0x20(%rsp)
movaps 0x5a756(%rip), %xmm0    # 0x1f19e0
movaps %xmm0, 0x10(%rsp)
movaps 0x5a6ba(%rip), %xmm0    # 0x1f1950
movups %xmm0, 0x38(%rsp)
movsd 0x5a6bd(%rip), %xmm0    # 0x1f1960
movsd %xmm0, 0x60(%rsp)
movaps 0x5a6c0(%rip), %xmm0    # 0x1f1970
movups %xmm0, 0x28(%rsp)
movaps 0x5a6c4(%rip), %xmm0    # 0x1f1980
movups %xmm0, 0x48(%rsp)
movabsq $0x500000006, %rcx      # imm = 0x500000006
movq %rcx, 0x58(%rsp)
movl $0x3f4ccccd, 0x68(%rsp) # imm = 0x3F4CCCCD
andl $0x0, 0x90(%rsp)
xorps %xmm0, %xmm0
movhps 0x4c22e(%rip), %xmm0    # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, 0x70(%rsp)
movups 0x230(%r12), %xmm0
movaps %xmm0, 0x80(%rsp)
movl %eax, 0x94(%rsp)
cmpl $0x0, 0xf0(%r12)
je 0x197330
movq 0x10(%r12), %rdx
leaq 0xbd112(%rip), %rdi     # 0x254430
leaq 0xbd113(%rip), %rsi     # 0x254438
xorl %ecx, %ecx
callq 0xd7e38
testl %eax, %eax
jne 0x19735d
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x15aa63
leaq 0xbd0ec(%rip), %rax     # 0x254430
movq (%rax), %rdi
leaq 0xbd0ea(%rip), %rax     # 0x254438
movq (%rax), %rsi
movq 0x10(%r12), %rdx
xorl %ecx, %ecx
callq 0xd7c88
movq 0x68(%r12), %rcx
leaq 0xbd0c7(%rip), %rax     # 0x254430
movq (%rax), %r8
leaq 0xbd0c5(%rip), %rax     # 0x254438
movq (%rax), %r9
movq %r15, (%rsp)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1970b6
callq 0x15aafe
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: print_dedup_HiFis_seq(ma_ug_t*)
void print_dedup_HiFis_seq(ma_ug_t *ug)
{
	uint64_t i;
	ma_utg_t *p = NULL;
	for (i = 0; i < ug->u.n; i++) {
		p = &(ug->u.a[i]);
		CALLOC(p->s, p->len+1);
		retrieve_u_seq(NULL, p->s, p, 0, 0, -1, NULL);
		p->s[p->len] = '\0';
	}

	FILE* output_file = fopen("dedup_HiFis_seq.gfa", "w");
    ma_ug_print(ug, NULL, NULL, NULL, NULL, "utg", output_file);
    fclose(output_file);

	output_file = fopen("dedup_HiFis_seq.noseq.gfa", "w");
	ma_ug_print_simple(ug, NULL, NULL, NULL, NULL, "utg", output_file);
	fclose(output_file);
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r14d, %r14d
cmpq (%rbx), %r14
jae 0x19741a
movq 0x10(%rbx), %r15
leaq (%r15,%r13), %r12
movl (%r15,%r13), %edi
andq %rbp, %rdi
incq %rdi
pushq $0x1
popq %rsi
callq 0x2120
movq %rax, 0x20(%r15,%r13)
andq $0x0, (%rsp)
xorl %edi, %edi
movq %rax, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq $-0x1
popq %r9
callq 0x9f29
movq 0x20(%r15,%r13), %rax
movl (%r15,%r13), %ecx
andq %rbp, %rcx
movb $0x0, (%rax,%rcx)
incq %r14
addq $0x28, %r13
jmp 0x1973c2
leaq 0x5f1e4(%rip), %rdi     # 0x1f6605
leaq 0x63279(%rip), %r14     # 0x1fa6a1
movq %r14, %rsi
callq 0x2210
movq %rax, %r15
movq %rax, (%rsp)
leaq 0x5683d(%rip), %r12     # 0x1edc7b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x7cd23
movq %r15, %rdi
callq 0x2190
leaq 0x5f1b8(%rip), %rdi     # 0x1f6619
movq %r14, %rsi
callq 0x2210
movq %rax, %r14
movq %rax, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x7de8f
movq %r14, %rdi
callq 0x2190
pushq $0x1
popq %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: hpc_l(char*, long, long, long)
uint32_t hpc_l(char *s, int64_t hof, int64_t sof, int64_t scut)
{
	if(scut == sof) return hof;
	if(scut < sof) sof = hof = 0;
	int64_t l, k;
	for (k=sof; (k>0)&&(k<scut)&&(s[k]==s[k-1])&&(seq_nt4_table[(uint8_t)s[k]]<4); k++) break;
	sof = k;
	for (l=sof, k=sof+1; k <= scut; k++) {
		if((k == scut) || (s[k] != s[l]) || (seq_nt4_table[(uint8_t)s[l]] >= 4)) {
			hof++; l = k;
		}
	}
	return hof;
}

// Assembly:
movq %rsi, %rax
cmpq %rdx, %rcx
jne 0x198042
retq
xorl %esi, %esi
cmpq %rdx, %rcx
cmovlq %rsi, %rax
cmovlq %rsi, %rdx
leaq 0x53aaa(%rip), %rsi     # 0x1ebb00
movq %rdx, %r8
leaq 0x1(%rdx), %r10
leaq -0x1(%r10), %r9
cmpq %rcx, %r9
jge 0x198041
movq %r10, %rdx
cmpq %r10, %rcx
je 0x198084
movzbl (%rdi,%rdx), %r9d
cmpb (%rdi,%r8), %r9b
jne 0x198084
leaq 0x1(%rdx), %r10
cmpb $0x4, (%rsi,%r9)
jb 0x19805d
incq %rax
jmp 0x198056
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: debug_append_inexact_edges(ma_ug_t*, ug_opt_t const*)
void debug_append_inexact_edges(ma_ug_t *ug, const ug_opt_t *uopt) {
	uint32_t n_asymm = 0, n_disconnect = 0, z, v, w, k, nv; asg_arc_t *av = NULL;
	for (z = 0; z < ug->g->n_arc; ++z) {
		if(ug->g->arc[z].del) continue;
		if(!get_ug_edge_src(ug, uopt->sources, uopt->max_hang, uopt->min_ovlp, 
													ug->g->arc[z].ul>>32, ug->g->arc[z].v)) {
			n_disconnect++;
		}
        v = ug->g->arc[z].v^1; w = (ug->g->arc[z].ul>>32)^1;
        nv = asg_arc_n(ug->g, v); av = asg_arc_a(ug->g, v);
        for (k = 0; k < nv; ++k) {
			if (av[k].del) continue;
			// fprintf(stderr, "found <%lu> -> <%u>\n", av[k].ul>>32, av[k].v);
			if (av[k].v == w) break;
		}
            
        if (k == nv) {
			ug->g->arc[z].del = 1, ++n_asymm;
			// fprintf(stderr, "# lack of <%u> -> <%u>, should be <%u> -> <%u>\n\n", w^1, v^1, v, w);
		}
    }

	if(n_asymm || n_disconnect) {
		asg_cleanup(ug->g); 
		fprintf(stderr, "[M::%s] # asymm edges: %u, # disconnect edges: %u\n", 
		__func__, n_asymm, n_disconnect);
		// exit(1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x18(%r15), %rdi
movl 0x4(%rdi), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r12
jae 0x1985de
movq 0x8(%rdi), %rax
imulq $0x18, %r12, %r13
cmpl $0x0, 0xc(%rax,%r13)
js 0x1985d6
addq %r13, %rax
movq 0x8(%r14), %rsi
movslq 0x40(%r14), %rdx
movslq 0x44(%r14), %rcx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
movq %r15, %rdi
callq 0x1630c4
cmpq $0x1, %rax
adcl $0x0, %ebx
movq 0x18(%r15), %rcx
movq 0x8(%rcx), %rax
movq 0x28(%rcx), %rdx
movl 0x4(%rax,%r13), %ecx
movl 0x8(%rax,%r13), %esi
xorq $0x1, %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, %rdi
shrq $0x20, %rdi
movl %edx, %esi
imulq $0x18, %rdi, %rdi
leaq (%rax,%rdi), %r8
addq $0xc, %r8
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x1985ce
cmpl $0x0, (%r8)
js 0x1985c1
movl -0x4(%r8), %r9d
xorl %ecx, %r9d
cmpl $0x1, %r9d
je 0x1985ca
incq %rdi
addq $0x18, %r8
jmp 0x1985a9
cmpl %edi, %edx
jne 0x1985d6
orb $-0x80, 0xf(%rax,%r13)
incl %ebp
incq %r12
jmp 0x198525
movl %ebp, %eax
orl %ebx, %eax
jne 0x1985f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x694eb
movq 0xba9e1(%rip), %rax     # 0x252fe0
movq (%rax), %rdi
leaq 0x5e07a(%rip), %rsi     # 0x1f6683
leaq 0x5e0a6(%rip), %rdx     # 0x1f66b6
movl %ebp, %ecx
movl %ebx, %r8d
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_O2/chhylp123[P]hifiasm/inter.cpp
// Function: load_emask_t(idx_emask_t**, char*, ma_ug_t*)
int32_t load_emask_t(idx_emask_t **z, char* file_name, ma_ug_t *ug)
{
	char* gfa_name = NULL; MALLOC(gfa_name, strlen(file_name)+50);
    sprintf(gfa_name, "%s.ul.msk.bin", file_name);
    FILE* fp = fopen(gfa_name, "r"); free(gfa_name);
    if (!fp) return 0;
    if(ug && (!test_dbug(ug, fp))) {
        fprintf(stderr, "[M::%s] Renew UL Index\n", __func__);
        fclose(fp);
        return 0;
    }
    uint64_t k; kv_emask_t *p; idx_emask_t *x; CALLOC(x, 1);


	fread(&x->n, sizeof(x->n), 1, fp); MALLOC(x->a, x->n); 
	for (k = 0; k < x->n; k++) {
		p = &(x->a[k]);
		fread(&p->n, sizeof(p->n), 1, fp); MALLOC(p->a, p->n); p->m = p->n;
		fread(p->a, sizeof((*(p->a))), p->n, fp);
	}
	
    fprintf(stderr, "[M::%s] Index has been loaded.\n", __func__);
    fclose(fp);
	*z = x;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2090
leaq 0x32(%rax), %rdi
callq 0x2280
movq %rax, %r12
leaq 0x5c5d8(%rip), %rsi     # 0x1f6761
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x57518(%rip), %rsi     # 0x1f16b7
movq %r12, %rdi
callq 0x2210
movq %rax, %r14
movq %r12, %rdi
callq 0x2220
testq %r14, %r14
jne 0x19a1c8
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r15, %r15
je 0x19a207
movq %r15, %rdi
movq %r14, %rsi
callq 0x871ea
testl %eax, %eax
jne 0x19a207
movq 0xb8dfd(%rip), %rax     # 0x252fe0
movq (%rax), %rdi
leaq 0x520c6(%rip), %rsi     # 0x1ec2b3
leaq 0x5c57b(%rip), %rdx     # 0x1f676f
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
callq 0x2190
jmp 0x19a1b7
movq %rbx, 0x10(%rsp)
pushq $0x1
popq %r15
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x8(%rax), %rdi
pushq $0x4
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
movl 0x8(%rbx), %r12d
imulq $0x18, %r12, %rdi
callq 0x2280
movq %rax, %r13
movq %rbx, 0x8(%rsp)
movq %rax, (%rbx)
addq $0x8, %r13
xorl %ebp, %ebp
pushq $0x20
popq %r15
cmpq %r12, %rbp
jae 0x19a29a
movq %r13, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x22f0
movq (%r13), %rbx
movq %rbx, %rdi
shlq $0x5, %rdi
callq 0x2280
movq %rax, -0x8(%r13)
movq %rbx, 0x8(%r13)
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x22f0
incq %rbp
addq $0x18, %r13
jmp 0x19a252
movq 0xb8d3f(%rip), %rax     # 0x252fe0
movq (%rax), %rdi
leaq 0x51f1b(%rip), %rsi     # 0x1ec1c6
leaq 0x5c4bd(%rip), %rdx     # 0x1f676f
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
callq 0x2190
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
pushq $0x1
popq %rbp
jmp 0x19a1b7
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: write_emask_t(idx_emask_t*, char*, ma_ug_t*)
int32_t write_emask_t(idx_emask_t *x, char* file_name, ma_ug_t *ug)
{
	char* gfa_name = NULL; MALLOC(gfa_name, strlen(file_name)+50);
    sprintf(gfa_name, "%s.ul.msk.bin", file_name);
    FILE* fp = fopen(gfa_name, "w"); free(gfa_name);
    if (!fp) return 0;
    uint64_t k; kv_emask_t *p = NULL;

    if(ug) write_dbug(ug, fp);

	fwrite(&x->n, sizeof(x->n), 1, fp);
	for (k = 0; k < x->n; k++) {
		p = &(x->a[k]);
		fwrite(&p->n, sizeof(p->n), 1, fp);
		fwrite(p->a, sizeof((*(p->a))), p->n, fp);
	}

    fprintf(stderr, "[M::%s] Index has been written.\n", __func__);
    fclose(fp);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2090
leaq 0x32(%rax), %rdi
callq 0x2280
movq %rax, %r12
leaq 0x5c45c(%rip), %rsi     # 0x1f6761
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x60386(%rip), %rsi     # 0x1fa6a1
movq %r12, %rdi
callq 0x2210
movq %rax, %r14
movq %r12, %rdi
callq 0x2220
testq %r14, %r14
jne 0x19a344
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r15, %r15
je 0x19a354
movq %r15, %rdi
movq %r14, %rsi
callq 0x873f8
leaq 0x8(%rbx), %r15
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2410
pushq $0x8
popq %r13
xorl %r12d, %r12d
jmp 0x19a3a5
movq (%rbx), %rbp
movq %rbp, %rdi
addq %r13, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x2410
movq -0x8(%rbp,%r13), %rdi
movq (%rbp,%r13), %rdx
pushq $0x20
popq %rsi
movq %r14, %rcx
callq 0x2410
incq %r12
addq $0x18, %r13
movl (%r15), %eax
cmpq %rax, %r12
jb 0x19a372
movq 0xb8c2c(%rip), %rax     # 0x252fe0
movq (%rax), %rdi
leaq 0x51da4(%rip), %rsi     # 0x1ec162
leaq 0x5c3b7(%rip), %rdx     # 0x1f677c
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
callq 0x2190
pushq $0x1
popq %rbp
jmp 0x19a333
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: gen_UL_reovlps(uldat_t*, ma_ug_t*, asg_t*, char*, int, int)
void gen_UL_reovlps(uldat_t *sl, ma_ug_t *ug, asg_t *sg, char* gfa_name, int32_t cutoff, int32_t is_emask)
{
	ul_idx_t *uu = gen_ul_idx(sl->uopt, ug, sg);
	int exist = (asm_opt.load_index_from_disk? uidx_load(&ha_flt_tab, &ha_idx, gfa_name, ug) : 0);
    if(exist == 0) uidx_l_build(uu->ug, (mg_idxopt_t *)sl->opt, cutoff);
	if(exist == 0) uidx_write(ha_flt_tab, ha_idx, gfa_name, ug);
	sl->ha_flt_tab = ha_flt_tab; sl->ha_idx = (ha_pt_t *)ha_idx; sl->uu = uu;	
	if(is_emask) {
		if((!(asm_opt.load_index_from_disk)) || (!load_emask_t(&(sl->mm), gfa_name, ug))) {
			sl->mm = graph_ovlp_binning(ug, sg, sl->uopt);
			write_emask_t(sl->mm, gfa_name, ug);
		}
	}

	init_ucr_file_t(sl, gfa_name, 1);
	ul_v_recall(sl, asm_opt.ar);
	destory_ucr_file_t(sl);
	///do not free ug
	uu->ug = NULL; destroy_ul_idx_t(uu); ha_ft_destroy(ha_flt_tab); ha_pt_destroy(ha_idx);
	sl->ha_flt_tab = NULL; sl->ha_idx = NULL; sl->uu = NULL;
	destroy_idx_emask_t(sl->mm); free(sl->mm); sl->mm = NULL;
	// exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r13d
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq %rdx, (%rsp)
callq 0x199880
movq %rax, %r14
leaq 0xb934b(%rip), %rax     # 0x253758
cmpl $0x0, 0xf0(%rax)
je 0x19a433
leaq 0xba013(%rip), %rdi     # 0x254430
leaq 0xba014(%rip), %rsi     # 0x254438
movq %r15, %rdx
movq %r12, %rcx
callq 0xd7e38
testl %eax, %eax
jne 0x19a461
movq (%r14), %rdi
movq 0x10(%rbx), %rsi
movl %r13d, %edx
callq 0x15a9e3
leaq 0xb9fe7(%rip), %rax     # 0x254430
movq (%rax), %rdi
leaq 0xb9fe5(%rip), %rax     # 0x254438
movq (%rax), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xd7c88
leaq 0xb9fc8(%rip), %r13     # 0x254430
movq (%r13), %rax
movq %rax, (%rbx)
leaq 0xb9fc2(%rip), %rax     # 0x254438
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movq %r14, 0x30(%rbx)
testl %ebp, %ebp
leaq 0xb92ce(%rip), %rbp     # 0x253758
je 0x19a4ca
cmpl $0x0, 0xf0(%rbp)
je 0x19a4a8
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x19a157
testl %eax, %eax
jne 0x19a4ca
movq 0x28(%rbx), %rdx
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x19a541
movq %rax, 0x38(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x19a2d6
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18202e
movq 0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x194e4c
movq %rbx, %rdi
callq 0x1820c7
andq $0x0, (%r14)
movq %r14, %rdi
callq 0x199f0f
movq (%r13), %rdi
callq 0xd5c37
leaq 0xb9f30(%rip), %rax     # 0x254438
movq (%rax), %rdi
callq 0xd4d2f
andq $0x0, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x38(%rbx), %rdi
callq 0x19a02e
movq 0x38(%rbx), %rdi
callq 0x2220
andq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: graph_ovlp_binning(ma_ug_t*, asg_t*, ug_opt_t const*)
idx_emask_t* graph_ovlp_binning(ma_ug_t *ug, asg_t *sg, const ug_opt_t *uopt)
{
	ug_bin_t sl; 
	init_aux_table(); ha_opt_update_cov(&asm_opt, asm_opt.hom_cov);
	init_ug_bin_t(&sl, uopt, 0, GBIN_K, GBIN_W, asm_opt.max_n_chain, GBIN_E, GBIN_E, GBIN_BE, GBIN_ME, GBIN_L,
	asm_opt.thread_num, 512, 3, 1, ug, sg);
	cal_graph_ovlp_binning(&sl);
	return sl.mm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x6b0f
leaq 0xb91f4(%rip), %rbx     # 0x253758
movl 0xd0(%rbx), %esi
movq %rbx, %rdi
callq 0x3430
movl 0x7c(%rbx), %eax
movl 0xe8(%rbx), %r9d
leaq 0x8(%rsp), %rbx
pushq $0x1f
popq %rcx
movsd 0x48fac(%rip), %xmm0    # 0x1e3538
movsd 0x52bc4(%rip), %xmm2    # 0x1ed158
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ecx, %r8d
movaps %xmm0, %xmm1
pushq %r15
pushq %r12
pushq $0x1
pushq $0x3
pushq $0x200                  # imm = 0x200
pushq %rax
pushq $0x100                  # imm = 0x100
pushq $0x4
callq 0x1a045c
addq $0x40, %rsp
movq %rbx, %rdi
callq 0x1a0f0b
movq 0xf8(%rbx), %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: drenew_UL_reovlps(uldat_t*, ma_ug_t*, asg_t*, char*, int)
uint32_t drenew_UL_reovlps(uldat_t *sl, ma_ug_t *ug, asg_t *sg, char* gfa_name, int32_t cutoff)
{
	uint32_t k, f_occ;
	kt_for(asm_opt.thread_num, dcheck_ulalignments_mul, ug, UL_INF.n);
	for (k = f_occ = 0; k < UL_INF.n; k++) {
		if(UL_INF.a[k].rlen&((uint32_t)(0x80000000))) f_occ++;
	}
	fprintf(stderr, "[M::%s::] # wrong UL alignments::%u\n", __func__, f_occ);
	if(f_occ == 0) return 0;//all set

	ul_idx_t *uu = gen_ul_idx(sl->uopt, ug, sg);
	int exist = (asm_opt.load_index_from_disk? uidx_load(&ha_flt_tab, &ha_idx, gfa_name, ug) : 0);
    if(exist == 0) uidx_l_build(uu->ug, (mg_idxopt_t *)sl->opt, cutoff);
	if(exist == 0) uidx_write(ha_flt_tab, ha_idx, gfa_name, ug);
	sl->ha_flt_tab = ha_flt_tab; sl->ha_idx = (ha_pt_t *)ha_idx; sl->uu = uu;	

	// init_ucr_file_t(sl, gfa_name, 1);
	recorrect_ul_pipeline(sl, asm_opt.ar);
	// destory_ucr_file_t(sl);
	///do not free ug
	uu->ug = NULL; destroy_ul_idx_t(uu); ha_ft_destroy(ha_flt_tab); ha_pt_destroy(ha_idx);
	sl->ha_flt_tab = NULL; sl->ha_idx = NULL; sl->uu = NULL;
	return 1;
	// exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb9157(%rip), %rax     # 0x253758
movl 0x7c(%rax), %edi
leaq 0xb9d0d(%rip), %r13     # 0x254318
movq 0x50(%r13), %rcx
leaq 0x132(%rip), %rsi       # 0x19a748
movq %r15, %rdx
callq 0xc67c0
movq 0x48(%r13), %rax
movq 0x50(%r13), %rcx
xorl %r13d, %r13d
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0x19a644
imulq $0x58, %rdx, %rsi
movl 0x18(%rax,%rsi), %esi
shrl $0x1f, %esi
addl %esi, %r13d
incl %edx
jmp 0x19a62b
movq 0xb8995(%rip), %rax     # 0x252fe0
movq (%rax), %rdi
leaq 0x5c135(%rip), %rsi     # 0x1f678a
leaq 0x5c153(%rip), %rdx     # 0x1f67af
xorl %ebp, %ebp
movl %r13d, %ecx
xorl %eax, %eax
callq 0x22b0
testl %r13d, %r13d
je 0x19a737
movq 0x28(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x199880
movq %rax, %r12
leaq 0xb90ce(%rip), %r13     # 0x253758
cmpl $0x0, 0xf0(%r13)
je 0x19a6b1
leaq 0xb9d95(%rip), %rdi     # 0x254430
leaq 0xb9d96(%rip), %rsi     # 0x254438
movq %r14, %rdx
movq %r15, %rcx
callq 0xd7e38
testl %eax, %eax
jne 0x19a6e1
movq (%r12), %rdi
movq 0x10(%rbx), %rsi
movl 0x4(%rsp), %edx
callq 0x15a9e3
leaq 0xb9d67(%rip), %rax     # 0x254430
movq (%rax), %rdi
leaq 0xb9d65(%rip), %rax     # 0x254438
movq (%rax), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xd7c88
leaq 0xb9d48(%rip), %r14     # 0x254430
movq (%r14), %rax
movq %rax, (%rbx)
leaq 0xb9d43(%rip), %r15     # 0x254438
movq (%r15), %rax
movq %rax, 0x8(%rbx)
movq %r12, 0x30(%rbx)
movq 0x68(%r13), %rsi
movq %rbx, %rdi
callq 0x195370
andq $0x0, (%r12)
movq %r12, %rdi
callq 0x199f0f
movq (%r14), %rdi
callq 0xd5c37
movq (%r15), %rdi
callq 0xd4d2f
andq $0x0, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: init_uldat_t(uldat_t*, void*, void*, mg_idxopt_t*, unsigned long, unsigned long, ug_opt_t const*, ul_idx_t*)
void init_uldat_t(uldat_t *sl, void *ha_flt_tab, void *ha_idx, mg_idxopt_t *opt, uint64_t chunk_size, uint64_t n_thread, const ug_opt_t *uopt, ul_idx_t *uu)
{
	memset(sl, 0, sizeof(uldat_t));
    sl->ha_flt_tab = ha_flt_tab;
    sl->ha_idx = (ha_pt_t *)ha_idx;
    sl->opt = opt;   
    sl->chunk_size = chunk_size;
    sl->n_thread = n_thread;
    sl->uu = uu;
    sl->uopt = uopt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
addq $0x18, %rdi
movl $0xd0, %edx
xorl %esi, %esi
callq 0x20e0
movq %r13, (%rbp)
movq %r12, 0x8(%rbp)
movq %r15, 0x10(%rbp)
movq %r14, 0x50(%rbp)
movq %rbx, 0x58(%rbp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x28(%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: update_ovlp_src(void*, long, int)
static void update_ovlp_src(void *data, long i, int tid) // callback for kt_for()
{
	uldat_t *sl = (uldat_t *)data;
	ma_hit_t_alloc* src = sl->uopt->sources;
	uint64_t z, k, *a, a_n;
	for (z = 0; z < src[i].length; z++) src[i].buffer[z].bl = 0;
	a = UL_INF.ridx.occ.a + UL_INF.ridx.idx.a[i];
	a_n = UL_INF.ridx.idx.a[i+1] - UL_INF.ridx.idx.a[i];
	// fprintf(stderr, "++i->%d, a_n->%lu++\n", i, a_n);
	for (k = 0; k < a_n; k++) {
		///note: we only label reliable chains
		// if(i == 4217) fprintf(stderr, "\nul_id: %lu\n", a[k]>>32);
		determine_connective_backtrack(&UL_INF, sl->uopt, &(UL_INF.a[a[k]>>32]), (uint32_t)(a[k]), i, a[k]>>32);
		// determine_connective_adv(&UL_INF, sl->uopt, G_CHAIN_BW, sl->opt->diff_ec_ul, &(UL_INF.a[a[k]>>32]), (uint32_t)(a[k]), i);
		// determine_connective(&UL_INF, sl->uopt, G_CHAIN_BW, sl->opt->diff_ec_ul, 
		// 										&(UL_INF.a[a[k]>>32]), (uint32_t)(a[k]), i);
	}
	// fprintf(stderr, "--i->%d, a_n->%lu--\n", i, a_n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rcx
imulq $0x18, %rsi, %rax
addq 0x8(%rcx), %rax
pushq $0x18
popq %rcx
xorl %edx, %edx
movabsq $-0x7fffffff00000001, %rsi # imm = 0x80000000FFFFFFFF
movl 0xc(%rax), %edi
cmpq %rdi, %rdx
jae 0x19afc7
movq (%rax), %rdi
andq %rsi, (%rdi,%rcx)
incq %rdx
addq $0x28, %rcx
jmp 0x19afaf
leaq 0xb934a(%rip), %r15     # 0x254318
movq 0x28(%r15), %rax
movl (%rax,%rbx,4), %r13d
movl 0x4(%rax,%rbx,4), %r12d
subl %r13d, %r12d
shlq $0x3, %r13
addq 0x40(%r15), %r13
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x19b012
movq 0x28(%r14), %rsi
movq (%r13,%rbp,8), %rcx
movq %rcx, %rax
shrq $0x20, %rax
imulq $0x58, %rax, %rdx
addq 0x48(%r15), %rdx
movq %rbx, %r8
callq 0x1946cf
incq %rbp
jmp 0x19afe8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: update_ovlp_src_bl(void*, long, int)
static void update_ovlp_src_bl(void *data, long i, int tid)
{
	uldat_t *sl = (uldat_t *)data;
	ma_hit_t_alloc* src = sl->uopt->sources;
	uint64_t z, sum; uint32_t qn, tn; int32_t idx;
	for (z = 0; z < src[i].length; z++) {
		qn = Get_qn(src[i].buffer[z]);
		tn = Get_tn(src[i].buffer[z]);
		if(qn > tn) continue;
		idx = get_specific_overlap(&(src[tn]), tn, qn);
		assert(idx != -1);
		sum = src[i].buffer[z].bl + src[tn].buffer[idx].bl;
		src[i].buffer[z].bl = src[tn].buffer[idx].bl = sum/**(sum&0x7fffffffU)**/;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x7fffffff00000000, %r15 # imm = 0x7FFFFFFF00000000
movq 0x28(%rdi), %rax
movq 0x8(%rax), %r12
imulq $0x18, %rsi, %r13
addq %r12, %r13
xorl %ebp, %ebp
xorl %r14d, %r14d
movl 0xc(%r13), %eax
cmpq %rax, %r14
jae 0x19b0c9
movq (%r13), %rax
movl 0x4(%rax,%rbp), %edx
movl 0xc(%rax,%rbp), %esi
cmpl %edx, %esi
jb 0x19b0c0
imulq $0x18, %rsi, %rbx
addq %r12, %rbx
movq %rbx, %rdi
callq 0x696ab
cmpl $-0x1, %eax
je 0x19b0d8
movq (%r13), %rcx
movq 0x18(%rcx,%rbp), %rcx
andq %r15, %rcx
movq (%rbx), %rdx
cltq
imulq $0x28, %rax, %rax
movq 0x18(%rdx,%rax), %rsi
addq %rsi, %rcx
andq %r15, %rcx
movabsq $-0x7fffffff00000001, %rdi # imm = 0x80000000FFFFFFFF
andq %rdi, %rsi
orq %rcx, %rsi
movq %rsi, 0x18(%rdx,%rax)
movq (%r13), %rax
movq 0x18(%rax,%rbp), %rdx
andq %rdi, %rdx
orq %rcx, %rdx
movq %rdx, 0x18(%rax,%rbp)
incq %r14
addq $0x28, %rbp
jmp 0x19b04a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c007(%rip), %rdi     # 0x1f70e6
leaq 0x56a3d(%rip), %rsi     # 0x1f1b23
leaq 0x5c003(%rip), %rcx     # 0x1f70f0
movl $0x4e12, %edx           # imm = 0x4E12
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: clean_contain_g0(uldat_t*)
void clean_contain_g0(uldat_t *sl)
{
	kt_for(sl->n_thread, clean_contained_chg, sl, R_INF.total_reads);
	asg_t *sg = (asg_t *)sl->rg; uint32_t k, cnt;
	for (k = cnt = 0; k < sg->n_seq; k++) {
		// if(is_contain_r((*(sl->uopt->ruIndex)), k)) {
		// 	fprintf(stderr, "[M::%s::]\t%.*s\n", __func__, (int)Get_NAME_LENGTH(R_INF, k), Get_NAME(R_INF, k));
		// }
		if(sg->seq_vis[k]) {
			asg_seq_del(sg, k); cnt++;
		}
		sg->seq_vis[k] = 0; 
	}
	if(cnt) asg_cleanup(sg);
	fprintf(stderr, "[M::%s::] # discard cread::%u\n", __func__, cnt); 
	// exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x58(%rdi), %edi
leaq 0xb9127(%rip), %rax     # 0x254230
movq 0x50(%rax), %rcx
leaq 0x77(%rip), %rsi        # 0x19b18b
movq %rbx, %rdx
callq 0xc67c0
movq 0x20(%rbx), %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
movl 0x14(%r14), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r15
jae 0x19b159
movq 0x30(%r14), %rax
cmpb $0x0, (%rax,%r15)
je 0x19b14f
movq %r14, %rdi
movl %r15d, %esi
callq 0x193082
incl %ebx
movq 0x30(%r14), %rax
movb $0x0, (%rax,%r15)
incq %r15
jmp 0x19b125
testl %ebx, %ebx
je 0x19b165
movq %r14, %rdi
callq 0x694eb
movq 0xb7e74(%rip), %rax     # 0x252fe0
movq (%rax), %rdi
leaq 0x5b670(%rip), %rsi     # 0x1f67e6
leaq 0x5b688(%rip), %rdx     # 0x1f6805
movl %ebx, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: clean_contained_chg(void*, long, int)
static void clean_contained_chg(void *data, long i, int tid) // callback for kt_for()
{
	uldat_t *sl = (uldat_t *)data;
	sl->rg->seq_vis[i] = 0;
	if(sl->rg->seq[i].del) return;
	if(!(is_contain_r((*(sl->uopt->ruIndex)), ((uint64_t)i)))) return;
	ma_hit_t_alloc* src = sl->uopt->sources;
	uint64_t z;
	for (z = 0; z < src[i].length; z++) {
		if(src[i].buffer[z].bl) break;
	}
	if(z >= src[i].length) sl->rg->seq_vis[i] = 1;
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x30(%rax), %rax
movb $0x0, (%rax,%rsi)
movq 0x20(%rdi), %rax
movq 0x20(%rax), %rcx
cmpl $0x0, (%rcx,%rsi,8)
js 0x19b1f0
movq 0x28(%rdi), %rcx
movq 0x30(%rcx), %rdx
cmpq %rsi, (%rdx)
jbe 0x19b1f0
movq 0x8(%rdx), %rdx
cmpl $0x0, (%rdx,%rsi,4)
js 0x19b1f0
movq 0x8(%rcx), %rdx
imulq $0x18, %rsi, %rdi
leaq (%rdx,%rdi), %rcx
movl 0xc(%rdx,%rdi), %edx
imulq $0x28, %rdx, %rdx
addq $0x28, %rdx
xorl %edi, %edi
leaq 0x28(%rdi), %r8
cmpq %r8, %rdx
je 0x19b1f1
movq (%rcx), %r9
testl $0x7fffffff, 0x1c(%r9,%rdi) # imm = 0x7FFFFFFF
movq %r8, %rdi
je 0x19b1d6
retq
movq 0x30(%rax), %rax
movb $0x1, (%rax,%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: label_contained_chg(void*, long, int)
static void label_contained_chg(void *data, long i, int tid) // callback for kt_for()
{
	uldat_t *sl = (uldat_t *)data; uint32_t v = i;
	sl->rg->seq_vis[v] = 0;
	if(sl->rg->seq[v>>1].del) return;
	if(is_contain_r((*(sl->uopt->ruIndex)), (v>>1))) {
		sl->rg->seq_vis[v] = 1; return;
	}
	asg_arc_t *av = asg_arc_a(sl->rg, v);
	uint32_t nv = asg_arc_n(sl->rg, v), k;
	for (k = 0; k < nv; ++k) {
		if(av[k].del) continue;
		if(is_contain_r((*(sl->uopt->ruIndex)), (av[k].v>>1))) break;
	}
	if(k < nv) sl->rg->seq_vis[v] = 1;
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x30(%rax), %rcx
movl %esi, %eax
movb $0x0, (%rcx,%rax)
movq 0x20(%rdi), %rcx
movq 0x20(%rcx), %rdx
shrl %esi
cmpl $0x0, (%rdx,%rsi,8)
js 0x19b8d9
movq 0x28(%rdi), %rdx
movq 0x30(%rdx), %rdx
movq (%rdx), %rdi
cmpq %rdi, %rsi
jae 0x19b8da
movq 0x8(%rdx), %r8
cmpl $0x0, (%r8,%rsi,4)
js 0x19b8da
movq 0x30(%rcx), %rcx
movb $0x1, (%rcx,%rax)
retq
movq 0x8(%rcx), %r8
movq 0x28(%rcx), %rsi
movq (%rsi,%rax,8), %rsi
movl %esi, %r9d
movq %rsi, %r10
shrq $0x20, %r10
imulq $0x18, %r9, %rsi
imulq $0x18, %r10, %r9
addq %r9, %r8
addq $0xc, %r8
xorl %r9d, %r9d
cmpq %r9, %rsi
je 0x19b8d9
cmpl $0x0, (%r8,%r9)
js 0x19b926
movl -0x4(%r8,%r9), %r10d
shrl %r10d
cmpq %r10, %rdi
jbe 0x19b926
movq 0x8(%rdx), %r11
cmpl $0x0, (%r11,%r10,4)
jns 0x19b8d1
addq $0x18, %r9
jmp 0x19b902
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: dedup_contain_g(ug_opt_t const*, asg_t*)
void dedup_contain_g(const ug_opt_t *uopt, asg_t *sg)
{
	mg_idxopt_t opt; uldat_t sl; int32_t cutoff;
	init_aux_table(); ha_opt_update_cov(&asm_opt, asm_opt.hom_cov);
	cutoff = asm_opt.max_n_chain;
	init_mg_opt(&opt, !(asm_opt.flag&HA_F_NO_HPC), 19, 10, cutoff, asm_opt.max_n_chain, asm_opt.ul_error_rate, asm_opt.ul_error_rate, asm_opt.ul_error_rate_low, asm_opt.ul_error_rate_hpc, asm_opt.ul_ec_round);
	init_uldat_t(&sl, NULL, NULL, &opt, CHUNK_SIZE, asm_opt.thread_num, uopt, NULL); sl.rg = sg;
	work_rg_contain_dedup(&sl);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6b0f
leaq 0xb7c1f(%rip), %r15     # 0x253758
movl 0xd0(%r15), %esi
movq %r15, %rdi
callq 0x3430
movl (%r15), %eax
movl 0xe8(%r15), %ecx
notl %eax
andl $0x1, %eax
movsd 0x238(%r15), %xmm0
movl 0x240(%r15), %edx
leaq 0xf0(%rsp), %r12
movl %ecx, 0x14(%r12)
movl %eax, 0x10(%r12)
movaps 0x55e60(%rip), %xmm1    # 0x1f19e0
movaps %xmm1, (%r12)
movaps 0x55dc4(%rip), %xmm1    # 0x1f1950
movups %xmm1, 0x28(%r12)
movsd 0x55dc6(%rip), %xmm1    # 0x1f1960
movsd %xmm1, 0x50(%r12)
movaps 0x55dc8(%rip), %xmm1    # 0x1f1970
movups %xmm1, 0x18(%r12)
movaps 0x55dcb(%rip), %xmm1    # 0x1f1980
movups %xmm1, 0x38(%r12)
movabsq $0x500000006, %rax      # imm = 0x500000006
movq %rax, 0x48(%r12)
movl $0x3f4ccccd, 0x58(%r12) # imm = 0x3F4CCCCD
movl %ecx, 0x80(%r12)
movups 0x228(%r15), %xmm1
movlps %xmm1, 0x60(%r12)
movups %xmm1, 0x68(%r12)
movsd %xmm0, 0x78(%r12)
movl %edx, 0x84(%r12)
movslq 0x7c(%r15), %r13
leaq 0x18(%rsp), %r15
movl $0xd0, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%r15)
movq %r12, -0x8(%r15)
movq $0x3b9aca00, 0x38(%r15) # imm = 0x3B9ACA00
movq %r13, 0x40(%r15)
movq %r14, 0x10(%r15)
movq %rbx, 0x8(%r15)
movq %rsp, %rdi
callq 0x193150
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq