LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/inter.cpp
// Function: ugl_cover_check(unsigned long, unsigned long, ma_utg_t*)
uint32_t ugl_cover_check(uint64_t is, uint64_t ie, ma_utg_t *u)
{
	if(is == 0 && ie == u->len) return 1;
	uint64_t l, i, us, ue;
	for (i = l = 0; i < u->n; i++) {
		us = l; ue = l + Get_READ_LENGTH(R_INF, (u->a[i]>>33));
		if(is <= us && ie >= ue) return 1;
		if(us >= ie) break;
		l += (uint32_t)u->a[i];
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f110a
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0x2f110a
movl $0x1, -0x4(%rbp)
jmp 0x2f11bc
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jae 0x2f11b5
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
leaq 0xd418f(%rip), %rcx     # 0x3c52d0
movq 0x18(%rcx), %rcx
movq -0x20(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq -0x30(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
shrq $0x21, %rdx
addq (%rcx,%rdx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x2f117e
movq -0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jb 0x2f117e
movl $0x1, -0x4(%rbp)
jmp 0x2f11bc
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2f118a
jmp 0x2f11b5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2f111a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/inter.cpp
// Function: find_ul_block_max_reverse(int, uc_block_t const*, unsigned int)
int32_t find_ul_block_max_reverse(int32_t n, const uc_block_t *a, uint32_t x)
{
    int32_t s = 0, e = n;
    if (n == 0) return n;
    if (a[0].qe < x) return 0;///max qe
    if (a[n-1].qe >= x) return n;///min qe

    while (e > s) { // TODO: finish this block
        int32_t m = s + (e - s) / 2;
        // if (a[m].qe >= x) e = m;
        // else s = m + 1;
		if (a[m].qe > x) s = m + 1;
		else e = m;
    }
    assert(s == e);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x2f1f70
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f2030
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x2f1f88
movl $0x0, -0x4(%rbp)
jmp 0x2f2030
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x2f1faf
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f2030
jmp 0x2f1fb1
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x2f2001
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x2f1ff9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2f1fff
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2f1fb1
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2f200b
jmp 0x2f202a
leaq 0x9eebe(%rip), %rdi     # 0x390ed0
leaq 0x9e816(%rip), %rsi     # 0x39082f
movl $0x4d48, %edx           # imm = 0x4D48
leaq 0xa2d34(%rip), %rcx     # 0x394d59
callq 0x2130
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/inter.cpp
// Function: find_ul_block_max(int, uc_block_t const*, unsigned int)
int32_t find_ul_block_max(int32_t n, const uc_block_t *a, uint32_t x)
{
    int32_t s = 0, e = n;
    if (n == 0) return -1;
    if (a[n-1].qe < x) return n - 1;
    if (a[0].qe >= x) return -1;
    while (e > s) { // TODO: finish this block
        int32_t m = s + (e - s) / 2;
        if (a[m].qe >= x) e = m;
        else s = m + 1;
    }
    assert(s == e);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x2f2071
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2134
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x2f209b
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2f2134
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x2f20b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2134
jmp 0x2f20b5
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x2f2105
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x2f20fa
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2f2103
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2f20b5
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2f210f
jmp 0x2f212e
leaq 0x9edba(%rip), %rdi     # 0x390ed0
leaq 0x9e712(%rip), %rsi     # 0x39082f
movl $0x4d57, %edx           # imm = 0x4D57
leaq 0xa2c79(%rip), %rcx     # 0x394da2
callq 0x2130
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/inter.cpp
// Function: scall_ul_pipeline(uldat_t*, enzyme const*)
int scall_ul_pipeline(uldat_t* sl, const enzyme *fn)
{
    double index_time = yak_realtime();
    int i;

	init_all_ul_t(&UL_INF, &R_INF);
    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_scall_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\n", __func__, UL_INF.n, sl->total_base);
	// 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);
	fprintf(stderr, "[M::%s::] ==> # fully covered reads: %lu\n", __func__, sl->num_bases);
	gen_ul_vec_rid_t(&UL_INF, &R_INF, NULL);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x20(%rbp)
leaq 0xd2a37(%rip), %rdi     # 0x3c53b8
leaq 0xd2948(%rip), %rsi     # 0x3c52d0
callq 0xbb50
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2f2a25
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x9da1b(%rip), %rsi     # 0x3903d6
callq 0x22c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x2f29d6
movl $0x0, -0x4(%rbp)
jmp 0x2f2af6
movq -0x30(%rbp), %rdi
callq 0x2ce660
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdx
movl $0x3, %ecx
leaq 0x106(%rip), %rsi       # 0x2f2b00
movl %ecx, %edi
callq 0x16d950
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2cee50
movq -0x30(%rbp), %rdi
callq 0x2380
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2f2994
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq 0xd158e(%rip), %rax     # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1b7ca0
movq -0x38(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
leaq 0x9a662(%rip), %rsi     # 0x38d0d0
leaq 0xa2535(%rip), %rdx     # 0x394faa
movb $0x1, %al
callq 0x22a0
movq 0xd155d(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0xd292b(%rip), %rax     # 0x3c53b8
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %r8
leaq 0xa24b4(%rip), %rsi     # 0x394f54
leaq 0xa2503(%rip), %rdx     # 0x394faa
movb $0x0, %al
callq 0x22a0
movq 0xd152b(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rcx
leaq 0xa24b4(%rip), %rsi     # 0x394f7e
leaq 0xa24d9(%rip), %rdx     # 0x394faa
movb $0x0, %al
callq 0x22a0
leaq 0xd28d9(%rip), %rdi     # 0x3c53b8
leaq 0xd27ea(%rip), %rsi     # 0x3c52d0
xorl %eax, %eax
movl %eax, %edx
callq 0x2f0d10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2f32f2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x9d14e(%rip), %rsi     # 0x3903d6
callq 0x22c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x2f32a3
movl $0x0, -0x4(%rbp)
jmp 0x2f338d
movq -0x30(%rbp), %rdi
callq 0x2ce660
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdx
movl $0x3, %ecx
leaq 0xd9(%rip), %rsi        # 0x2f33a0
movl %ecx, %edi
callq 0x16d950
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2cee50
movq -0x30(%rbp), %rdi
callq 0x2380
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2f3261
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq 0xd0cc1(%rip), %rax     # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1b7ca0
movq -0x38(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
leaq 0x99d95(%rip), %rsi     # 0x38d0d0
leaq 0xa1c66(%rip), %rdx     # 0x394fa8
movb $0x1, %al
callq 0x22a0
movq 0xd0c90(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0xd205e(%rip), %rax     # 0x3c53b8
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %r8
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %r9
leaq 0xa1c44(%rip), %rsi     # 0x394fbc
leaq 0xa1c29(%rip), %rdx     # 0x394fa8
movb $0x0, %al
callq 0x22a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2f3b72
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x9c8ce(%rip), %rsi     # 0x3903d6
callq 0x22c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x2f3b23
movl $0x0, -0x4(%rbp)
jmp 0x2f3c10
movq -0x30(%rbp), %rdi
callq 0x2ce660
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdx
movl $0x2, %ecx
leaq 0xd9(%rip), %rsi        # 0x2f3c20
movl %ecx, %edi
callq 0x16d950
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2cee50
movq -0x30(%rbp), %rdi
callq 0x2380
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2f3ae1
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq 0xd0441(%rip), %rax     # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1b7ca0
movq -0x38(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
leaq 0x99515(%rip), %rsi     # 0x38d0d0
leaq 0xa1442(%rip), %rdx     # 0x395004
movb $0x1, %al
callq 0x22a0
movq 0xd0410(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0xd17de(%rip), %rax     # 0x3c53b8
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %r8
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %r9
leaq 0xa141f(%rip), %rsi     # 0x39501a
leaq 0xa1402(%rip), %rdx     # 0x395004
movb $0x0, %al
callq 0x22a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9850
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x2f42ff
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r9d
xorl %r8d, %r8d
movq %r9, %rsi
movq $-0x1, (%rsp)
callq 0xfef0
movq 0xcfd37(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0xa0d9a(%rip), %rsi     # 0x395062
movb $0x0, %al
callq 0x22a0
movq 0xcfd0a(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x30(%rbp), %rcx
leaq 0xa2a60(%rip), %rsi     # 0x396d4a
movb $0x0, %al
callq 0x22a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f426c
leaq -0x30(%rbp), %rdi
callq 0x9670
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x2f4f15
movl $0x1, -0x4(%rbp)
jmp 0x2f5015
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f4f94
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x14(%rcx), %eax
jne 0x2f4f4e
jmp 0x2f4f89
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
subl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x2f4f87
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x2f4f85
movl $0x1, -0x4(%rbp)
jmp 0x2f5015
jmp 0x2f4f87
jmp 0x2f4f89
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2f4f1e
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x2f500e
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x14(%rcx), %eax
jne 0x2f4fcb
jmp 0x2f5003
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
subl 0x10(%rcx), %eax
cmpl -0x1c(%rbp), %eax
jg 0x2f5001
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x2f4fff
movl $0x1, -0x4(%rbp)
jmp 0x2f5015
jmp 0x2f5001
jmp 0x2f5003
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2f4f9d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x118(%rbp), %rdi
xorl %esi, %esi
movl $0xe8, %edx
callq 0x2100
movq -0x28(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
movq $0xbebc200, -0xc8(%rbp) # imm = 0xBEBC200
leaq 0xcd85b(%rip), %rax     # 0x3c47f8
movslq 0x7c(%rax), %rax
movq %rax, -0xc0(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x118(%rbp), %rdi
addq $0x70, %rdi
leaq -0x118(%rbp), %rsi
addq $0x98, %rsi
leaq 0xcd80f(%rip), %rax     # 0x3c47f8
movq 0x10(%rax), %rdx
callq 0x2f4880
cmpl $0x0, %eax
jne 0x2f7030
movq -0x20(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x2ce540
leaq -0x118(%rbp), %rdi
addq $0x70, %rdi
leaq -0x118(%rbp), %rsi
addq $0x98, %rsi
leaq 0xcd7d1(%rip), %rax     # 0x3c47f8
movq 0x10(%rax), %rdx
callq 0x2f45e0
leaq -0x128(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2100
movq 0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
leaq -0x128(%rbp), %rdx
callq 0x2f4cf0
movq 0xccf7f(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x88(%rbp), %rcx
movq -0x90(%rbp), %r8
movq -0xa8(%rbp), %rax
movl %eax, %r9d
leaq 0x9e231(%rip), %rsi     # 0x3952b4
leaq 0x9e261(%rip), %rdx     # 0x3952eb
movb $0x0, %al
callq 0x22a0
leaq -0x118(%rbp), %rsi
addq $0x70, %rsi
movq 0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x128(%rbp), %rdi
movsd 0x8b205(%rip), %xmm0    # 0x3822b8
movsd 0x87f5d(%rip), %xmm1    # 0x37f018
movl $0x1f4, %r8d            # imm = 0x1F4
movl $0x3e8, %r9d            # imm = 0x3E8
callq 0x2f57f0
leaq -0x118(%rbp), %rdi
addq $0x70, %rdi
callq 0x283060
movq -0x70(%rbp), %rdi
callq 0x2210
movq -0x50(%rbp), %rdi
callq 0x2210
movl $0x1, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0xccebf(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x9e1c9(%rip), %rsi     # 0x3952f4
leaq 0x9e1d4(%rip), %rdx     # 0x395306
movb $0x0, %al
callq 0x22a0
movl -0x1c(%rbp), %r8d
leaq 0xcd6b4(%rip), %rax     # 0x3c47f8
movsd 0x230(%rax), %xmm2
leaq 0xcd6a5(%rip), %rax     # 0x3c47f8
movsd 0x238(%rax), %xmm3
leaq 0xcd696(%rip), %rax     # 0x3c47f8
movl 0x240(%rax), %eax
leaq -0xa8(%rbp), %rdi
xorl %r9d, %r9d
movl $0x13, %edx
movl $0xa, %ecx
xorps %xmm0, %xmm0
movsd 0x8b0b9(%rip), %xmm1    # 0x382240
movl %r9d, %esi
movl %eax, (%rsp)
callq 0x282cf0
leaq 0xcd65f(%rip), %rax     # 0x3c47f8
cmpl $0x0, 0xf0(%rax)
je 0x2f71cc
leaq 0xcd64f(%rip), %rax     # 0x3c47f8
movq 0x10(%rax), %rdx
leaq 0xce31c(%rip), %rdi     # 0x3c54d0
leaq 0xce31d(%rip), %rsi     # 0x3c54d8
xorl %eax, %eax
movl %eax, %ecx
callq 0x18b820
movl %eax, -0xb0(%rbp)
jmp 0x2f71d6
xorl %eax, %eax
movl %eax, -0xb0(%rbp)
jmp 0x2f71d6
movl -0xb0(%rbp), %eax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
jne 0x2f71fb
movq -0x8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x282f30
cmpl $0x0, -0xac(%rbp)
jne 0x2f722c
leaq 0xce2c5(%rip), %rax     # 0x3c54d0
movq (%rax), %rdi
leaq 0xce2c3(%rip), %rax     # 0x3c54d8
movq (%rax), %rsi
leaq 0xcd5d9(%rip), %rax     # 0x3c47f8
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x18b600
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xcd5bd(%rip), %rax     # 0x3c47f8
movq 0x68(%rax), %rcx
leaq 0xce28a(%rip), %rax     # 0x3c54d0
movq (%rax), %r8
leaq 0xce288(%rip), %rax     # 0x3c54d8
movq (%rax), %r9
movq -0x8(%rbp), %rax
leaq -0xa8(%rbp), %rdi
movq %rax, (%rsp)
callq 0x2f6f30
callq 0x283020
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2f739c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq $-0x1, %r9
movq %r8, %rdi
movq $0x0, (%rsp)
callq 0x10980
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2f72fc
leaq 0x9df6e(%rip), %rdi     # 0x395311
leaq 0xa2028(%rip), %rsi     # 0x3993d2
callq 0x2200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %r8d
leaq 0x955e1(%rip), %r9      # 0x38c9a8
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
movq %rax, (%rsp)
callq 0xefa60
movq -0x20(%rbp), %rdi
callq 0x21a0
leaq 0x9df3c(%rip), %rdi     # 0x395325
leaq 0xa1fe2(%rip), %rsi     # 0x3993d2
callq 0x2200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %r8d
leaq 0x9559b(%rip), %r9      # 0x38c9a8
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
movq %rax, (%rsp)
callq 0xf1c10
movq -0x20(%rbp), %rdi
callq 0x21a0
movl $0x1, %edi
callq 0x2240
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x2f8e3a
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x2f8f5e
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x2f8e54
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x39(%rbp)
jle 0x2f8ebe
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x39(%rbp)
jge 0x2f8ebe
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rdx
subq $0x1, %rdx
movsbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
jne 0x2f8ebe
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x9192f(%rip), %rax     # 0x38a7e0
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2f8ec7
jmp 0x2f8ec9
jmp 0x2f8ec9
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x2f8f57
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x2f8f33
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2f8f33
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x918b6(%rip), %rax     # 0x38a7e0
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jl 0x2f8f47
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x2f8f49
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2f8ee5
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x32, %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x985e5(%rip), %rsi     # 0x39546d
movb $0x0, %al
callq 0x2050
movq -0x28(%rbp), %rdi
leaq 0x9c538(%rip), %rsi     # 0x3993d2
callq 0x2200
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2210
cmpq $0x0, -0x30(%rbp)
jne 0x2fcebf
movl $0x0, -0x4(%rbp)
jmp 0x2fcf96
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2fcedb
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1018e0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2400
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
jae 0x2fcf67
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2400
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rcx
movl $0x20, %esi
callq 0x2400
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2fcefe
movq 0xc7072(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x8deca(%rip), %rsi     # 0x38ae42
leaq 0x98509(%rip), %rdx     # 0x395488
movb $0x0, %al
callq 0x22a0
movq -0x30(%rbp), %rdi
callq 0x21a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x9690
leaq 0xc7635(%rip), %rax     # 0x3c47f8
movl 0xd0(%rax), %esi
leaq 0xc7628(%rip), %rdi     # 0x3c47f8
callq 0x3b60
movq -0x18(%rbp), %rsi
leaq 0xc7618(%rip), %rax     # 0x3c47f8
movl 0xe8(%rax), %r9d
leaq 0xc760a(%rip), %rax     # 0x3c47f8
movl 0x7c(%rax), %r11d
movq -0x8(%rbp), %r10
movq -0x10(%rbp), %rax
leaq -0x118(%rbp), %rdi
xorl %edx, %edx
movl $0x1f, %r8d
movsd 0x81e1f(%rip), %xmm1    # 0x37f030
movsd 0x8ec8f(%rip), %xmm2    # 0x38bea8
movl %r8d, %ecx
movaps %xmm1, %xmm0
movq $0x4, (%rsp)
movq $0x100, 0x8(%rsp)       # imm = 0x100
movl %r11d, 0x10(%rsp)
movl $0x200, 0x18(%rsp)      # imm = 0x200
movl $0x3, 0x20(%rsp)
movl $0x1, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x3079e0
leaq -0x118(%rbp), %rdi
callq 0x308ee0
movq -0x20(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xe8, %edx
callq 0x2100
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq 0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jae 0x2fe046
movq -0x28(%rbp), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
imulq $0x28, -0x30(%rbp), %rcx
addq %rcx, %rax
movabsq $-0x7fffffff00000001, %rcx # imm = 0x80000000FFFFFFFF
andq 0x18(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2fdff3
leaq 0xc736b(%rip), %rax     # 0x3c53b8
movq 0x40(%rax), %rax
leaq 0xc7360(%rip), %rcx     # 0x3c53b8
movq 0x28(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq 0xc7343(%rip), %rax     # 0x3c53b8
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
leaq 0xc7330(%rip), %rcx     # 0x3c53b8
movq 0x28(%rcx), %rcx
movq -0x10(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, %eax
movq %rax, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x2fe111
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rsi
leaq 0xc72fe(%rip), %rax     # 0x3c53b8
movq 0x48(%rax), %rdx
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
imulq $0x58, %rax, %rax
addq %rax, %rdx
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
movq -0x10(%rbp), %r8
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq (%rax,%rdi,8), %r9
shrq $0x20, %r9
leaq 0xc72ba(%rip), %rdi     # 0x3c53b8
callq 0x2f24b0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2fe0a1
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edi
movq -0x8(%rbp), %rdx
leaq 0xc6faf(%rip), %rax     # 0x3c52d0
movq 0x50(%rax), %rcx
leaq 0xb4(%rip), %rsi        # 0x2fe3e0
callq 0x16d710
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jae 0x2fe39f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x2fe385
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2ef9c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2fe34b
cmpl $0x0, -0x18(%rbp)
je 0x2fe3ae
movq -0x10(%rbp), %rdi
callq 0xcdd10
movq 0xc5c2b(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movl -0x18(%rbp), %ecx
leaq 0x97130(%rip), %rsi     # 0x3954f2
leaq 0x97148(%rip), %rdx     # 0x395511
movb $0x0, %al
callq 0x22a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x2fe42b
jmp 0x2fe516
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq 0x30(%rcx), %rcx
cmpq (%rcx), %rax
jae 0x2fe479
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x2fe479
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x2fe47e
jmp 0x2fe516
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jae 0x2fe4ea
movq -0x28(%rbp), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
imulq $0x28, -0x30(%rbp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
shrq $0x20, %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
cmpl $0x0, %eax
je 0x2fe4da
jmp 0x2fe4ea
jmp 0x2fe4dc
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2fe496
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jb 0x2fe516
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movb $0x1, (%rax,%rcx)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x9690
leaq 0xc51c9(%rip), %rax     # 0x3c47f8
movl 0xd0(%rax), %esi
leaq 0xc51bc(%rip), %rdi     # 0x3c47f8
callq 0x3b60
leaq 0xc51b0(%rip), %rax     # 0x3c47f8
movl 0xe8(%rax), %eax
movl %eax, -0x184(%rbp)
leaq 0xc519d(%rip), %rax     # 0x3c47f8
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
movl -0x184(%rbp), %r8d
leaq 0xc517d(%rip), %rax     # 0x3c47f8
movl 0xe8(%rax), %r9d
leaq 0xc516f(%rip), %rax     # 0x3c47f8
movsd 0x228(%rax), %xmm0
leaq 0xc5160(%rip), %rax     # 0x3c47f8
movsd 0x228(%rax), %xmm1
leaq 0xc5151(%rip), %rax     # 0x3c47f8
movsd 0x230(%rax), %xmm2
leaq 0xc5142(%rip), %rax     # 0x3c47f8
movsd 0x238(%rax), %xmm3
leaq 0xc5133(%rip), %rax     # 0x3c47f8
movl 0x240(%rax), %eax
leaq -0x98(%rbp), %rdi
movl $0x13, %edx
movl $0xa, %ecx
movl %eax, (%rsp)
callq 0x282cf0
leaq 0xc510d(%rip), %rax     # 0x3c47f8
movslq 0x7c(%rax), %r9
movq -0x8(%rbp), %rax
leaq -0x180(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
leaq -0x98(%rbp), %rcx
movl $0x3b9aca00, %r8d       # imm = 0x3B9ACA00
movq %rdx, %rsi
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x2fd4f0
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x2efb70
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
// File: chhylp123[P]hifiasm/inter.cpp
// Function: gen_contig_path(ug_opt_t const*, asg_t*, ma_ug_t*, ma_ug_t*)
scaf_res_t *gen_contig_path(const ug_opt_t *uopt, asg_t *sg, ma_ug_t *ctg, ma_ug_t *ref)
{
	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);
	ul_idx_t *uu = gen_ul_idx_t(uopt, ref, sg, 0, 0, 1);
	init_uldat_t(&sl, NULL, NULL, &opt, CHUNK_SIZE, asm_opt.thread_num, uopt, uu); sl.rg = sg; sl.ug = ctg;

	scaf_res_t *res = work_ctg_path_gchains(&sl); uu->ug = NULL;
	destroy_ul_idx_t(uu);
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x9690
leaq 0xc4e41(%rip), %rax     # 0x3c47f8
movl 0xd0(%rax), %esi
leaq 0xc4e34(%rip), %rdi     # 0x3c47f8
callq 0x3b60
leaq 0xc4e28(%rip), %rax     # 0x3c47f8
movl 0xe8(%rax), %eax
movl %eax, -0x194(%rbp)
leaq 0xc4e15(%rip), %rax     # 0x3c47f8
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
movl -0x194(%rbp), %r8d
leaq 0xc4df5(%rip), %rax     # 0x3c47f8
movl 0xe8(%rax), %r9d
leaq 0xc4de7(%rip), %rax     # 0x3c47f8
movsd 0x228(%rax), %xmm0
leaq 0xc4dd8(%rip), %rax     # 0x3c47f8
movsd 0x228(%rax), %xmm1
leaq 0xc4dc9(%rip), %rax     # 0x3c47f8
movsd 0x230(%rax), %xmm2
leaq 0xc4dba(%rip), %rax     # 0x3c47f8
movsd 0x238(%rax), %xmm3
leaq 0xc4dab(%rip), %rax     # 0x3c47f8
movl 0x240(%rax), %eax
leaq -0xa8(%rbp), %rdi
movl $0x13, %edx
movl $0xa, %ecx
movl %eax, (%rsp)
callq 0x282cf0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
movl $0x1, %r9d
movq %r8, %rcx
callq 0x2fc690
movq %rax, -0x1a0(%rbp)
leaq 0xc4d5f(%rip), %rax     # 0x3c47f8
movslq 0x7c(%rax), %r9
movq -0x8(%rbp), %r10
movq -0x1a0(%rbp), %rax
leaq -0x190(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
leaq -0xa8(%rbp), %rcx
movl $0x3b9aca00, %r8d       # imm = 0x3B9ACA00
movq %rdx, %rsi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2fd4f0
movq -0x10(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x2ec2a0
movq %rax, -0x1a8(%rbp)
movq -0x1a0(%rbp), %rax
movq $0x0, (%rax)
movq -0x1a0(%rbp), %rdi
callq 0x2fc8d0
movq -0x1a8(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/inter.cpp
// Function: dd_ug(asg_t*, ma_ug_t*, ma_sub_t*, ma_hit_t_alloc*, R_to_U*, char const*)
uint32_t dd_ug(asg_t *sg, ma_ug_t *ug, ma_sub_t* coverage_cut, ma_hit_t_alloc* sources, R_to_U* ruIndex, const char* output_file_name)
{
    fprintf(stderr, "Writing raw unitig GFA to disk... \n");
    char* gfa_name = (char*)malloc(strlen(output_file_name)+25);
    sprintf(gfa_name, "%s.r_utg.noseq.gfa", output_file_name);
    FILE* output_file = fopen(gfa_name, "w");
    ma_ug_print_simple(ug, sg, coverage_cut, sources, ruIndex, "utg", output_file);
    fclose(output_file);

    free(gfa_name);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq 0xc3369(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x867ca(%rip), %rsi     # 0x38744b
movb $0x0, %al
callq 0x22a0
movq -0x30(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x19, %rdi
callq 0x2270
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x867cc(%rip), %rsi     # 0x38747c
movb $0x0, %al
callq 0x2050
movq -0x38(%rbp), %rdi
leaq 0x98710(%rip), %rsi     # 0x3993d2
callq 0x2200
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x40(%rbp), %rax
leaq 0x8bcbe(%rip), %r9      # 0x38c9a8
movq %rax, (%rsp)
callq 0xf1c10
movq -0x40(%rbp), %rdi
callq 0x21a0
movq -0x38(%rbp), %rdi
callq 0x2210
movl $0x1, %edi
callq 0x2240
nop