LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_ug_gen(hifiasm_opt_t const*, void const*, ma_utg_v*, int, int, int, int)
ha_pt_t *ha_pt_ug_gen(const hifiasm_opt_t *asm_opt, const void *flt_tab, ma_utg_v *us, int is_HPC, int k, int w, int min_freq)
{
	ha_ct_t *ct;
	ha_pt_t *pt;
	///HAF_COUNT_EXACT: no bf
	ct = ha_count(asm_opt, HAF_COUNT_EXACT|HAF_UG_READ, is_HPC, k, w, NULL, flt_tab, NULL, us, 0, NULL, 1);
	fprintf(stderr, "[M::%s::%.3f*%.2f] ==> counted %ld distinct minimizer k-mers\n", __func__,
			yak_realtime(), yak_cpu_usage(), (long)ct->tot);
	///minimizer with YAK_MAX_COUNT occ may apper > YAK_MAX_COUNT times, so it may lead to overflow at ha_pt_gen
	ha_ct_shrink(ct, min_freq, YAK_MAX_COUNT - 1, asm_opt->thread_num);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movq -0x10(%rbp), %r10
movq -0x18(%rbp), %rax
movl $0x81, %esi
xorl %r9d, %r9d
xorl %r11d, %r11d
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x1, 0x28(%rsp)
callq 0x1886f0
movq %rax, -0x30(%rbp)
movq 0x23a1ff(%rip), %rax    # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x50(%rbp)
callq 0x1b7d20
movq -0x58(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x200dd9(%rip), %rsi    # 0x38abeb
leaq 0x200e4b(%rip), %rdx    # 0x38ac64
movb $0x2, %al
callq 0x22a0
movq -0x30(%rbp), %rdi
movl 0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %ecx
movl $0xffe, %edx            # imm = 0xFFE
callq 0x1891f0
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %esi
movl $0x1, %edx
callq 0x186b00
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movq -0x38(%rbp), %r9
movq -0x10(%rbp), %r10
movq -0x18(%rbp), %rax
movl $0x81, %esi
xorl %r11d, %r11d
xorl %r11d, %r11d
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x1, 0x28(%rsp)
callq 0x1886f0
movq 0x23a133(%rip), %rax    # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x40(%rbp)
callq 0x1b7d20
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x200d58(%rip), %rsi    # 0x38ac36
leaq 0x200d7f(%rip), %rdx    # 0x38ac64
movb $0x2, %al
callq 0x22a0
movq -0x38(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_shrink(ha_pt_s*, int)
static uint64_t ha_pt_shrink(ha_pt_t *h, int n_thread)
{
    int i;
	uint64_t occ;
    ///still start 4096 threads
    kt_for(n_thread, worker_pt_shrink, h, 1<<h->pre);
    for (i = 0, occ = 0, h->tot = 0; i < 1<<h->pre; ++i)
	{
		h->tot += kh_size(h->h[i].h);
		occ += h->h[i].n;
	}
	return occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
leaq 0x72c2(%rip), %rsi      # 0x1913b0
callq 0x16d710
movl $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x18a176
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x18a10e
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_init(int, int, int, int)
static ha_ct_t *ha_ct_init(int k, int pre, int n_hash, int n_shift)
{
	ha_ct_t *h;
	int i;
	if (pre < YAK_COUNTER_BITS) return 0;
	CALLOC(h, 1);
	h->k = k, h->pre = pre;
	CALLOC(h->h, 1<<h->pre);
	///i<h->pre = 4096
	///it seems there is a large hash table h, consisting 4096 small hash tables
	for (i = 0; i < 1<<h->pre; ++i)
		h->h[i].h = yak_ct_init();
	///for 0-th counting, enter here; used for bloom filter
	if (n_hash > 0 && n_shift > h->pre) {
		h->n_hash = n_hash, h->n_shift = n_shift;
		for (i = 0; i < 1<<h->pre; ++i)
			h->h[i].b = yak_bf_init(h->n_shift - h->pre, h->n_hash); ///h->n_shift = 37, h->pre = 12, h->n_hash = 4 
	}
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0xc, -0x10(%rbp)
jge 0x18cb77
movq $0x0, -0x8(%rbp)
jmp 0x18cc97
movl $0x1, %edi
movl $0x28, %esi
callq 0x2140
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdi
movl $0x10, %esi
callq 0x2140
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x18cc0a
callq 0x18ecf0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18cbca
cmpl $0x0, -0x14(%rbp)
jle 0x18cc8f
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x18cc8f
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x18cc8d
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x20(%rbp), %rax
subl 0x4(%rax), %edi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x186470
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18cc37
jmp 0x18cc8f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/htab.cpp
// Function: worker_ct_shrink(void*, long, int)
static void worker_ct_shrink(void *data, long i, int tid) // callback for kt_for()
{
	shrink_aux_t *a = (shrink_aux_t*)data;
	ha_ct_t *h = a->h;
	yak_ct_t *g = h->h[i].h, *f;
	khint_t k;
	f = yak_ct_init();
	yak_ct_resize(f, kh_size(g));
	for (k = 0; k < kh_end(g); ++k) {
		if (kh_exist(g, k)) {
			int absent, c = kh_key(g, k) & YAK_MAX_COUNT;
			if (c >= a->min && c <= a->max)
				yak_ct_put(f, kh_key(g, k), &absent);
		}
	}
	yak_ct_destroy(g);
	h->h[i].h = f;
}

// 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 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x18ecf0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x190b90
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x190ac4
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x4c(%rbp)
jmp 0x190acb
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0x190acb
movl -0x48(%rbp), %eax
movl -0x4c(%rbp), %ecx
cmpl %ecx, %eax
jae 0x190b59
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x3c(%rbp), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x3c(%rbp), %ecx
andl $0x1f, %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x190b49
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x3c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
andq $0xfff, %rax            # imm = 0xFFF
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x190b47
movl -0x44(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x190b47
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x3c(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0x40(%rbp), %rdx
callq 0x18f940
jmp 0x190b49
jmp 0x190b4b
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x190aa1
movq -0x30(%rbp), %rdi
callq 0x18c0c0
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/htab.cpp
// Function: worker_ct_hist(void*, long, int)
static void worker_ct_hist(void *data, long i, int tid) // callback for kt_for()
{
	hist_aux_t *a = (hist_aux_t*)data;
	uint64_t *cnt = a->cnt[tid].c;
	yak_ct_t *g = a->h->h[i].h;
	khint_t k;
	for (k = 0; k < kh_end(g); ++k)
		if (kh_exist(g, k))
			++cnt[kh_key(g, k)&YAK_MAX_COUNT];
}

// 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 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0xf, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x191335
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x3c(%rbp)
jmp 0x19133c
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x19133c
movl -0x38(%rbp), %eax
movl -0x3c(%rbp), %ecx
cmpl %ecx, %eax
jae 0x19139f
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x34(%rbp), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x34(%rbp), %ecx
andl $0x1f, %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x19138f
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x34(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
andq $0xfff, %rcx            # imm = 0xFFF
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x191391
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x191312
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/./htab.h
// Function: mz_low_b(int, int)
inline int mz_low_b(int peak_hom, int peak_het)
{
	int low_freq = 2;
	if(peak_het > 0) low_freq = peak_het/2;
	else if(peak_hom > 0) low_freq = peak_hom/4;
	if(low_freq < 2) low_freq = 2;
	return low_freq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x192037
movl -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0x19204d
cmpl $0x0, -0x4(%rbp)
jle 0x19204b
movl -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0x19204d
cmpl $0x2, -0xc(%rbp)
jge 0x19205a
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/htab.cpp
// Function: flt_quals(char*, unsigned long, unsigned long, long)
inline uint64_t flt_quals(char *sc_a, uint64_t sc_l, uint64_t sc_off, int64_t sc_cut)
{
	int64_t sc_min = sc_l * sc_cut, sc_tot; uint64_t k;
	for (k = sc_tot = 0; (k < sc_l) && (sc_tot < sc_min); k++) {
		sc_tot += (((uint8_t)sc_a[k]) - sc_off);
	}

	// if(sc_tot < sc_min) {
	// 	fprintf(stderr, "[M::%s] sc_tot::%ld, sc_min::%ld, sc_l::%lu\n", __func__, sc_tot, sc_min, sc_l);
	// }

	if(sc_tot < sc_min) return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
imulq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x1920ae
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1920b7
jmp 0x1920dd
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
subq -0x20(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x192091
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x1920f1
movq $0x0, -0x8(%rbp)
jmp 0x1920f9
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/hist.cpp
// Function: adj_m_peak_hom(int, int, int, int, int*)
int adj_m_peak_hom(int m_peak_hom, int max_i, int max2_i, int max3_i, int *peak_het)
{
	int64_t mm[3], d, min_i, min_d, i;
	mm[0] = max2_i; mm[1] = max_i; mm[2] = max3_i;
	for (i = 0, min_i = -1, min_d = -1; i < 3; i++){
		if(mm[i] <= 0) continue;
		d = (mm[i] >= m_peak_hom?mm[i]-m_peak_hom:m_peak_hom-mm[i]);
		if(min_d == -1 || min_d > d || (min_d == d && i == 1)){
			min_d = d; min_i = i;
		}
	}
	if(min_i < 0) return m_peak_hom;
	if(mm[min_i] < m_peak_hom){
		d = m_peak_hom - mm[min_i];
		if(d >= mm[min_i]*0.51) {
			*peak_het = mm[min_i];
			return m_peak_hom;
		}
	}

	for (i = min_i-1; i >= 0; i--){
		if(mm[i] <= 0) continue;
		*peak_het = mm[i];
		break;
	}
	return mm[min_i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x60(%rbp)
movq $-0x1, -0x50(%rbp)
movq $-0x1, -0x58(%rbp)
cmpq $0x3, -0x60(%rbp)
jge 0x1924f3
movq -0x60(%rbp), %rax
cmpq $0x0, -0x40(%rbp,%rax,8)
jg 0x19246d
jmp 0x1924e2
movq -0x60(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
movslq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jl 0x192495
movq -0x60(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
movslq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x68(%rbp)
jmp 0x1924a6
movslq -0x8(%rbp), %rax
movq -0x60(%rbp), %rcx
subq -0x40(%rbp,%rcx,8), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $-0x1, -0x58(%rbp)
je 0x1924d0
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
jg 0x1924d0
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x1924e0
cmpq $0x1, -0x60(%rbp)
jne 0x1924e0
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x1924e2
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x192454
cmpq $0x0, -0x50(%rbp)
jge 0x192505
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1925b4
movq -0x50(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
movslq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jge 0x192566
movslq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
subq -0x40(%rbp,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cvtsi2sdq -0x48(%rbp), %xmm0
movq -0x50(%rbp), %rax
cvtsi2sdq -0x40(%rbp,%rax,8), %xmm1
movsd 0x1efd77(%rip), %xmm2   # 0x3822b8
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x192564
movq -0x50(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1925b4
jmp 0x192566
movq -0x50(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jl 0x1925a8
movq -0x60(%rbp), %rax
cmpq $0x0, -0x40(%rbp,%rax,8)
jg 0x192587
jmp 0x19259a
movq -0x60(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1925a8
movq -0x60(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x192572
movq -0x50(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/./htab.h
// Function: tq_shift(tiny_queue_t*)
static inline int tq_shift(tiny_queue_t *q)
{
	int x;
	if (q->count == 0) return -1;
	x = q->a[q->front++];
	q->front &= 0x3f;
	--q->count;
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x193d8b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x193dc4
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movslq %ecx, %rcx
movl 0x8(%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/anchor.cpp
// Function: lable_matched_ovlp(overlap_region_alloc*, ma_hit_t_alloc*)
void lable_matched_ovlp(overlap_region_alloc* overlap_list, ma_hit_t_alloc* paf)
{
	uint64_t j = 0, inner_j = 0;
	while (j < overlap_list->length && inner_j < paf->length)
    {
        if(overlap_list->list[j].y_id < paf->buffer[inner_j].tn)
        {
            j++;
        }
        else if(overlap_list->list[j].y_id > paf->buffer[inner_j].tn)
        {
            inner_j++;
        }
        else
        {
            if(overlap_list->list[j].y_pos_strand == paf->buffer[inner_j].rev)
            {
				overlap_list->list[j].is_match = 1;
            }
            j++;
            inner_j++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x21(%rbp)
jae 0x1a3363
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1a336f
jmp 0x1a3449
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
imulq $0x28, -0x20(%rbp), %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
jae 0x1a33a9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1a3444
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
imulq $0x28, -0x20(%rbp), %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
jbe 0x1a33e0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1a3442
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
imulq $0x28, -0x20(%rbp), %rdx
addq %rdx, %rcx
movq 0x18(%rcx), %rcx
shrq $0x1f, %rcx
andq $0x1, %rcx
cmpl %ecx, %eax
jne 0x1a342a
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x18(%rbp), %rcx
addq %rcx, %rax
movb $0x1, 0x2c(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1a3444
jmp 0x1a333c
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/anchor.cpp
// Function: lchain_qgen_mcopy_fast_re1(Candidates_list*, unsigned int, overlap_region_alloc*, unsigned int, unsigned long, unsigned long, unsigned int, long, long, long, double, double, double, long, unsigned int, long, double, unsigned int)
void lchain_qgen_mcopy_fast_re1(Candidates_list* cl, uint32_t cl_beg, overlap_region_alloc* ol, uint32_t rid, uint64_t rl, uint64_t tl, 
				uint32_t apend_be, int64_t max_skip, int64_t max_iter, 
				int64_t max_dis, double chn_pen_gap, double chn_pen_skip, double bw_rate, int64_t quick_check, 
				uint32_t gen_off, int64_t enable_mcopy, double mcopy_rate, uint32_t mcopy_khit_cut)
{
	uint64_t cn = cl->length, m = cl_beg;
	if(cl_beg >= cn) return;

	m += lchain_qdp_mcopy_fast(cl, cl_beg, cn - cl_beg, m, &(cl->chainDP), ol, max_skip, max_iter, max_dis, chn_pen_gap, chn_pen_skip, bw_rate, 
                rid, rl, tl, quick_check, apend_be, gen_off, enable_mcopy, mcopy_rate, mcopy_khit_cut, 1);
	cl->length = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl 0x48(%rbp), %eax
movq 0x40(%rbp), %rax
movl 0x38(%rbp), %eax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movq %rdx, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -0x58(%rbp)
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x68(%rbp)
movsd %xmm2, -0x70(%rbp)
movsd %xmm3, -0x78(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
movl -0x34(%rbp), %eax
movq %rax, -0x88(%rbp)
movl -0x34(%rbp), %eax
cmpq -0x80(%rbp), %rax
jb 0x1ac1af
jmp 0x1ac2ad
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
movq -0x80(%rbp), %rdx
movl -0x34(%rbp), %eax
subq %rax, %rdx
movq -0x88(%rbp), %rcx
movq -0x30(%rbp), %r8
addq $0x18, %r8
movq -0x40(%rbp), %r9
movq 0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
movsd -0x60(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movsd -0x70(%rbp), %xmm2
movl -0x44(%rbp), %r13d
movq -0x50(%rbp), %r12
movq -0x58(%rbp), %r15
movq 0x30(%rbp), %r14
movl 0x10(%rbp), %ebx
movl 0x38(%rbp), %eax
movl %eax, %r11d
movq 0x40(%rbp), %r10
movsd -0x78(%rbp), %xmm3
movl 0x48(%rbp), %eax
movq %rax, -0x90(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, (%rsp)
movq -0xa0(%rbp), %rax
movq %rax, 0x8(%rsp)
movq -0x98(%rbp), %rax
movq %rax, 0x10(%rsp)
movq -0x90(%rbp), %rax
movl %r13d, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movl %ebx, 0x38(%rsp)
movq %r11, 0x40(%rsp)
movq %r10, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq $0x1, 0x58(%rsp)
callq 0x275f0
addq -0x88(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/anchor.cpp
// Function: set_lchain_dp_op(unsigned int, unsigned int, long*, long*, long*, double*, double*, long*)
void set_lchain_dp_op(uint32_t is_accurate, uint32_t mz_k, int64_t *max_skip, int64_t *max_iter, int64_t *max_dis, double *chn_pen_gap, double *chn_pen_skip, int64_t *quick_check)
{
	double div, pen_gap, pen_skip, tmp;
	if(is_accurate) {
		(*quick_check) = 1; (*max_skip) = 25; (*max_iter) = 5000; (*max_dis) = 5000; div = 0.01; pen_gap = 0.5f; pen_skip = 0.0005f; 
	} else {
		(*quick_check) = 0; (*max_skip) = 25; (*max_iter) = 5000; (*max_dis) = 5000; div = 0.1; pen_gap = 0.5f; pen_skip = 0.0005f;
	}
	tmp = expf(-div * (double)mz_k);///0.60049557881 -> HiFi; 0.18268352405 -> ont
	*chn_pen_gap = pen_gap * tmp;///0.300247789405 -> HiFi; 0.091341762025 -> ont
	///0.000300247789405 -> HiFi (>3330 will be negative);
	//0.000091341762025 -> ont (>10947 will be negative);
	*chn_pen_skip = pen_skip * tmp; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x1acb01
movq 0x18(%rbp), %rax
movq $0x1, (%rax)
movq -0x10(%rbp), %rax
movq $0x19, (%rax)
movq -0x18(%rbp), %rax
movq $0x1388, (%rax)         # imm = 0x1388
movq -0x20(%rbp), %rax
movq $0x1388, (%rax)         # imm = 0x1388
movsd 0x1ded50(%rip), %xmm0   # 0x38b830
movsd %xmm0, -0x30(%rbp)
movsd 0x1d5783(%rip), %xmm0   # 0x382270
movsd %xmm0, -0x38(%rbp)
movsd 0x1ded2e(%rip), %xmm0   # 0x38b828
movsd %xmm0, -0x40(%rbp)
jmp 0x1acb54
movq 0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x19, (%rax)
movq -0x18(%rbp), %rax
movq $0x1388, (%rax)         # imm = 0x1388
movq -0x20(%rbp), %rax
movq $0x1388, (%rax)         # imm = 0x1388
movsd 0x1d24e3(%rip), %xmm0   # 0x37f018
movsd %xmm0, -0x30(%rbp)
movsd 0x1d572e(%rip), %xmm0   # 0x382270
movsd %xmm0, -0x38(%rbp)
movsd 0x1decd9(%rip), %xmm0   # 0x38b828
movsd %xmm0, -0x40(%rbp)
movaps 0x1dece5(%rip), %xmm1   # 0x38b840
movsd -0x30(%rbp), %xmm0
pxor %xmm1, %xmm0
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x2370
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x48(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm0
mulsd -0x48(%rbp), %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/anchor.cpp
// Function: h_ec_lchain_re_gen_qry(ha_abuf_s*, unsigned long*, unsigned long*, unsigned long*, unsigned long*, unsigned long, unsigned long*, unsigned long*)
uint64_t h_ec_lchain_re_gen_qry(ha_abuf_t *ab, uint64_t *k, uint64_t *l, uint64_t *i, uint64_t *idx_a, uint64_t idx_n, uint64_t *tid, uint64_t *trev)
{
	while ((*k) <= ab->n_a) {
        if ((*k) == ab->n_a || (ab->a[*k].srt>>32) != (ab->a[*l].srt>>32)) {
			for (; ((*i) < idx_n) && ((idx_a[*i]>>32) < (ab->a[*l].srt>>32)); (*i)++);
			if(((*i) < idx_n) && ((ab->a[*l].srt>>32) == (idx_a[*i]>>32))) {
				(*tid) = ab->a[*l].srt>>33; (*trev) = (ab->a[*l].srt>>32) & 1; 
				
				return 1;
			}
            (*l) = (*k);
        }
		++(*k);
    }
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
ja 0x1b31de
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x1b30c5
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq (%rax), %rax
shrq $0x20, %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x20(%rbp), %rdx
imulq $0x18, (%rdx), %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
shrq $0x20, %rcx
cmpq %rcx, %rax
je 0x1b31cb
jmp 0x1b30c7
movq -0x28(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq -0x38(%rbp), %rcx
movb %al, -0x39(%rbp)
jae 0x1b310f
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x20(%rbp), %rdx
imulq $0x18, (%rdx), %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
shrq $0x20, %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1b3118
jmp 0x1b312a
jmp 0x1b311a
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1b30c7
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x38(%rbp), %rax
jae 0x1b31bd
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq (%rax), %rax
shrq $0x20, %rax
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq (%rdx), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
cmpq %rcx, %rax
jne 0x1b31bd
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq (%rax), %rcx
shrq $0x21, %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq (%rax), %rcx
shrq $0x20, %rcx
andq $0x1, %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0x1b31e6
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1b3064
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/extract.cpp
// Function: gfa_strdup(char const*)
char *gfa_strdup(const char *src)
{
	int32_t len;
	char *dst;
	len = strlen(src);
	GFA_MALLOC(dst, len + 1);
	memcpy(dst, src, len + 1);
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20a0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x2180
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/extract.cpp
// Function: gfa_strndup(char const*, unsigned long)
char *gfa_strndup(const char *src, size_t n)
{
	char *dst;
	GFA_MALLOC(dst, n + 1);
	strncpy(dst, src, n);
	dst[n] = 0;
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x20f0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/extract.cpp
// Function: ha_extract_print_list(All_reads const*, int, char const*)
void ha_extract_print_list(const All_reads *rs, int n_rounds, const char *o)
{
	int i, n;
	char **list;
	list = gv_read_list(o, &n);
	ha_extract_print(rs, n_rounds, n, list);
	for (i = 0; i < n; ++i) free(list[i]);
	free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1b5730
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x1b5a70
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1b6572
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2210
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b654e
movq -0x28(%rbp), %rdi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: test_unitig_index(ha_ug_index*, ma_ug_t*)
void test_unitig_index(ha_ug_index* idx, ma_ug_t *ug)
{
    double index_time = yak_realtime();
    uint32_t i, j;
    ma_utg_t *u = NULL;
    hc_pt1_t *h = NULL;
    idx->ug = ug;
    for (i = 0; i < idx->ug->u.n; i++)
    {
        u = &(idx->ug->u.a[i]);
        if(u->m == 0) continue;
        test_hc_pt1(u->s, u->len, i, idx);
    }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jae 0x1bfa10
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1bf9e0
jmp 0x1bfa05
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %esi
movl -0x1c(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rcx
callq 0x1bf6b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bf9ac
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x1bfa92
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1bfa85
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x20(%rbp), %ecx
cmpq $-0x1, (%rax,%rcx,8)
je 0x1bfa78
movq 0x204579(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x1cc46d(%rip), %rsi    # 0x38bede
movb $0x0, %al
callq 0x22a0
jmp 0x1bfa7a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1bfa41
jmp 0x1bfa87
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bfa17
movq 0x204547(%rip), %rax    # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1b7ca0
movq -0x38(%rbp), %rdi
subsd -0x18(%rbp), %xmm0
leaq 0x1cc432(%rip), %rsi    # 0x38bee7
leaq 0x1cc453(%rip), %rdx    # 0x38bf0f
movb $0x1, %al
callq 0x22a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: destory_hc_pt_index(ha_ug_index*)
void destory_hc_pt_index(ha_ug_index* idx)
{
    if(idx->idx_buf)
    {
        uint64_t i = 0;
        for (i = 0; i < idx->tot; i++)
        {
            if(idx->idx_buf[i].a) free(idx->idx_buf[i].a);
            if(idx->idx_buf[i].h) hc_pt_destroy(idx->idx_buf[i].h);
        }
        free(idx->idx_buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x1c0553
movq $0x0, -0x10(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x1c0546
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x1c04ff
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x1c0533
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1c1c90
jmp 0x1c0535
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1c04bb
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: hc_pt_t_gen(ha_ug_index*, pldat_t*)
void hc_pt_t_gen(ha_ug_index* idx, pldat_t* pl)
{
    if(pl == NULL)
    {
        uint64_t i;
        for (i = 0; i < idx->tot; i++)
        {
            hc_pt_t_gen_single(&(idx->idx_buf[i]), &(idx->up_bound), &(idx->low_bound));
        }
    }
    else
    {
        kt_for(pl->n_thread, worker_for_sort, pl, pl->h->tot);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c05f5
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x1c05f3
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x68, %rsi
movq -0x8(%rbp), %rdx
addq $0x70, %rdx
callq 0x1bfad0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c05af
jmp 0x1c061b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl %eax, %edi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rax), %rcx
leaq 0x1a(%rip), %rsi        # 0x1c0630
callq 0x16d710
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: debug_hash_value(char*, unsigned long, unsigned long)
uint64_t debug_hash_value(char *r, uint64_t end, uint64_t k_mer)
{
    uint64_t i;
    uint64_t x[4], mask = (1ULL<<k_mer) - 1, shift = k_mer - 1, skip;
    for (i = end + 1 - k_mer, x[0] = x[1] = x[2] = x[3] = 0; i <= end; i++)
    {
        int c = seq_nt4_table[(uint8_t)r[i]];
        ///c = 00, 01, 10, 11
        if (c < 4) { // not an "N" base
            ///x[0] & x[1] are the forward k-mer
            ///x[2] & x[3] are the reverse complementary k-mer
            x[0] = (x[0] << 1 | (c&1))  & mask;
            x[1] = (x[1] << 1 | (c>>1)) & mask;
            x[2] = x[2] >> 1 | (uint64_t)(1 - (c&1))  << shift;
            x[3] = x[3] >> 1 | (uint64_t)(1 - (c>>1)) << shift;
        }
    }

    return hc_hash_long(x, &skip, k_mer);
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x1c1ddf
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x1c8aa9(%rip), %rax    # 0x38a7e0
movzbl (%rax,%rcx), %eax
movl %eax, -0x5c(%rbp)
cmpl $0x4, -0x5c(%rbp)
jge 0x1c1dcc
movq -0x40(%rbp), %rax
shlq %rax
movl -0x5c(%rbp), %ecx
andl $0x1, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
andq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
shlq %rax
movl -0x5c(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
orq %rcx, %rax
andq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
shrq %rax
movl -0x5c(%rbp), %edx
andl $0x1, %edx
movl $0x1, %ecx
subl %edx, %ecx
movslq %ecx, %rdx
movq -0x50(%rbp), %rcx
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
shrq %rax
movl -0x5c(%rbp), %edx
sarl %edx
movl $0x1, %ecx
subl %edx, %ecx
movslq %ecx, %rdx
movq -0x50(%rbp), %rcx
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x1c1dce
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1c1d14
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x212f90
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: test_reads(reads_t*, char const*)
void test_reads(reads_t* x, const char *fn)
{
    gzFile fp;
    kseq_t *ks;
    int ret, i = 0;

    if ((fp = gzopen(fn, "r")) == 0) return;
    ks = kseq_init(fp);
    while (((ret = kseq_read(ks)) >= 0))
    {
        if(memcmp(ks->name.s, x->name.a + x->name_Len.a[i], ks->name.l) != 0)
        {
            fprintf(stderr, "ERROR222: i: %d, len: %lu\n", i, x->name_Len.a[i]);
        }
        i++;
    }

    kseq_destroy(ks);
    gzclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1cc164(%rip), %rsi    # 0x3903d6
callq 0x22c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1c4286
jmp 0x1c431d
movq -0x18(%rbp), %rdi
callq 0x1c3db0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c3df0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jl 0x1c430b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x28(%rbp), %rcx
addq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x20b0
cmpl $0x0, %eax
je 0x1c4300
movq 0x1ffd04(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movl -0x28(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x1c7d38(%rip), %rsi    # 0x38c031
movb $0x0, %al
callq 0x22a0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1c4293
movq -0x20(%rbp), %rdi
callq 0x1c41e0
movq -0x18(%rbp), %rdi
callq 0x2380
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: destory_reads(reads_t*)
void destory_reads(reads_t* x)
{
    kv_destroy(x->name);
    kv_destroy(x->name_Len);
    kv_destroy(x->r);
    kv_destroy(x->r_Len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: print_hits_simp(ha_ug_index*, kvec_pe_hit*)
void print_hits_simp(ha_ug_index* idx, kvec_pe_hit* hits)
{
    uint64_t k, shif = 64 - idx->uID_bits;
    char dir[2] = {'+', '-'};
    for (k = 0; k < hits->a.n; ++k) 
    { 
        if(((hits->a.a[k].s<<1)>>shif) == ((hits->a.a[k].e<<1)>>shif)) continue;
        fprintf(stderr, "r-%lu-th\t%c\trs-utg%.6dl\t%lu\t%c\tre-utg%.6dl\t%lu\n", 
        hits->a.a[k].id,
        dir[hits->a.a[k].s>>63], (int)((hits->a.a[k].s<<1)>>shif)+1, hits->a.a[k].s&idx->pos_mode,
        dir[hits->a.a[k].e>>63], (int)((hits->a.a[k].e<<1)>>shif)+1, hits->a.a[k].e&idx->pos_mode);        
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movl $0x40, %eax
subq 0x18(%rcx), %rax
movq %rax, -0x20(%rbp)
movw 0x1c92ec(%rip), %ax     # 0x38d8b4
movw %ax, -0x22(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1c4753
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
shlq %rax
movq -0x20(%rbp), %rcx
shrq %cl, %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
shlq %rdx
movq -0x20(%rbp), %rcx
shrq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jne 0x1c4633
jmp 0x1c4742
movq 0x1ff9a6(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
shrq $0x3f, %rax
movsbl -0x22(%rbp,%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
shlq %rax
movq -0x20(%rbp), %rcx
shrq %cl, %rax
movl %eax, %r8d
addl $0x1, %r8d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %r9
movq -0x8(%rbp), %rax
andq 0x30(%rax), %r9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
shrq $0x3f, %rax
movsbl -0x22(%rbp,%rax), %r11d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
shlq %rax
movq -0x20(%rbp), %rcx
shrq %cl, %rax
movl -0x28(%rbp), %ecx
movl %eax, %r10d
addl $0x1, %r10d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
andq 0x30(%rsi), %rax
leaq 0x1c794f(%rip), %rsi    # 0x38c07c
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c45d4
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: sort_hits(kvec_pe_hit*)
void sort_hits(kvec_pe_hit* hits)
{
    double index_time = yak_realtime();
    uint64_t k, l;
    radix_sort_pe_hit_an1(hits->a.a, hits->a.a + hits->a.n);
    for (k = 1, l = 0; k <= hits->a.n; ++k) 
    {   
        if (k == hits->a.n || (hits->a.a[k].s<<1) != (hits->a.a[l].s<<1)) 
        {
            if (k - l > 1) radix_sort_pe_hit_an2(hits->a.a + l, hits->a.a + k);
            l = k;
        }
    }
    fprintf(stderr, "[M::%s::%.3f] ==> Sort\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x1b8c80
movq $0x1, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
ja 0x1c4a52
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x1c49fe
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
shlq %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
je 0x1c4a3f
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
cmpq $0x1, %rax
jbe 0x1c4a37
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x1b91d0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1c4a41
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c49a9
movq 0x1ff587(%rip), %rax    # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1b7ca0
movq -0x28(%rbp), %rdi
subsd -0x10(%rbp), %xmm0
leaq 0x1c765b(%rip), %rsi    # 0x38c0d0
leaq 0x1c766c(%rip), %rdx    # 0x38c0e8
movb $0x1, %al
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: destory_bubbles(bubble_type*)
void destory_bubbles(bubble_type* bub)
{
    if(bub->index) free(bub->index);
    kv_destroy(bub->list);
    kv_destroy(bub->num);
    kv_destroy(bub->pathLen);
    kv_destroy(bub->b_s_idx);
    kv_destroy(bub->chain_weight);
    asg_destroy(bub->b_g);
    ma_ug_destroy(bub->b_ug);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c4ab2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0xcd170
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rdi
callq 0xcd6f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: get_bubbles(bubble_type*, unsigned long, unsigned int*, unsigned int*, unsigned int**, unsigned int*, unsigned long*)
void get_bubbles(bubble_type* bub, uint64_t id, uint32_t* beg, uint32_t* sink, uint32_t** a, uint32_t* n, uint64_t* pathBase)
{
    if(a) (*a) = bub->list.a + bub->num.a[id] + 2;
    if(n) (*n) = bub->num.a[id+1] - bub->num.a[id] - 2;
    if(beg) (*beg) = bub->list.a[bub->num.a[id]];
    if(sink) (*sink) = bub->list.a[bub->num.a[id] + 1];
    if(pathBase) (*pathBase) = bub->pathLen.a[id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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)
cmpq $0x0, -0x28(%rbp)
je 0x1c4b70
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdx
movl (%rax,%rdx,4), %eax
shlq $0x2, %rax
addq %rax, %rcx
addq $0x8, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x1c4b9f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdx
subl (%rax,%rdx,4), %ecx
subl $0x2, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x1c4bc6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x1c4bf2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x10(%rbp)
je 0x1c4c10
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)