LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/Process_Read.cpp
// Function: ha_compress_qual_bit(unsigned char*, char*, unsigned long, unsigned long)
void ha_compress_qual_bit(uint8_t* dest, char* src, uint64_t src_l, uint64_t bitn)
{

	uint64_t i = 0, k, bit_r = 8/bitn, dest_i = 0;
	uint8_t tmp = 0, c = 0;

	for (i = 0; i + bit_r <= src_l;) {
		for (k = tmp = 0; k < bit_r; k++) {
			c = ((uint8_t)src[i]);
			tmp <<= bitn; tmp |= c; i++;
		}
		dest[dest_i++] = tmp;
	}

	if(i < src_l) {
		for (k = tmp = 0; i < src_l; k++) {
			c = ((uint8_t)src[i]);
			tmp <<= bitn; tmp |= c; i++;
		}
		 
		dest[dest_i++] = (tmp<<(8-(bitn*k)));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x8, %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
movb $0x0, -0x42(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xabd9
movb $0x0, -0x41(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xabbb
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x42(%rbp)
movq -0x20(%rbp), %rcx
movzbl -0x41(%rbp), %eax
shll %cl, %eax
movb %al, -0x41(%rbp)
movzbl -0x42(%rbp), %ecx
movzbl -0x41(%rbp), %eax
orl %ecx, %eax
movb %al, -0x41(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xab6f
movb -0x41(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x40(%rbp)
movb %dl, (%rax,%rcx)
jmp 0xab55
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xac6e
movb $0x0, -0x41(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xac3f
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x42(%rbp)
movq -0x20(%rbp), %rcx
movzbl -0x41(%rbp), %eax
shll %cl, %eax
movb %al, -0x41(%rbp)
movzbl -0x42(%rbp), %ecx
movzbl -0x41(%rbp), %eax
orl %ecx, %eax
movb %al, -0x41(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xabf3
movzbl -0x41(%rbp), %eax
movq -0x20(%rbp), %rdx
imulq -0x30(%rbp), %rdx
movl $0x8, %ecx
subq %rdx, %rcx
shll %cl, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x40(%rbp)
movb %dl, (%rax,%rcx)
popq %rbp
retq
// File: chhylp123[P]hifiasm/Process_Read.cpp
// Function: reverse_complement(char*, unsigned long)
void reverse_complement(char* pattern, uint64_t length)
{
	uint64_t i = 0;
	uint64_t end = length / 2;
	char k;
	uint64_t index;

	for (i = 0; i < end; i++)
	{
		
		index = length - i - 1;
		k = pattern[index];
		pattern[index] = RC_CHAR(pattern[i]);
		pattern[i] = RC_CHAR(k);
	}

	if(length&(uint64_t)1)
	{
		pattern[end] = RC_CHAR(pattern[end]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xb57c
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3b9128(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3b9220(%rip), %rax    # 0x3c4755
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
leaq 0x3b9100(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3b91f8(%rip), %rax    # 0x3c4755
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb4e7
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xb5ba
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3b90b1(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3b91a9(%rip), %rax    # 0x3c4755
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Process_Read.cpp
// Function: print_fastq(_IO_FILE*, char*, char*, char*, unsigned long, unsigned long)
void print_fastq(FILE *fp, char *id, char *bs, char *qual, uint64_t bitu, uint64_t sc_off)
{
	uint64_t i = 0, ql = strlen(qual); uint8_t c = 0, sc;
	
	if(fp) fprintf(fp, "@%s\n%s\n+\n", id, bs);
	else fprintf(stdout, "@%s\n%s\n+\n", id, bs);

	for (i = 0; i < ql; i++) {
		for (c = 0, sc = ((uint8_t)qual[i]) - sc_off; (c < bitu) && (sc_tb[c] < sc); c++);
		if(c >= bitu) c = bitu - 1;
		if(fp) fprintf(fp, "%u", c);
		else fprintf(stdout, "%u", c);
	}

	if(fp) fprintf(fp, "\n");
	else fprintf(stdout, "\n");
}

// 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 $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20a0
movq %rax, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb61c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x375f21(%rip), %rsi    # 0x381534
movb $0x0, %al
callq 0x22a0
jmp 0xb63c
movq 0x3b89a5(%rip), %rax    # 0x3c3fc8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x375eff(%rip), %rsi    # 0x381534
movb $0x0, %al
callq 0x22a0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xb710
movb $0x0, -0x41(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
subq -0x30(%rbp), %rax
movb %al, -0x42(%rbp)
movzbl -0x41(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x43(%rbp)
jae 0xb698
movzbl -0x41(%rbp), %eax
movl %eax, %ecx
leaq 0x376279(%rip), %rax    # 0x381900
movq (%rax,%rcx,8), %rax
movzbl -0x42(%rbp), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x43(%rbp)
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0xb6a1
jmp 0xb6ad
jmp 0xb6a3
movb -0x41(%rbp), %al
addb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0xb669
movzbl -0x41(%rbp), %eax
cmpq -0x28(%rbp), %rax
jb 0xb6c2
movq -0x28(%rbp), %rax
subq $0x1, %rax
movb %al, -0x41(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb6e1
movq -0x8(%rbp), %rdi
movzbl -0x41(%rbp), %edx
leaq 0x37c4fb(%rip), %rsi    # 0x387bd3
movb $0x0, %al
callq 0x22a0
jmp 0xb6fd
movq 0x3b88e0(%rip), %rax    # 0x3c3fc8
movq (%rax), %rdi
movzbl -0x41(%rbp), %edx
leaq 0x37c4dd(%rip), %rsi    # 0x387bd3
movb $0x0, %al
callq 0x22a0
jmp 0xb6ff
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xb644
cmpq $0x0, -0x8(%rbp)
je 0xb72b
movq -0x8(%rbp), %rdi
leaq 0x37b306(%rip), %rsi    # 0x386a28
movb $0x0, %al
callq 0x22a0
jmp 0xb743
movq 0x3b8896(%rip), %rax    # 0x3c3fc8
movq (%rax), %rdi
leaq 0x37b2ec(%rip), %rsi    # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Process_Read.cpp
// Function: destory_Debug_reads(Debug_reads*)
void destory_Debug_reads(Debug_reads* x)
{
	uint64_t i;
	for (i = 0; i < x->query_num; i++)
	{
		free(x->read_name[i]);
		kv_destroy(x->candidate_count[i].a);
	}
	
	free(x->read_name); free(x->read_id);
	fclose(x->fp); fclose(x->fp_r0); fclose(x->fp_r1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xbb00
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbab4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x21a0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x21a0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Process_Read.cpp
// Function: destory_all_ul_t(all_ul_t*)
void destory_all_ul_t(all_ul_t *x) {
	uint64_t i;
	for (i = 0; i < x->n; i++) {
		free(x->a[i].N_site.a); free(x->a[i].r_base.a); free(x->a[i].bb.a);
	}
	free(x->a);

	for (i = 0; i < x->nid.n; i++) free(x->nid.a[i].a);
	free(x->nid.a);
	free(x->ridx.idx.a); free(x->ridx.occ.a);

	// if(x->mm) {
	// 	for (i = 0; i < x->mm->n; i++) free(x->mm->a[i].a);
	// 	free(x->mm->a); free(x->mm); x->mm = NULL;
	// }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0xbc0b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
imulq $0x58, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
imulq $0x58, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
imulq $0x58, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x30(%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbba4
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2210
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xbc56
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbc20
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
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Process_Read.cpp
// Function: destroy_scaf_res_t(scaf_res_t*)
void destroy_scaf_res_t(scaf_res_t *p)
{
	if(p) {
		uint32_t k;
		for (k = 0; k < p->m; k++) {
			free(p->a[k].N_site.a); free(p->a[k].r_base.a); free(p->a[k].bb.a);	
		}
		free(p->a);
		free(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13ce9
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x13cd4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rdi
callq 0x2210
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13c6e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: ha_ovec_destroy(ha_ovec_buf_t*)
void ha_ovec_destroy(ha_ovec_buf_t *b)
{
	destory_UC_Read(&b->self_read);
	destory_UC_Read(&b->ovlp_read);
	destory_Candidates_list(&b->clist);
	destory_overlap_region_alloc(&b->olist);
    destory_overlap_region_alloc(&b->olist_hp);
	ha_abuf_destroy(b->ab);
    ha_abufl_destroy(b->abl);
    destory_fake_cigar(&(b->tmp_region.f_cigar));
    free(b->tmp_region.w_list.a); free(b->tmp_region.w_list.c.a);
    kv_destroy(b->b_buf.a);
    kv_destroy(b->r_buf.a);
    kv_destroy(b->k_flag.a);
    kv_destroy(b->sp);
    destroy_bit_extz_t(&(b->exz));
	if (!b->is_final) {
		destory_Cigar_record(&b->cigar1);
		destory_Graph(&b->POA_Graph);
		destory_Graph(&b->DAGCon);
		destory_Correct_dumy(&b->correct);
		destoryHaplotypeEvdience(&b->hap);
		destory_Round2_alignment(&b->round2);
	}
	free(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x9670
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x9670
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x230c0
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
callq 0x1e220
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0x1e220
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rdi
callq 0x1a0680
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
callq 0x1a0830
movq -0x8(%rbp), %rdi
addq $0x121a0, %rdi          # imm = 0x121A0
addq $0x38, %rdi
callq 0x1e2c0
movq -0x8(%rbp), %rax
movq 0x121f8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x12210(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x12150(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x12170(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x12190(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x12260(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
addq $0x12268, %rdi          # imm = 0x12268
callq 0x1c4e0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x15060
movq -0x8(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x320c0
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x2c300
movq -0x8(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x2c300
movq -0x8(%rbp), %rdi
addq $0x2c0, %rdi            # imm = 0x2C0
callq 0x32090
movq -0x8(%rbp), %rdi
addq $0x9040, %rdi           # imm = 0x9040
callq 0x1c520
movq -0x8(%rbp), %rdi
addq $0x9330, %rdi           # imm = 0x9330
callq 0x32050
movq -0x8(%rbp), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: ha_Graph_mem(Graph const*)
static int64_t ha_Graph_mem(const Graph *g)
{
	int64_t i, mem = 0;
	mem = sizeof(Graph) + g->node_q.size * 8 + g->g_nodes.size * sizeof(Node);
	for (i = 0; i < (int64_t)g->g_nodes.size; ++i) {
		Node *n = &g->g_nodes.list[i];
		mem += n->mismatch_edges.size * sizeof(Edge);
		mem += n->deletion_edges.size * sizeof(Edge);
		mem += n->insertion_edges.size * sizeof(Edge);
	}
	mem += g->g_nodes.sort.size * 9;
	return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
shlq $0x3, %rax
addq $0xb8, %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jge 0x15556
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
imulq $0x38, 0x28(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
imulq $0x38, 0x48(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
imulq $0x38, 0x68(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x154f0
movq -0x8(%rbp), %rax
imulq $0x9, 0x30(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: get_het_cnt(haplotype_evdience_alloc*)
uint32_t get_het_cnt(haplotype_evdience_alloc *hap)
{
    uint32_t i, cnt;
    for (i = cnt = 0; i < hap->snp_stat.n; i++) {
        if(hap->snp_stat.a[i].score == 1 && (!(hap->snp_stat.a[i].occ_0 < 2 || hap->snp_stat.a[i].occ_1 < 2))) {
            cnt++;
        }
    }
    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x220(%rcx), %rax
jae 0x155fd
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x1c(%rax)
jne 0x155f0
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0x8(%rax)
jb 0x155f0
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0xc(%rax)
jb 0x155f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x155f2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15586
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: Output_corrected_reads()
void Output_corrected_reads()
{
    long long i;
    UC_Read g_read;
    init_UC_Read(&g_read);
    char* gfa_name = (char*)malloc(strlen(asm_opt.output_file_name)+35);
    sprintf(gfa_name, "%s.ec.fa", asm_opt.output_file_name);
    FILE* output_file = fopen(gfa_name, "w");
    free(gfa_name);

    for (i = 0; i < (long long)R_INF.total_reads; i++)
    {
        recover_UC_Read(&g_read, &R_INF, i);
        fwrite(">", 1, 1, output_file);
        fwrite(Get_NAME(R_INF, i), 1, Get_NAME_LENGTH(R_INF, i), output_file);
        fwrite("\n", 1, 1, output_file);
        fwrite(g_read.seq, 1, g_read.length, output_file);
        fwrite("\n", 1, 1, output_file);
    }
    destory_UC_Read(&g_read);
    fclose(output_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x28(%rbp), %rdi
callq 0x9850
leaq 0x3af1d0(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x23, %rdi
callq 0x2270
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x3af1ac(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdx
leaq 0x36c35b(%rip), %rsi    # 0x3819b2
movb $0x0, %al
callq 0x2050
movq -0x30(%rbp), %rdi
leaq 0x383d69(%rip), %rsi    # 0x3993d2
callq 0x2200
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2210
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x3afc92(%rip), %rax    # 0x3c5320
jge 0x1575a
movq -0x8(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x3afc2d(%rip), %rsi    # 0x3c52d0
callq 0xa380
movq -0x38(%rbp), %rcx
leaq 0x36c308(%rip), %rdi    # 0x3819bb
movl $0x1, %edx
movq %rdx, %rsi
callq 0x2400
movq 0x3afc11(%rip), %rdi    # 0x3c52d8
movq 0x3afc42(%rip), %rax    # 0x3c5310
movq -0x8(%rbp), %rcx
addq (%rax,%rcx,8), %rdi
movq 0x3afc33(%rip), %rax    # 0x3c5310
movq -0x8(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq 0x3afc23(%rip), %rax    # 0x3c5310
movq -0x8(%rbp), %rcx
subq (%rax,%rcx,8), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x2400
movq -0x38(%rbp), %rcx
leaq 0x37131a(%rip), %rdi    # 0x386a28
movl $0x1, %edx
movq %rdx, %rsi
callq 0x2400
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x2400
movq -0x38(%rbp), %rcx
leaq 0x3712ec(%rip), %rdi    # 0x386a28
movl $0x1, %edx
movq %rdx, %rsi
callq 0x2400
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x15683
leaq -0x28(%rbp), %rdi
callq 0x9670
movq -0x38(%rbp), %rdi
callq 0x21a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: debug_print_pob_regions()
void debug_print_pob_regions()
{
    uint64_t i, total = 0;
    for (i = 0; i < R_INF.total_reads; i++)
    {
        if(R_INF.trio_flag[i]!=AMBIGU)
        {
            total++;
            fprintf(stderr, "(%lu) %.*s\n", i, (int)Get_NAME_LENGTH(R_INF, i), Get_NAME(R_INF, i));
        }
    }
    fprintf(stderr, "total hp reads: %lu, R_INF.total_reads: %lu\n", total, R_INF.total_reads);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x3af98d(%rip), %rax    # 0x3c5320
jae 0x15a1f
movq 0x3af958(%rip), %rax    # 0x3c52f8
movq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x15a0c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq 0x3ae620(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq 0x3af942(%rip), %rax    # 0x3c5310
movq -0x8(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq 0x3af932(%rip), %rcx    # 0x3c5310
movq -0x8(%rbp), %rsi
subq (%rcx,%rsi,8), %rax
movl %eax, %ecx
movq 0x3af8e9(%rip), %r8     # 0x3c52d8
movq 0x3af91a(%rip), %rax    # 0x3c5310
movq -0x8(%rbp), %rsi
addq (%rax,%rsi,8), %r8
leaq 0x36bfc8(%rip), %rsi    # 0x3819cd
movb $0x0, %al
callq 0x22a0
jmp 0x15a0e
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x15988
movq 0x3ae5ba(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq 0x3af8ec(%rip), %rcx    # 0x3c5320
leaq 0x36bf9e(%rip), %rsi    # 0x3819d9
movb $0x0, %al
callq 0x22a0
movl $0x1, %edi
callq 0x2240
nopl (%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: rescue_hp_reads(ha_ovec_buf_t**)
void rescue_hp_reads(ha_ovec_buf_t **b)
{
    int hom_cov, het_cov;
    ha_flt_tab_hp = ha_idx_hp = NULL;
    if (!(asm_opt.flag & HA_F_NO_KMER_FLT)) {
       ha_flt_tab_hp = ha_ft_gen(&asm_opt, &R_INF, &hom_cov, 1, 0);
    }
    ha_idx_hp = ha_pt_gen(&asm_opt, ha_flt_tab, 1, 1, &R_INF, &hom_cov, &het_cov);


    if (asm_opt.required_read_name)
		kt_for(asm_opt.thread_num, worker_ovec_related_reads, b, R_INF.total_reads);
	else
		kt_for(asm_opt.thread_num, worker_ovec, b, R_INF.total_reads);




    ha_ft_destroy(ha_flt_tab_hp); ha_flt_tab_hp = NULL;
    ha_pt_destroy(ha_idx_hp); ha_idx_hp = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3afa85(%rip), %rax    # 0x3c54e8
movq $0x0, (%rax)
leaq 0x3afa6f(%rip), %rax    # 0x3c54e0
movq $0x0, (%rax)
leaq 0x3aed79(%rip), %rax    # 0x3c47f8
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x15ab5
leaq 0x3aed68(%rip), %rdi    # 0x3c47f8
leaq 0x3af839(%rip), %rsi    # 0x3c52d0
leaq -0xc(%rbp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x189600
movq %rax, %rcx
leaq 0x3afa2e(%rip), %rax    # 0x3c54e0
movq %rcx, (%rax)
leaq 0x3afa14(%rip), %rax    # 0x3c54d0
movq (%rax), %rsi
leaq 0x3aed32(%rip), %rdi    # 0x3c47f8
movl $0x1, %ecx
leaq 0x3af7fe(%rip), %r8     # 0x3c52d0
leaq -0xc(%rbp), %r9
leaq -0x10(%rbp), %rax
movl %ecx, %edx
movq %rax, (%rsp)
callq 0x18a180
movq %rax, %rcx
leaq 0x3af9f9(%rip), %rax    # 0x3c54e8
movq %rcx, (%rax)
leaq 0x3aecff(%rip), %rax    # 0x3c47f8
cmpq $0x0, 0x18(%rax)
je 0x15b23
leaq 0x3aecf1(%rip), %rax    # 0x3c47f8
movl 0x7c(%rax), %edi
movq -0x8(%rbp), %rdx
movq 0x3af80b(%rip), %rcx    # 0x3c5320
leaq 0x74(%rip), %rsi        # 0x15b90
callq 0x16d710
jmp 0x15b44
leaq 0x3aecce(%rip), %rax    # 0x3c47f8
movl 0x7c(%rax), %edi
movq -0x8(%rbp), %rdx
movq 0x3af7e8(%rip), %rcx    # 0x3c5320
leaq 0xa21(%rip), %rsi       # 0x16560
callq 0x16d710
leaq 0x3af995(%rip), %rax    # 0x3c54e0
movq (%rax), %rdi
callq 0x188df0
leaq 0x3af986(%rip), %rax    # 0x3c54e0
movq $0x0, (%rax)
leaq 0x3af980(%rip), %rax    # 0x3c54e8
movq (%rax), %rdi
callq 0x187660
leaq 0x3af971(%rip), %rax    # 0x3c54e8
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: print_het_cnt_log(unsigned int*)
void print_het_cnt_log(uint32_t *het_cnt)
{
    if(!het_cnt) return;
    char* gfa_name = (char*)malloc(strlen(asm_opt.output_file_name)+35);
    sprintf(gfa_name, "%s.het_cnt.log", asm_opt.output_file_name);
    FILE* output_file = fopen(gfa_name, "w");
    fprintf(stderr, "[M::%s::] ==> print cnt of het sites to %s...\n", __func__, gfa_name);
    free(gfa_name);
    uint64_t i;
    for (i = 0; i < R_INF.total_reads; i++){
        fprintf(output_file, ">%.*s\t%u\n", (int)Get_NAME_LENGTH(R_INF, i), Get_NAME(R_INF, i), het_cnt[i]);
    }
    fclose(output_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16948
jmp 0x16a46
leaq 0x3adea9(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x23, %rdi
callq 0x2270
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3ade85(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdx
leaq 0x36b088(%rip), %rsi    # 0x381a06
movb $0x0, %al
callq 0x2050
movq -0x10(%rbp), %rdi
leaq 0x382a42(%rip), %rsi    # 0x3993d2
callq 0x2200
movq %rax, -0x18(%rbp)
movq 0x3ad640(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rcx
leaq 0x36b067(%rip), %rsi    # 0x381a15
leaq 0x36b08f(%rip), %rdx    # 0x381a44
movb $0x0, %al
callq 0x22a0
movq -0x10(%rbp), %rdi
callq 0x2210
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x3ae948(%rip), %rax    # 0x3c5320
jae 0x16a3d
movq -0x18(%rbp), %rdi
movq 0x3ae92b(%rip), %rax    # 0x3c5310
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq 0x3ae91b(%rip), %rcx    # 0x3c5310
movq -0x20(%rbp), %rdx
subq (%rcx,%rdx,8), %rax
movl %eax, %edx
movq 0x3ae8d2(%rip), %rcx    # 0x3c52d8
movq 0x3ae903(%rip), %rax    # 0x3c5310
movq -0x20(%rbp), %rsi
addq (%rax,%rsi,8), %rcx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rsi
movl (%rax,%rsi,4), %r8d
leaq 0x36b02e(%rip), %rsi    # 0x381a56
movb $0x0, %al
callq 0x22a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x169cd
movq -0x18(%rbp), %rdi
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: prt_dbg_rs(_IO_FILE*, Debug_reads*, unsigned long)
void prt_dbg_rs(FILE *fp, Debug_reads* x, uint64_t round)
{
    uint64_t k, id; UC_Read g_read; init_UC_Read(&g_read);
    for (k = 0; k < R_INF_FLAG.query_num; k++) {
        id = x->read_id[k];
        if(id == ((uint64_t)-1)) continue;
        recover_UC_Read(&g_read, &R_INF, id);
        fprintf(fp, ">%.*s_r%lu\n", (int)Get_NAME_LENGTH((R_INF), id), Get_NAME((R_INF), id), round);
        fprintf(fp, "%.*s\n", (int)g_read.length, g_read.seq);
    }
    destory_UC_Read(&g_read);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9850
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x3ae8e8(%rip), %rax    # 0x3c5368
jae 0x16b31
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x16aa3
jmp 0x16b20
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq 0x3ae81e(%rip), %rsi    # 0x3c52d0
callq 0xa380
movq -0x8(%rbp), %rdi
movq 0x3ae84e(%rip), %rax    # 0x3c5310
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq 0x3ae83e(%rip), %rcx    # 0x3c5310
movq -0x28(%rbp), %rdx
subq (%rcx,%rdx,8), %rax
movl %eax, %edx
movq 0x3ae7f5(%rip), %rcx    # 0x3c52d8
movq 0x3ae826(%rip), %rax    # 0x3c5310
movq -0x28(%rbp), %rsi
addq (%rax,%rsi,8), %rcx
movq -0x18(%rbp), %r8
leaq 0x36af63(%rip), %rsi    # 0x381a60
movb $0x0, %al
callq 0x22a0
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %edx
movq -0x48(%rbp), %rcx
leaq 0x380231(%rip), %rsi    # 0x396d4a
movb $0x0, %al
callq 0x22a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16a75
leaq -0x48(%rbp), %rdi
callq 0x9670
addq $0x50, %rsp
popq %rbp
retq
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: ha_ec_dbg()
int ha_ec_dbg(void)
{
	int hom_cov, het_cov;

    ha_idx = ha_pt_gen(&asm_opt, 0, 0, 0, &R_INF, &hom_cov, &het_cov); // build the index
    asm_opt.hom_cov = hom_cov; asm_opt.het_cov = het_cov;
	ha_opt_update_cov(&asm_opt, hom_cov);

    cal_ec_r_dbg(asm_opt.thread_num, R_INF.total_reads);

    ha_pt_destroy(ha_idx); ha_idx = NULL;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3ad999(%rip), %rdi    # 0x3c47f8
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
leaq 0x3ae464(%rip), %r8     # 0x3c52d0
leaq -0x4(%rbp), %r9
leaq -0x8(%rbp), %rax
movl %ecx, %edx
movq %rax, (%rsp)
callq 0x18a180
movq %rax, %rcx
leaq 0x3ae64f(%rip), %rax    # 0x3c54d8
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
leaq 0x3ad962(%rip), %rax    # 0x3c47f8
movl %ecx, 0xd0(%rax)
movl -0x8(%rbp), %ecx
leaq 0x3ad952(%rip), %rax    # 0x3c47f8
movl %ecx, 0xd4(%rax)
movl -0x4(%rbp), %esi
leaq 0x3ad942(%rip), %rdi    # 0x3c47f8
callq 0x3b60
leaq 0x3ad936(%rip), %rax    # 0x3c47f8
movslq 0x7c(%rax), %rdi
movq 0x3ae453(%rip), %rsi    # 0x3c5320
callq 0x26a110
leaq 0x3ae5ff(%rip), %rax    # 0x3c54d8
movq (%rax), %rdi
callq 0x187660
leaq 0x3ae5f0(%rip), %rax    # 0x3c54d8
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: check_chain_indels(Fake_Cigar*, long long, long long, float)
int check_chain_indels(Fake_Cigar* chain, long long xBeg, long long xEnd, float indel_rate)
{
    uint64_t i = 0;
    long long indels = 0, xOffset;
    if(chain->length != 0)
    {
        indels += abs(get_fake_gap_shift(chain, 0));
        xOffset = get_fake_gap_pos(chain, 0);
        if(indels > (xOffset - xBeg + 1) * indel_rate) return 0;

        for (i = 1; i < chain->length; i++)
        {
            indels += abs((get_fake_gap_shift(chain, i) - get_fake_gap_shift(chain, i-1)));
            xOffset = get_fake_gap_pos(chain, i);
            if(indels > (xOffset - xBeg + 1) * indel_rate) return 0;
        }
    }

    if(indels > (xEnd - xBeg + 1) * indel_rate) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x185de
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1e340
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cltq
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1e320
cltq
movq %rax, -0x40(%rbp)
cvtsi2ssq -0x38(%rbp), %xmm0
movq -0x40(%rbp), %rax
subq -0x18(%rbp), %rax
addq $0x1, %rax
cvtsi2ss %rax, %xmm1
mulss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x18531
movl $0x0, -0x4(%rbp)
jmp 0x1860f
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
jae 0x185dc
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
callq 0x1e340
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
subq $0x1, %rax
movl %eax, %esi
callq 0x1e340
movl %eax, %ecx
movl -0x44(%rbp), %eax
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cltq
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
callq 0x1e320
cltq
movq %rax, -0x40(%rbp)
cvtsi2ssq -0x38(%rbp), %xmm0
movq -0x40(%rbp), %rax
subq -0x18(%rbp), %rax
addq $0x1, %rax
cvtsi2ss %rax, %xmm1
mulss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x185c9
movl $0x0, -0x4(%rbp)
jmp 0x1860f
jmp 0x185cb
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x18539
jmp 0x185de
cvtsi2ssq -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
addq $0x1, %rax
cvtsi2ss %rax, %xmm1
mulss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x18608
movl $0x0, -0x4(%rbp)
jmp 0x1860f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: reset_final_overlaps(overlap_region_alloc*)
void reset_final_overlaps(overlap_region_alloc *overlap_list)
{
    
    uint64_t i;
    for (i = 0; i < overlap_list->length; i++)
    {
        if (overlap_list->list[i].is_match == 1 || overlap_list->list[i].is_match == 2)
        {
            overlap_list->list[i].x_pos_s = overlap_list->list[i].x_pos_e = (uint32_t)-1;
            overlap_list->list[i].y_pos_s = overlap_list->list[i].y_pos_e = (uint32_t)-1;
            overlap_list->list[i].is_match = 0;
        }
    }

    ha_sort_list_by_anchor(overlap_list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x195c9
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x10(%rbp), %rcx
addq %rcx, %rax
movzbl 0x2c(%rax), %eax
cmpl $0x1, %eax
je 0x1953c
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x10(%rbp), %rcx
addq %rcx, %rax
movzbl 0x2c(%rax), %eax
cmpl $0x2, %eax
jne 0x195b6
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x10(%rbp), %rcx
addq %rcx, %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x10(%rbp), %rcx
addq %rcx, %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x10(%rbp), %rcx
addq %rcx, %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x10(%rbp), %rcx
addq %rcx, %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x10(%rbp), %rcx
addq %rcx, %rax
movb $0x0, 0x2c(%rax)
jmp 0x195b8
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x194f4
movq -0x8(%rbp), %rdi
callq 0x1a3c60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: check_cluster(unsigned long*, long long, ma_hit_t_alloc*, float)
int check_cluster(uint64_t* list, long long listLen, ma_hit_t_alloc* paf, float threshold)
{
    long long i, k;
    uint32_t qn, tn;
    long long T_edges, A_edges;
    T_edges = A_edges = 0;
    for (i = 0; i < listLen; i++)
    {
        qn = (uint32_t)list[i];
        for (k = i + 1; k < listLen; k++)
        {
            tn = (uint32_t)list[k];
            if(get_specific_overlap(&(paf[qn]), qn, tn) != -1)
            {
                A_edges++;
            }

            if(get_specific_overlap(&(paf[tn]), tn, qn) != -1)
            {
                A_edges++;
            }

            T_edges = T_edges + 2;
        }

    }

    if(A_edges >= (T_edges*threshold))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x1a29d
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x1a28a
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movl -0x3c(%rbp), %esi
movl -0x40(%rbp), %edx
callq 0xce1b0
cmpq $-0x1, %rax
je 0x1a242
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movl -0x40(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
callq 0xce1b0
cmpq $-0x1, %rax
je 0x1a26d
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1a1fa
jmp 0x1a28c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1a1d1
cvtsi2ssq -0x50(%rbp), %xmm0
cvtsi2ssq -0x48(%rbp), %xmm1
mulss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0x1a2bc
movl $0x1, -0x4(%rbp)
jmp 0x1a2c3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: ha_overlap_final()
void ha_overlap_final(void)
{
	int i, hom_cov, het_cov;
	ha_ovec_buf_t **b;
    ha_flt_tab_hp = ha_idx_hp = NULL;

	CALLOC(b, asm_opt.thread_num);
	for (i = 0; i < asm_opt.thread_num; ++i)
		b[i] = ha_ovec_init(asm_opt.flag & HA_F_HIGH_HET, 1,0);///b[i] = ha_ovec_init(1, 1);
	ha_idx = ha_pt_gen(&asm_opt, ha_flt_tab, 1, 0, &R_INF, &hom_cov, &het_cov); // build the index
    // if(asm_opt.flag & HA_F_HIGH_HET)
    // {
    //     kt_for(asm_opt.thread_num, worker_ov_final_high_het, b, R_INF.total_reads);
    // }
    // else
    {
        kt_for(asm_opt.thread_num, worker_ov_final, b, R_INF.total_reads);
    }
    
	ha_pt_destroy(ha_idx);
	ha_idx = 0;
	for (i = 0; i < asm_opt.thread_num; ++i)
		ha_ovec_destroy(b[i]);
	free(b);
    asm_opt.hom_cov = hom_cov;
    asm_opt.het_cov = het_cov;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x3aab19(%rip), %rax    # 0x3c54e8
movq $0x0, (%rax)
leaq 0x3aab03(%rip), %rax    # 0x3c54e0
movq $0x0, (%rax)
leaq 0x3a9e0d(%rip), %rax    # 0x3c47f8
movslq 0x7c(%rax), %rdi
movl $0x8, %esi
callq 0x2140
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x3a9dea(%rip), %rcx    # 0x3c47f8
cmpl 0x7c(%rcx), %eax
jge 0x1aa48
leaq 0x3a9dde(%rip), %rax    # 0x3c47f8
movl (%rax), %edi
andl $0x400, %edi            # imm = 0x400
movl $0x1, %esi
xorl %edx, %edx
callq 0x14c90
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1aa04
leaq 0x3aaa81(%rip), %rax    # 0x3c54d0
movq (%rax), %rsi
leaq 0x3a9d9f(%rip), %rdi    # 0x3c47f8
movl $0x1, %edx
xorl %ecx, %ecx
leaq 0x3aa869(%rip), %r8     # 0x3c52d0
leaq -0x8(%rbp), %r9
leaq -0xc(%rbp), %rax
movq %rax, (%rsp)
callq 0x18a180
movq %rax, %rcx
leaq 0x3aaa56(%rip), %rax    # 0x3c54d8
movq %rcx, (%rax)
leaq 0x3a9d6c(%rip), %rax    # 0x3c47f8
movl 0x7c(%rax), %edi
movq -0x18(%rbp), %rdx
movq 0x3aa886(%rip), %rcx    # 0x3c5320
leaq 0x8f(%rip), %rsi        # 0x1ab30
callq 0x16d710
leaq 0x3aaa2b(%rip), %rax    # 0x3c54d8
movq (%rax), %rdi
callq 0x187660
leaq 0x3aaa1c(%rip), %rax    # 0x3c54d8
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x3a9d24(%rip), %rcx    # 0x3c47f8
cmpl 0x7c(%rcx), %eax
jge 0x1aaf5
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14f00
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1aaca
movq -0x18(%rbp), %rdi
callq 0x2210
movl -0x8(%rbp), %ecx
leaq 0x3a9cf0(%rip), %rax    # 0x3c47f8
movl %ecx, 0xd0(%rax)
movl -0xc(%rbp), %ecx
leaq 0x3a9ce0(%rip), %rax    # 0x3c47f8
movl %ecx, 0xd4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: ha_ec_ff(int)
void ha_ec_ff(int renew_idx)
{
	int hom_cov, het_cov;
    ha_flt_tab_hp = ha_idx_hp = NULL;

    if(ha_idx && renew_idx) {
        ha_pt_destroy(ha_idx); ha_idx = NULL;
    }

    if(!ha_idx) {
        ha_idx = ha_pt_gen(&asm_opt, ha_flt_tab, 1, 0, &R_INF, &hom_cov, &het_cov); // build the index
        asm_opt.hom_cov = hom_cov; asm_opt.het_cov = het_cov;
    }

    cal_ov_r(asm_opt.thread_num, R_INF.total_reads, renew_idx);

	ha_pt_destroy(ha_idx); ha_idx = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x3aa746(%rip), %rax    # 0x3c54e8
movq $0x0, (%rax)
leaq 0x3aa730(%rip), %rax    # 0x3c54e0
movq $0x0, (%rax)
leaq 0x3aa71a(%rip), %rax    # 0x3c54d8
cmpq $0x0, (%rax)
je 0x1ade7
cmpl $0x0, -0x4(%rbp)
je 0x1ade7
leaq 0x3aa707(%rip), %rax    # 0x3c54d8
movq (%rax), %rdi
callq 0x187660
leaq 0x3aa6f8(%rip), %rax    # 0x3c54d8
movq $0x0, (%rax)
leaq 0x3aa6ea(%rip), %rax    # 0x3c54d8
cmpq $0x0, (%rax)
jne 0x1ae51
leaq 0x3aa6d5(%rip), %rax    # 0x3c54d0
movq (%rax), %rsi
leaq 0x3a99f3(%rip), %rdi    # 0x3c47f8
movl $0x1, %edx
xorl %ecx, %ecx
leaq 0x3aa4bd(%rip), %r8     # 0x3c52d0
leaq -0x8(%rbp), %r9
leaq -0xc(%rbp), %rax
movq %rax, (%rsp)
callq 0x18a180
movq %rax, %rcx
leaq 0x3aa6aa(%rip), %rax    # 0x3c54d8
movq %rcx, (%rax)
movl -0x8(%rbp), %ecx
leaq 0x3a99bd(%rip), %rax    # 0x3c47f8
movl %ecx, 0xd0(%rax)
movl -0xc(%rbp), %ecx
leaq 0x3a99ad(%rip), %rax    # 0x3c47f8
movl %ecx, 0xd4(%rax)
leaq 0x3a99a0(%rip), %rax    # 0x3c47f8
movslq 0x7c(%rax), %rdi
movq 0x3aa4bd(%rip), %rsi    # 0x3c5320
movslq -0x4(%rbp), %rdx
callq 0x26a800
leaq 0x3aa665(%rip), %rax    # 0x3c54d8
movq (%rax), %rdi
callq 0x187660
leaq 0x3aa656(%rip), %rax    # 0x3c54d8
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: ug_idx_build(ma_ug_t*, int)
void ug_idx_build(ma_ug_t *ug, int hap_n)
{
    int flag = asm_opt.flag&HA_F_NO_HPC, i;
    asm_opt.flag -= flag;
    // ha_flt_tab = ha_ft_ug_gen(&asm_opt, &(ug->u), hap_n, hap_n);
    // ha_idx = ha_pt_ug_gen(&asm_opt, ha_flt_tab, &(ug->u), hap_n);

    ha_ovec_buf_t **b = NULL;
    // overlap and correct reads
    CALLOC(b, asm_opt.thread_num);
    for (i = 0; i < asm_opt.thread_num; ++i)
    {
        b[i] = ha_ovec_init(1, 1, 0);
        b[i]->ua = &(ug->u);
    }
            
    kt_for(asm_opt.thread_num, worker_ov_utg, b, R_INF.total_reads);

    for (i = 0; i < asm_opt.thread_num; ++i)
        ha_ovec_destroy(b[i]);
    free(b);

    ha_ft_destroy(ha_flt_tab); 
    ha_pt_destroy(ha_idx);
    asm_opt.flag += flag;
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x3a9952(%rip), %rax    # 0x3c47f8
movl (%rax), %eax
andl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0x3a9940(%rip), %rcx    # 0x3c47f8
movl (%rcx), %ecx
subl %eax, %ecx
leaq 0x3a9935(%rip), %rax    # 0x3c47f8
movl %ecx, (%rax)
movq $0x0, -0x20(%rbp)
leaq 0x3a9924(%rip), %rax    # 0x3c47f8
movslq 0x7c(%rax), %rdi
movl $0x8, %esi
callq 0x2140
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x3a9901(%rip), %rcx    # 0x3c47f8
cmpl 0x7c(%rcx), %eax
jge 0x1af3b
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x14c90
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x12248(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1aeed
leaq 0x3a98b6(%rip), %rax    # 0x3c47f8
movl 0x7c(%rax), %edi
movq -0x20(%rbp), %rdx
movq 0x3aa3d0(%rip), %rcx    # 0x3c5320
leaq 0x89(%rip), %rsi        # 0x1afe0
callq 0x16d710
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x3a988b(%rip), %rcx    # 0x3c47f8
cmpl 0x7c(%rcx), %eax
jge 0x1af8e
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14f00
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1af63
movq -0x20(%rbp), %rdi
callq 0x2210
leaq 0x3aa532(%rip), %rax    # 0x3c54d0
movq (%rax), %rdi
callq 0x188df0
leaq 0x3aa52b(%rip), %rax    # 0x3c54d8
movq (%rax), %rdi
callq 0x187660
movl -0x10(%rbp), %ecx
leaq 0x3a9839(%rip), %rax    # 0x3c47f8
addl (%rax), %ecx
leaq 0x3a9830(%rip), %rax    # 0x3c47f8
movl %ecx, (%rax)
movl $0x1, %edi
callq 0x2240
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: ha_assemble_ovec()
int ha_assemble_ovec(void)
{
	extern void ha_extract_print_list(const All_reads *rs, int n_rounds, const char *o);
	int r = 0, hom_cov = -1;
	
    ha_flt_tab = ha_idx = NULL;

    // construct hash table for high occurrence k-mers
    if (!(asm_opt.flag & HA_F_NO_KMER_FLT) && ha_flt_tab == NULL) {
        ha_flt_tab = ha_ft_gen(&asm_opt, &R_INF, &hom_cov, 0, 0);
        ha_opt_update_cov(&asm_opt, hom_cov);
    }
    // error correction
    assert(asm_opt.number_of_round > 0);
    ha_opt_reset_to_round(&asm_opt, r); // this update asm_opt.roundID and a few other fields
    ha_overlap_cal(r, 0);
    fprintf(stderr, "[M::%s] size of buffer: %.3fGB\n", __func__, asm_opt.mem_buf / 1073741824.0);
    
    
    ha_print_ovlp_stat(R_INF.paf, R_INF.reverse_paf, R_INF.total_reads);
    ha_ft_destroy(ha_flt_tab);

    Output_PAF0(R_INF.paf, "0");
    Output_PAF0(R_INF.reverse_paf, "1");
    if (asm_opt.flag & HA_F_WRITE_PAF) Output_PAF();

	destory_All_reads(&R_INF);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
leaq 0x3aa24b(%rip), %rax    # 0x3c54d8
movq $0x0, (%rax)
leaq 0x3aa235(%rip), %rax    # 0x3c54d0
movq $0x0, (%rax)
leaq 0x3a954f(%rip), %rax    # 0x3c47f8
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x1b2f9
leaq 0x3aa216(%rip), %rax    # 0x3c54d0
cmpq $0x0, (%rax)
jne 0x1b2f9
leaq 0x3a9531(%rip), %rdi    # 0x3c47f8
leaq 0x3aa002(%rip), %rsi    # 0x3c52d0
leaq -0x8(%rbp), %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x189600
movq %rax, %rcx
leaq 0x3aa1e9(%rip), %rax    # 0x3c54d0
movq %rcx, (%rax)
movl -0x8(%rbp), %esi
leaq 0x3a9504(%rip), %rdi    # 0x3c47f8
callq 0x3b60
leaq 0x3a94f8(%rip), %rax    # 0x3c47f8
cmpl $0x0, 0xf8(%rax)
jle 0x1b30b
jmp 0x1b32a
leaq 0x36690d(%rip), %rdi    # 0x381c1f
leaq 0x366922(%rip), %rsi    # 0x381c3b
movl $0x7ea, %edx            # imm = 0x7EA
leaq 0x366923(%rip), %rcx    # 0x381c48
callq 0x2130
movl -0x4(%rbp), %esi
leaq 0x3a94c4(%rip), %rdi    # 0x3c47f8
callq 0x3b00
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0x177d0
movq 0x3a8c96(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x3a94a4(%rip), %rax    # 0x3c47f8
cvtsi2sdq 0x1a8(%rax), %xmm0
movsd 0x3665eb(%rip), %xmm1   # 0x381950
divsd %xmm1, %xmm0
leaq 0x3668ef(%rip), %rsi    # 0x381c5f
leaq 0x366908(%rip), %rdx    # 0x381c7f
movb $0x1, %al
callq 0x22a0
movq 0x3a9fc3(%rip), %rdi    # 0x3c5348
movq 0x3a9fc4(%rip), %rsi    # 0x3c5350
movq 0x3a9f8d(%rip), %rdx    # 0x3c5320
callq 0x18f70
leaq 0x3aa131(%rip), %rax    # 0x3c54d0
movq (%rax), %rdi
callq 0x188df0
movq 0x3a9f9a(%rip), %rdi    # 0x3c5348
leaq 0x367869(%rip), %rsi    # 0x382c1e
callq 0x19d30
movq 0x3a9f8f(%rip), %rdi    # 0x3c5350
leaq 0x37fe99(%rip), %rsi    # 0x39b261
callq 0x19d30
leaq 0x3a9424(%rip), %rax    # 0x3c47f8
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1b3e3
callq 0x198d0
leaq 0x3a9ee6(%rip), %rdi    # 0x3c52d0
callq 0x73f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: ha_assemble_ovec_cc()
int ha_assemble_ovec_cc(void)
{
    ha_idx = NULL;

    ha_opt_reset_to_round(&asm_opt, 0); // this update asm_opt.roundID and a few other fields
    ha_ec_dbg();

    // Output_PAF0(R_INF.paf, "0");
	destory_All_reads(&R_INF);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x3aa0cd(%rip), %rax    # 0x3c54d8
movq $0x0, (%rax)
leaq 0x3a93df(%rip), %rdi    # 0x3c47f8
xorl %esi, %esi
callq 0x3b00
callq 0x16e50
leaq 0x3a9ea4(%rip), %rdi    # 0x3c52d0
callq 0x73f0
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: get_N_occ(char*, long long)
static inline long long get_N_occ(char* seq, long long length)
{
	long long j, N_occ = 0;
	for (j = 0; j < length; j++)
		if(seq_nt6_table[(uint8_t)seq[j]] >= 4)
			N_occ++;
	return N_occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x1bf40
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3a8735(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jl 0x1bf30
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1bf32
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1befc
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/./Correct.h
// Function: InitHaplotypeEvdience_buf(haplotype_evdience_alloc*, void*)
inline void InitHaplotypeEvdience_buf(haplotype_evdience_alloc* h, void *km)
{
    memset(h, 0, sizeof(haplotype_evdience_alloc));
    /****************************may have bugs********************************/
    memset(h->flag, 0, WINDOW_MAX_SIZE * sizeof(uint8_t));
    /****************************may have bugs********************************/
    // init_SNP_IDs(&(h->dp.SNP_IDs));
    memset(&(h->dp.SNP_IDs), 0, sizeof(h->dp.SNP_IDs));
    h->dp.SNP_IDs.max_snp_id = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x2e8, %edx            # imm = 0x2E8
callq 0x2100
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x2100
movq -0x8(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
addq $0x60, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movq $-0x1, 0x2c0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop