LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: init_UC_Read(UC_Read*)
void init_UC_Read(UC_Read* r)
{
	r->length = 0;
	r->size = 0;
	r->seq = NULL;
	if (bit_t_seq_table[0][0] == 0)
	{
		uint64_t i = 0;

		for (i = 0; i < 256; i++)
		{
			bit_t_seq_table[i][0] = s_H[((i >> 6)&(uint64_t)3)];
			bit_t_seq_table[i][1] = s_H[((i >> 4)&(uint64_t)3)];
			bit_t_seq_table[i][2] = s_H[((i >> 2)&(uint64_t)3)];
			bit_t_seq_table[i][3] = s_H[(i&(uint64_t)3)];

			bit_t_seq_table_rc[i][0] = RC_CHAR(bit_t_seq_table[i][3]);
			bit_t_seq_table_rc[i][1] = RC_CHAR(bit_t_seq_table[i][2]);
			bit_t_seq_table_rc[i][2] = RC_CHAR(bit_t_seq_table[i][1]);
			bit_t_seq_table_rc[i][3] = RC_CHAR(bit_t_seq_table[i][0]);
		}
	}
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpb $0x0, 0x2572ef(%rip)    # 0x28aa30
je 0x33744
retq
pushq %rbx
xorl %eax, %eax
leaq 0x256fe2(%rip), %rcx    # 0x28a730
leaq 0x2572db(%rip), %rdx    # 0x28aa30
leaq 0x256ed4(%rip), %rsi    # 0x28a630
leaq 0x256fd2(%rip), %rdi    # 0x28a735
leaq 0x2576c6(%rip), %r8     # 0x28ae30
movq %rax, %r9
shrq $0x6, %r9
movzbl (%r9,%rcx), %r9d
movb %r9b, (%rdx,%rax,4)
movl %eax, %r10d
shrl $0x4, %r10d
andl $0x3, %r10d
movzbl (%r10,%rcx), %r10d
movb %r10b, 0x1(%rdx,%rax,4)
movl %eax, %r11d
shrl $0x2, %r11d
andl $0x3, %r11d
movzbl (%r11,%rcx), %r11d
movb %r11b, 0x2(%rdx,%rax,4)
movl %eax, %ebx
andl $0x3, %ebx
movzbl (%rbx,%rcx), %ebx
movb %bl, 0x3(%rdx,%rax,4)
movzbl (%rbx,%rsi), %ebx
movb (%rbx,%rdi), %bl
movb %bl, (%r8,%rax,4)
movzbl (%r11,%rsi), %r11d
movb (%r11,%rdi), %r11b
movb %r11b, 0x1(%r8,%rax,4)
movzbl (%r10,%rsi), %r10d
movb (%r10,%rdi), %r10b
movb %r10b, 0x2(%r8,%rax,4)
movzbl (%r9,%rsi), %r9d
movb (%r9,%rdi), %r9b
movb %r9b, 0x3(%r8,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x3376a
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: recover_UC_Read(UC_Read*, All_reads const*, unsigned long)
void recover_UC_Read(UC_Read* r, const All_reads *R_INF, uint64_t ID)
{
	r->length = Get_READ_LENGTH((*R_INF), ID);
	uint8_t* src = Get_READ((*R_INF), ID);

	if (r->length + 4 > r->size) {
		r->size = r->length + 4;
		r->seq = (char*)realloc(r->seq,sizeof(char)*(r->size));
	}

	uint64_t i = 0;

	if(src) {
		while ((long long)i < r->length) {
			memcpy(r->seq+i, bit_t_seq_table[src[i>>2]], 4);
			i = i + 4;
		}

		if (R_INF->N_site[ID]) {
			for (i = 1; i <= R_INF->N_site[ID][0]; i++) r->seq[R_INF->N_site[ID][i]] = 'N';
		}
	} else {///N
		memset(r->seq, 'N', r->length);
	}

	r->RID = ID;	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rsi), %rax
movq (%rax,%rdx,8), %rsi
movq %rsi, 0x8(%rdi)
movq 0x10(%r15), %rax
movq (%rax,%rdx,8), %r12
addq $0x4, %rsi
cmpq 0x10(%rdi), %rsi
jle 0x33d36
movq %rsi, 0x10(%r14)
movq (%r14), %rdi
callq 0x2370
movq %rax, (%r14)
testq %r12, %r12
je 0x33da2
cmpq $0x0, 0x8(%r14)
jle 0x33d6a
xorl %eax, %eax
leaq 0x256ce5(%rip), %rcx    # 0x28aa30
movq (%r14), %rdx
movq %rax, %rsi
shrq $0x2, %rsi
movzbl (%r12,%rsi), %esi
movl (%rcx,%rsi,4), %esi
movl %esi, (%rdx,%rax)
addq $0x4, %rax
cmpq 0x8(%r14), %rax
jl 0x33d4b
movq (%r15), %rax
cmpq $0x0, (%rax,%rbx,8)
je 0x33db3
movq (%r15), %rax
movq (%rax,%rbx,8), %rax
cmpq $0x0, (%rax)
je 0x33db3
movl $0x1, %ecx
movq (%r14), %rdx
movq (%rax,%rcx,8), %rax
movb $0x4e, (%rdx,%rax)
incq %rcx
movq (%r15), %rax
movq (%rax,%rbx,8), %rax
cmpq (%rax), %rcx
jbe 0x33d86
jmp 0x33db3
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movl $0x4e, %esi
callq 0x20e0
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: recover_UC_Read_RC(UC_Read*, All_reads*, unsigned long)
void recover_UC_Read_RC(UC_Read* r, All_reads* R_INF, uint64_t ID)
{
	r->length = Get_READ_LENGTH((*R_INF), ID);
	uint8_t* src = Get_READ((*R_INF), ID);

	if (r->length + 4 > r->size) {
		r->size = r->length + 4;
		r->seq = (char*)realloc(r->seq,sizeof(char)*(r->size));
	}

	long long last_chr = r->length % 4;
	long long i = r->length / 4 - 1 + (last_chr != 0);
	long long index = 0;

	if(src) {
		if(last_chr!=0) {
			memcpy(r->seq + index, bit_t_seq_table_rc[src[i]] + 4 - last_chr, last_chr);
			index = last_chr;
			i--;
		}

		while (i >= 0) {
			memcpy(r->seq + index, bit_t_seq_table_rc[src[i]], 4);
			i--;
			index = index + 4;
		}

		if (R_INF->N_site[ID]) {
			for (i = 1; i <= (long long)R_INF->N_site[ID][0]; i++) {
				r->seq[r->length - R_INF->N_site[ID][i] - 1] = 'N';
			}
		}
	} else {///N
		memset(r->seq, 'N', r->length);
	}

	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rsi), %rax
movq (%rax,%rdx,8), %rsi
movq %rsi, 0x8(%rdi)
movq 0x10(%r15), %rax
movq (%rax,%rdx,8), %r13
addq $0x4, %rsi
cmpq 0x10(%rdi), %rsi
jle 0x33e04
movq %rsi, 0x10(%r14)
movq (%r14), %rdi
callq 0x2370
movq %rax, (%r14)
movq 0x8(%r14), %rdx
leaq 0x3(%rdx), %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
movq %rax, %rsi
andq $-0x4, %rsi
xorl %ecx, %ecx
movq %rdx, %r12
subq %rsi, %r12
setne %sil
testq %r13, %r13
je 0x33e6a
movq %rbx, (%rsp)
sarq $0x2, %rax
movb %sil, %cl
leaq (%rax,%rcx), %rbp
decq %rbp
leaq 0x256fec(%rip), %rbx    # 0x28ae30
testq %r12, %r12
je 0x33e85
movq (%r14), %rdi
movzbl (%r13,%rbp), %eax
leaq (%rbx,%rax,4), %rsi
subq %r12, %rsi
addq $0x4, %rsi
movq %r12, %rdx
callq 0x2160
decq %rbp
jmp 0x33e88
movq (%r14), %rdi
movl $0x4e, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
xorl %r12d, %r12d
testq %rbp, %rbp
js 0x33ea9
incq %rbp
movq (%r14), %rax
movzbl -0x1(%r13,%rbp), %ecx
movl (%rbx,%rcx,4), %ecx
movl %ecx, (%rax,%r12)
addq $0x4, %r12
decq %rbp
jg 0x33e90
movq (%r15), %rax
movq (%rsp), %rsi
cmpq $0x0, (%rax,%rsi,8)
je 0x33ee8
movq (%r15), %rax
movq (%rax,%rsi,8), %rcx
cmpq $0x0, (%rcx)
jle 0x33ee8
xorl %eax, %eax
movq (%r14), %rdx
movq 0x8(%rcx,%rax,8), %rcx
notq %rcx
addq 0x8(%r14), %rdx
movb $0x4e, (%rcx,%rdx)
movq (%r15), %rcx
movq (%rcx,%rsi,8), %rcx
incq %rax
cmpq (%rcx), %rax
jl 0x33ec6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: ha_compress_base(unsigned char*, char*, unsigned long, unsigned long**, unsigned long)
void ha_compress_base(uint8_t* dest, char* src, uint64_t src_l, uint64_t** N_site_lis, uint64_t N_site_occ)
{
	///N_site_lis saves the pos of all Ns in this read
	///N_site_lis[0] is the number of Ns
	free((*N_site_lis));
	if (N_site_occ)
	{
		(*N_site_lis) = (uint64_t*)malloc(sizeof(uint64_t)*(N_site_occ + 1));
		(*N_site_lis)[0] = N_site_occ;
	}
	else
	{
		(*N_site_lis) = NULL;
	}

	uint64_t i = 0;
	uint64_t N_site_i = 1;
	uint64_t dest_i = 0;
	uint8_t tmp = 0;
	uint8_t c = 0;

	while (i + 4 <= src_l)
	{
		tmp = 0;

		COMPRESS_BASE;
		tmp = tmp | (c<<6);

		COMPRESS_BASE;
		tmp = tmp | (c<<4);

		COMPRESS_BASE;
		tmp = tmp | (c<<2);

		COMPRESS_BASE;
		tmp = tmp | c;

		dest[dest_i] = tmp;

		dest_i++;
	}

	//at most 3 bases here
	uint64_t shift = 6;
	if (i < src_l)
	{
		tmp = 0;

		while (i < src_l)
		{
			COMPRESS_BASE;
			tmp = tmp | (c << shift);
			shift = shift -2;
		}
		
		dest[dest_i] = tmp;
		dest_i++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq (%rcx), %rdi
callq 0x2220
testq %r13, %r13
je 0x33f31
leaq 0x8(,%r13,8), %rdi
callq 0x2280
movq %rax, (%rbx)
movq %r13, (%rax)
jmp 0x33f38
movq $0x0, (%rbx)
movl $0x1, %eax
cmpq $0x4, %r14
jae 0x33f4c
xorl %edi, %edi
xorl %edx, %edx
jmp 0x3400c
movl $0x2, %ecx
xorl %edx, %edx
leaq 0x2566d6(%rip), %rsi    # 0x28a630
movzbl -0x2(%r12,%rcx), %edi
movb (%rdi,%rsi), %dil
cmpb $0x4, %dil
jb 0x33f7a
leaq -0x2(%rcx), %rdi
movq (%rbx), %r8
movq %rdi, (%r8,%rax,8)
incq %rax
xorl %edi, %edi
movzbl -0x1(%r12,%rcx), %r8d
movb (%r8,%rsi), %r8b
cmpb $0x4, %r8b
jb 0x33f9b
leaq -0x1(%rcx), %r8
movq (%rbx), %r9
movq %r8, (%r9,%rax,8)
incq %rax
xorl %r8d, %r8d
movzbl (%r12,%rcx), %r9d
movb (%r9,%rsi), %r9b
cmpb $0x4, %r9b
jb 0x33fb7
movq (%rbx), %r9
movq %rcx, (%r9,%rax,8)
incq %rax
xorl %r9d, %r9d
movzbl 0x1(%r12,%rcx), %r10d
movb (%r10,%rsi), %r10b
cmpb $0x4, %r10b
jb 0x33fd8
leaq 0x1(%rcx), %r10
movq (%rbx), %r11
movq %r10, (%r11,%rax,8)
incq %rax
xorl %r10d, %r10d
shlb $0x6, %dil
shlb $0x4, %r8b
orb %dil, %r8b
shlb $0x2, %r9b
orb %r8b, %r9b
orb %r10b, %r9b
movb %r9b, (%r15,%rdx)
incq %rdx
leaq 0x4(%rcx), %rdi
addq $0x6, %rcx
cmpq %r14, %rcx
movq %rdi, %rcx
jbe 0x33f5a
addq $-0x2, %rdi
cmpq %r14, %rdi
jae 0x34054
movl $0x6, %ecx
xorl %esi, %esi
leaq 0x256611(%rip), %r8     # 0x28a630
movzbl (%r12,%rdi), %r9d
movb (%r9,%r8), %r9b
cmpb $0x4, %r9b
jb 0x3403b
movq (%rbx), %r9
movq %rdi, (%r9,%rax,8)
incq %rax
xorl %r9d, %r9d
movzbl %r9b, %r9d
shll %cl, %r9d
incq %rdi
orb %r9b, %sil
addl $-0x2, %ecx
cmpq %rdi, %r14
jne 0x3401f
movb %sil, (%r15,%rdx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: convert_qual(unsigned char*, char*, unsigned long, unsigned long, unsigned long, unsigned long)
void convert_qual(uint8_t* dest, char* src, uint64_t src_l, uint64_t bitu, uint64_t rev, uint64_t sc_off)
{
	uint64_t i = 0; uint8_t c = 0, sc;
	// fprintf(stderr, "\n[M::%s]\n", __func__);
	for (i = 0; i < src_l; i++) {
		for (c = 0, sc = ((uint8_t)src[i]) - sc_off; (c < bitu) && (sc_tb[c] < sc); c++);
		if(c >= bitu) c = bitu - 1;
		dest[(rev?(src_l-i-1):(i))] = c;
		// fprintf(stderr, "%u->%u\n", sc, c);
	}
}

// Assembly:
testq %rdx, %rdx
je 0x340f2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rcx, %rcx
setne %al
leal -0x1(%rcx), %ebx
xorl %r10d, %r10d
leaq 0x1f0a9c(%rip), %r11    # 0x224b20
movzbl %bl, %ebx
testq %rcx, %rcx
je 0x340bc
movb (%rsi,%r10), %bpl
subb %r9b, %bpl
cmpb $0xb, %bpl
jb 0x340bc
movzbl %bpl, %r15d
movb $0x1, %r12b
movl %r12d, %r14d
movzbl %r12b, %r13d
cmpq %rcx, %r13
setb %bpl
jae 0x340c1
leal 0x1(%r14), %r12d
cmpq %r15, (%r11,%r13,8)
jb 0x340a0
jmp 0x340c1
xorl %r14d, %r14d
movl %eax, %ebp
movzbl %r14b, %r14d
testb %bpl, %bpl
cmovel %ebx, %r14d
movq %r10, %r15
notq %r15
addq %rdx, %r15
testq %r8, %r8
cmoveq %r10, %r15
movb %r14b, (%rdi,%r15)
incq %r10
cmpq %rdx, %r10
jne 0x34087
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdx, %r8
xorl %r9d, %r9d
movl $0x8, %eax
xorl %edx, %edx
divq %rcx
movl $0x0, %edx
cmpq %r8, %rax
ja 0x3414d
xorl %edx, %edx
xorl %r9d, %r9d
cmpq $0x8, %rcx
jbe 0x3411e
xorl %r10d, %r10d
jmp 0x3413d
leaq (%rsi,%r9), %r11
xorl %r10d, %r10d
xorl %ebx, %ebx
movzbl %r10b, %r10d
shll %cl, %r10d
orb (%r11,%rbx), %r10b
incq %rbx
cmpq %rax, %rbx
jb 0x34127
addq %rbx, %r9
movb %r10b, (%rdi,%rdx)
incq %rdx
leaq (%r9,%rax), %r10
cmpq %r8, %r10
jbe 0x34113
cmpq %r8, %r9
jae 0x3417a
xorl %eax, %eax
movq %r9, %r10
movzbl %al, %eax
shll %cl, %eax
orb (%rsi,%r10), %al
incq %r10
cmpq %r10, %r8
jne 0x34157
movzbl %al, %eax
subl %r8d, %r9d
imull %r9d, %ecx
addb $0x8, %cl
shll %cl, %eax
movb %al, (%rdi,%rdx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: ha_compress_qual(unsigned char*, char*, unsigned long, unsigned long, unsigned long)
void ha_compress_qual(uint8_t* dest, char* src, uint64_t src_l, uint64_t bitn, uint64_t sc_off)
{

	uint64_t i = 0, k, bit_r = 8/bitn, dest_i = 0, bitu = (1<<bitn);
	uint8_t tmp = 0, c = 0, sc;

	for (i = 0; i + bit_r <= src_l;) {
		for (k = tmp = 0; k < bit_r; k++) {
			for (c = 0, sc = ((uint8_t)src[i]) - sc_off; (c < bitu) && (sc_tb[c] < sc); c++);
			if(c >= bitu) c = bitu - 1;
			tmp <<= bitn; tmp |= c; i++;
		}
		dest[dest_i++] = tmp;
	}

	if(i < src_l) {
		for (k = tmp = 0; i < src_l; k++) {
			for (c = 0, sc = ((uint8_t)src[i]) - sc_off; (c < bitu) && (sc_tb[c] < sc); c++);
			if(c >= bitu) c = bitu - 1;
			tmp <<= bitn; tmp |= c; i++;
		}
		 
		dest[dest_i++] = (tmp<<(8-(bitn*k)));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rdi, -0x10(%rsp)
xorl %edi, %edi
movl $0x8, %eax
xorl %edx, %edx
divq %rcx
movl $0x1, %edx
shll %cl, %edx
movslq %edx, %rdx
movl $0x0, %r11d
cmpq %r13, %rax
ja 0x3423c
leal -0x1(%rdx), %ebx
xorl %r11d, %r11d
leaq 0x1f0960(%rip), %r14    # 0x224b20
movzbl %bl, %ebp
xorl %edi, %edi
movq %r13, -0x8(%rsp)
xorl %r15d, %r15d
cmpq $0x8, %rcx
ja 0x34222
xorl %r12d, %r12d
movb (%rsi,%r11), %r9b
subb %r8b, %r9b
cmpb $0xb, %r9b
jb 0x34205
movzbl %r9b, %r9d
xorl %r10d, %r10d
incb %r10b
movzbl %r10b, %r13d
cmpq %rdx, %r13
jae 0x3420a
cmpq %r9, (%r14,%r13,8)
jb 0x341ea
cmpq %rdx, %r13
cmovael %ebp, %r13d
jmp 0x3420d
xorl %r13d, %r13d
jmp 0x3420d
movl %ebx, %r13d
movzbl %r15b, %r15d
shll %cl, %r15d
orb %r13b, %r15b
incq %r11
incq %r12
cmpq %rax, %r12
jb 0x341d6
movq -0x10(%rsp), %r9
movb %r15b, (%r9,%rdi)
incq %rdi
leaq (%r11,%rax), %r9
movq -0x8(%rsp), %r13
cmpq %r13, %r9
jbe 0x341ca
cmpq %r13, %r11
jae 0x342b1
leal -0x1(%rdx), %ebx
xorl %eax, %eax
leaq 0x1f08d3(%rip), %r14    # 0x224b20
movzbl %bl, %ebp
movq %r11, %r15
movb (%rsi,%r15), %r9b
subb %r8b, %r9b
cmpb $0xb, %r9b
jb 0x34282
movzbl %r9b, %r9d
xorl %r10d, %r10d
incb %r10b
movzbl %r10b, %r12d
cmpq %rdx, %r12
jae 0x34287
cmpq %r9, (%r14,%r12,8)
jb 0x34267
cmpq %rdx, %r12
cmovael %ebp, %r12d
jmp 0x3428a
xorl %r12d, %r12d
jmp 0x3428a
movl %ebx, %r12d
movzbl %al, %eax
shll %cl, %eax
orb %r12b, %al
incq %r15
cmpq %r13, %r15
jne 0x34253
subl %r13d, %r11d
movzbl %al, %eax
imull %r11d, %ecx
addb $0x8, %cl
shll %cl, %eax
movq -0x10(%rsp), %rcx
movb %al, (%rcx,%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rax
shrq %rax
cmpq $0x2, %rsi
jb 0x3462d
movq %rax, %rcx
negq %rcx
leaq (%rsi,%rdi), %rdx
decq %rdx
xorl %r8d, %r8d
leaq 0x25603a(%rip), %r9     # 0x28a630
leaq 0x256138(%rip), %r10    # 0x28a735
movq %rdi, %r11
movzbl (%rdx,%r8), %ebx
movzbl (%r11), %r14d
movzbl (%r14,%r9), %r14d
movb (%r14,%r10), %bpl
movb %bpl, (%rdx,%r8)
movzbl (%rbx,%r9), %ebx
movb (%rbx,%r10), %bl
movb %bl, (%r11)
decq %r8
incq %r11
cmpq %r8, %rcx
jne 0x34600
testb $0x1, %sil
je 0x3464f
movzbl (%rdi,%rax), %ecx
leaq 0x255ff2(%rip), %rdx    # 0x28a630
movzbl (%rcx,%rdx), %ecx
leaq 0x2560ec(%rip), %rdx    # 0x28a735
movb (%rcx,%rdx), %cl
movb %cl, (%rdi,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %rcx, %rdi
callq 0x2090
movq %rax, %r13
testq %rbx, %rbx
je 0x34694
leaq 0x1f00c6(%rip), %rsi    # 0x224755
movq %rbx, %rdi
jmp 0x346a5
movq 0x25591d(%rip), %rax    # 0x289fb8
movq (%rax), %rdi
leaq 0x1f00b0(%rip), %rsi    # 0x224755
movq %rbp, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x22b0
testq %r13, %r13
je 0x34744
testq %r15, %r15
setne 0x7(%rsp)
leal -0x1(%r15), %eax
leaq 0x1f0452(%rip), %r12    # 0x224b20
movzbl %al, %ebp
xorl %r14d, %r14d
testq %r15, %r15
je 0x34709
movq 0x8(%rsp), %rax
movb (%rax,%r14), %al
subb 0x10(%rsp), %al
cmpb $0xb, %al
jb 0x34709
movzbl %al, %edx
movb $0x1, %sil
movl %esi, %eax
movzbl %sil, %edi
cmpq %r15, %rdi
setb %cl
jae 0x3470f
leal 0x1(%rax), %esi
cmpq %rdx, (%r12,%rdi,8)
jb 0x346f0
jmp 0x3470f
xorl %eax, %eax
movb 0x7(%rsp), %cl
movzbl %al, %eax
testb %cl, %cl
cmovel %ebp, %eax
movzbl %al, %edx
testq %rbx, %rbx
je 0x34724
movq %rbx, %rdi
jmp 0x3472e
movq 0x25588d(%rip), %rax    # 0x289fb8
movq (%rax), %rdi
leaq 0x1f66c3(%rip), %rsi    # 0x22adf8
xorl %eax, %eax
callq 0x22b0
incq %r14
cmpq %r13, %r14
jne 0x346d4
testq %rbx, %rbx
je 0x34753
movl $0xa, %edi
movq %rbx, %rsi
jmp 0x34762
movq 0x25585e(%rip), %rax    # 0x289fb8
movq (%rax), %rsi
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x347b3
movl $0x10, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2220
movq 0x18(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2220
incq %r15
addq $0x20, %r14
cmpq 0x10(%rbx), %r15
jb 0x3478d
movq (%rbx), %rdi
callq 0x2220
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x20(%rbx), %rdi
callq 0x2190
movq 0x28(%rbx), %rdi
callq 0x2190
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
je 0x34853
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x48(%rbx), %rax
movq 0x38(%rax,%r14), %rdi
callq 0x2220
movq 0x48(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
callq 0x2220
movq 0x48(%rbx), %rax
movq 0x30(%rax,%r14), %rdi
callq 0x2220
incq %r15
addq $0x58, %r14
cmpq 0x50(%rbx), %r15
jb 0x3481c
movq 0x48(%rbx), %rdi
callq 0x2220
cmpq $0x0, (%rbx)
je 0x34881
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2220
incq %r15
addq $0x10, %r14
cmpq (%rbx), %r15
jb 0x34868
movq 0x10(%rbx), %rdi
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: push_subblock_original_bases(char*, all_ul_t*, ul_vec_t*, unsigned int, unsigned int, unsigned int)
void push_subblock_original_bases(char* str, all_ul_t *x, ul_vec_t *p, uint32_t s, uint32_t e, uint32_t subLen)//for debug
{
	uc_block_t *b = NULL;
	uint32_t qs = s, qe = e;
	while (qs < e) {
		qe = qs + subLen; if(qe > e) qe = e;
		kv_pushp(uc_block_t, p->bb, &b);
		b->hid = (uint32_t)-1; b->rev = 0;
		b->qs = qs; b->qe = qe;
		b->ts = p->r_base.n; b->te = b->ts + B4L(b->qe - b->qs);
		kv_resize(uint8_t, p->r_base, b->te); p->r_base.n = b->te;
		ha_encode_base(p->r_base.a+b->ts, str+b->qs, b->qe-b->qs, &(p->N_site), b->qs);

		qs = qe;
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
cmpl %r8d, %ecx
jae 0x34cc2
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r14
leaq 0x38(%rdx), %rax
movq %rax, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq 0x20(%rsp), %rax
leal (%rax,%r13), %ebx
cmpl %ebp, %ebx
cmovbl %ebx, %ebp
movq 0x28(%r14), %rax
cmpq %rax, 0x20(%r14)
jne 0x34be9
leaq (%rax,%rax), %rcx
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rcx
movq %rcx, 0x28(%r14)
movq 0x30(%r14), %rdi
shlq $0x2, %rcx
leaq (%rcx,%rcx,8), %rsi
callq 0x2370
movq %rax, 0x30(%r14)
movq 0x20(%r14), %rax
movq 0x30(%r14), %r12
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r14)
leaq (%rax,%rax,8), %r15
movl $0xffffffff, (%r12,%r15,4) # imm = 0xFFFFFFFF
andb $-0x21, 0x20(%r12,%r15,4)
movl %r13d, 0x4(%r12,%r15,4)
movl %ebp, 0x8(%r12,%r15,4)
movl (%r14), %ecx
movl %ecx, 0xc(%r12,%r15,4)
movl %ebp, %edx
subl %r13d, %edx
movl %edx, %eax
shrl $0x2, %eax
andl $0x3, %edx
cmpl $0x1, %edx
sbbl $-0x1, %eax
addl %ecx, %eax
movl %eax, 0x10(%r12,%r15,4)
cmpq %rax, 0x8(%r14)
jae 0x34c85
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%r14)
movq 0x10(%r14), %rdi
callq 0x2370
movq %rax, 0x10(%r14)
leaq (%r12,%r15,4), %rax
movl 0x10(%rax), %ecx
movq %rcx, (%r14)
movl 0xc(%rax), %edi
addq 0x10(%r14), %rdi
movl 0x4(%rax), %r8d
movl 0x8(%rax), %edx
movq 0x18(%rsp), %rax
leaq (%rax,%r8), %rsi
subl %r8d, %edx
movq 0x10(%rsp), %rcx
callq 0x348a1
movl %ebp, %r13d
movl 0xc(%rsp), %ebp
cmpl %ebp, %ebx
jb 0x34ba8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: debug_append_ul_t(ul_ov_t*, long, ul_vec_t*)
void debug_append_ul_t(ul_ov_t *o, int64_t on, ul_vec_t *p)
{
	int64_t k, l = 0;
    uint32_t sp = (uint32_t)-1, ep = (uint32_t)-1, qss, qee, m;
    for (k = on-1; k >= 0; k--) {
        if(sp == (uint32_t)-1 || o[k].qe <= sp) {
            if(sp != (uint32_t)-1) l += ep - sp;

			if(sp == (uint32_t)-1) qss = o[k].qe, qee = p->rlen;
			else qss = o[k].qe, qee = sp;
			if(qee > qss) {
				for (m = 0; m < p->bb.n; m++) {
					if(qss == (p->bb.a[m].qs+((p->bb.a[m].hid>>15)&(0x7fffU))) && 
							qee == (p->bb.a[m].qe-(p->bb.a[m].hid&(0x7fffU)))) {
						break;
					}
				}
				if(m >= p->bb.n) fprintf(stderr, "ERROR\n");
			}

            sp = o[k].qs;
            ep = o[k].qe;
        } else {
            sp = MIN(sp, o[k].qs);
        }
    }
    if(sp != (uint32_t)-1) l += ep - sp;

	if(sp == (uint32_t)-1) qss = 0, qee = p->rlen;
	else qss = 0, qee = sp;
	if(qee > qss) {
		for (m = 0; m < p->bb.n; m++) {
			if(qss == (p->bb.a[m].qs+((p->bb.a[m].hid>>15)&(0x7fffU))) && 
					qee == (p->bb.a[m].qe-(p->bb.a[m].hid&(0x7fffU)))) {
				break;
			}
		}
		if(m >= p->bb.n) fprintf(stderr, "ERROR\n");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
testq %rsi, %rsi
jle 0x351ef
movq %rsi, %r15
movq %rdi, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x1(%r15), %r12
cmpl $-0x1, %eax
je 0x35159
leaq (%r12,%r12,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %r12, %rcx
cmpl %eax, 0x8(%r14,%rcx)
jbe 0x35154
addq %r14, %rcx
movl 0x4(%rcx), %ecx
cmpl %ecx, %eax
cmovael %ecx, %eax
jmp 0x351e0
cmpl $-0x1, %eax
jne 0x3515c
movl 0x18(%rbx), %eax
leaq (%r12,%r12,8), %rcx
leaq (%rcx,%rcx,2), %r13
addq %r12, %r13
movl 0x8(%r14,%r13), %ecx
cmpl %ecx, %eax
jbe 0x351db
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
setne %r8b
je 0x351d6
movq 0x30(%rbx), %rsi
movl $0x1, %edi
xorl %r9d, %r9d
leaq (%r9,%r9,8), %r10
movl (%rsi,%r10,4), %r9d
movl %r9d, %r11d
shrl $0xf, %r11d
andl $0x7fff, %r11d          # imm = 0x7FFF
addl 0x4(%rsi,%r10,4), %r11d
cmpl %r11d, %ecx
jne 0x351c0
leaq (%rsi,%r10,4), %r10
movl 0x8(%r10), %r10d
andl $0x7fff, %r9d           # imm = 0x7FFF
subl %r9d, %r10d
cmpl %r10d, %eax
je 0x351d0
movl %edi, %r9d
incl %edi
cmpq %r9, %rdx
seta %r8b
ja 0x35189
jmp 0x351d6
testb $0x1, %r8b
jne 0x351db
callq 0x3a87
movl 0x4(%r14,%r13), %eax
cmpq $0x1, %r15
movq %r12, %r15
jg 0x35129
jmp 0x351f4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
jne 0x351fc
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0x35268
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
setne %dil
je 0x35263
movq 0x30(%rbx), %rdx
movl $0x1, %esi
xorl %r8d, %r8d
leaq (%r8,%r8,8), %r9
movl (%rdx,%r9,4), %r8d
movl %r8d, %r10d
shrl $0xf, %r10d
andl $0x7fff, %r10d          # imm = 0x7FFF
addl 0x4(%rdx,%r9,4), %r10d
jne 0x3524d
leaq (%rdx,%r9,4), %r9
movl 0x8(%r9), %r9d
andl $0x7fff, %r8d           # imm = 0x7FFF
subl %r8d, %r9d
cmpl %r9d, %eax
je 0x3525d
movl %esi, %r8d
incl %esi
cmpq %r8, %rcx
seta %dil
ja 0x35219
jmp 0x35263
testb $0x1, %dil
jne 0x35268
callq 0x3aa3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: produce_u_seq(char*, ma_utg_t*, UC_Read*)
void produce_u_seq(char* r, ma_utg_t *u, UC_Read *buf)
{
	if(u->m == 0 || u->n == 0) return;
	uint32_t j, k, l = 0;
    uint32_t rId, ori, start, eLen, readLen;
	char *readS = NULL;
	memset(r, 'N', u->len);
	for (j = 0; j < u->n; ++j) {
		rId = u->a[j]>>33;
		///uId = i;
		ori = u->a[j]>>32&1;
		start = l;
		eLen = (uint32_t)u->a[j];
		l += eLen;

		if(eLen == 0) continue;
		recover_UC_Read(buf, &R_INF, rId);

		readS = buf->seq;
		readLen = Get_READ_LENGTH(R_INF, rId);
		
		if (!ori) // forward strand
		{
			for (k = 0; k < eLen; k++)
			{
				r[start + k] = readS[k];
			}
		}
		else
		{
			for (k = 0; k < eLen; k++)
			{
				uint8_t c = (uint8_t)readS[readLen - 1 - k];
				r[start + k] = c >= 128? 'N' : RC_CHAR(c);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
cmpl $0x0, 0xc(%rsi)
je 0x376d3
movq %rsi, %rbx
cmpl $0x0, 0x10(%rsi)
je 0x376d3
movq %rdi, %r15
movl (%rbx), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl $0x4e, %esi
callq 0x20e0
cmpl $0x0, 0x10(%rbx)
je 0x376d3
xorl %ebp, %ebp
leaq 0x253c28(%rip), %rsi    # 0x28b230
xorl %r14d, %r14d
movq %rbx, 0x8(%rsp)
movq 0x18(%rbx), %rax
movq (%rax,%rbp,8), %r12
testl %r12d, %r12d
je 0x376c1
movq %r12, %r13
shrq $0x21, %r13
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
callq 0x33cf8
movq (%rbx), %rax
btq $0x20, %r12
movl %r12d, %ecx
jb 0x3766d
movl %r14d, %edx
xorl %r9d, %r9d
movq 0x8(%rsp), %rbx
leaq 0x253bd9(%rip), %rsi    # 0x28b230
movb (%rax,%r9), %dil
leal (%rdx,%r9), %r8d
movb %dil, (%r15,%r8)
incq %r9
cmpq %r9, %rcx
jne 0x37657
jmp 0x376c1
leaq 0x253bbc(%rip), %rsi    # 0x28b230
movq 0x18(%rsi), %rdx
movq (%rdx,%r13,8), %rdx
decq %rdx
movl %r14d, %r9d
movq 0x8(%rsp), %rbx
leaq 0x252fa2(%rip), %r10    # 0x28a630
leaq 0x2530a0(%rip), %r11    # 0x28a735
movl %edx, %edi
movsbq (%rax,%rdi), %rdi
testq %rdi, %rdi
js 0x376ac
movzbl (%rdi,%r10), %edi
movb (%rdi,%r11), %dil
jmp 0x376af
movb $0x4e, %dil
movl %r9d, %r8d
movb %dil, (%r15,%r8)
decq %rdx
incl %r9d
decq %rcx
jne 0x37695
addl %r12d, %r14d
incq %rbp
movl 0x10(%rbx), %eax
cmpq %rax, %rbp
jb 0x37610
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Process_Read.cpp
// Function: write_compress_base_disk(_IO_FILE*, unsigned long, char*, unsigned int, ul_vec_t*)
void write_compress_base_disk(FILE *fp, uint64_t ul_rid, char *str, uint32_t len, ul_vec_t *buf)
{
	buf->N_site.n = buf->bb.n = 0; buf->rlen = len; buf->r_base.n = B4L(len); 
	kv_resize(uint8_t, buf->r_base, buf->r_base.n); 
	ha_encode_base(buf->r_base.a, str, len, &(buf->N_site), 0);

	fwrite(&ul_rid, sizeof(ul_rid), 1, fp);
	fwrite(&len, sizeof(len), 1, fp);
	fwrite(&buf->N_site.n, sizeof(buf->N_site.n), 1, fp);
	fwrite(buf->N_site.a, sizeof((*buf->N_site.a)), buf->N_site.n, fp);
	fwrite(buf->r_base.a, sizeof((*buf->r_base.a)), buf->r_base.n, fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%r8)
leaq 0x40(%r8), %r15
movq %rax, 0x40(%r8)
movl %ecx, %eax
shrl $0x2, %eax
andl $0x3, %ecx
cmpl $0x1, %ecx
sbbl $-0x1, %eax
movl %ebp, 0x18(%r8)
movq %rax, (%r8)
cmpq %rax, 0x8(%r8)
jae 0x385ab
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%r14)
movq 0x10(%r14), %rdi
callq 0x2370
movq %rax, 0x10(%r14)
leaq 0x38(%r14), %rcx
movq 0x10(%r14), %rdi
movl %ebp, %edx
movq %r12, %rsi
xorl %r8d, %r8d
callq 0x348a1
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
leaq 0x4(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2410
movq 0x38(%r14), %rdi
movq 0x40(%r14), %rdx
movl $0x4, %esi
movq %rbx, %rcx
callq 0x2410
movq (%r14), %rdx
movq 0x10(%r14), %rdi
movl $0x1, %esi
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2410
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x388d9
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x388c5
movl $0x1, %ebp
xorl %eax, %eax
movq (%rbx), %rcx
imulq $0x58, %rax, %r14
movq 0x38(%rcx,%r14), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x10(%rax,%r14), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x30(%rax,%r14), %rdi
callq 0x2220
movl %ebp, %eax
incl %ebp
cmpq %rax, 0x10(%rbx)
ja 0x38890
movq (%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2220
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Assembly.cpp
// Function: ha_ovec_buf_init(void*, int, int, int)
ha_ovec_buf_t *ha_ovec_buf_init(void *km, int is_final, int save_ov, int is_ug)
{
	ha_ovec_buf_t *b;
	KCALLOC(km, b, 1);
	b->is_final = !!is_final, b->save_ov = !!save_ov;
	init_UC_Read(&b->self_read);//set 0
	init_UC_Read(&b->ovlp_read);//set 0
	init_Candidates_list(&b->clist);//set 0
    memset(&b->olist, 0, sizeof(overlap_region_alloc));
    memset(&b->olist_hp, 0, sizeof(overlap_region_alloc));
    // init_overlap_region_alloc(&b->olist);
    // init_overlap_region_alloc(&b->olist_hp);
    init_fake_cigar(&(b->tmp_region.f_cigar));//set 0
    kv_init(b->b_buf.a);//set 0
    kv_init(b->r_buf.a);//set 0
    kv_init(b->k_flag.a);//set 0
    kv_init(b->sp);//set 0
	if(!is_ug) b->ab = ha_abuf_init_buf(km);
    else b->abl = ha_abufl_init_buf(km);
	if (!b->is_final) {
        init_Cigar_record_buf(&b->cigar1, km);
		// init_Graph(&b->POA_Graph);
		// init_Graph(&b->DAGCon);
		init_Correct_dumy_buf(&b->correct, km);//set 0
        InitHaplotypeEvdience_buf(&b->hap, km);
		init_Round2_alignment_buf(&b->round2, km);
	}
	return b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movl $0x1, %esi
movl $0x12340, %edx          # imm = 0x12340
callq 0x1e3590
movq %rax, %r14
xorl %eax, %eax
testl %r12d, %r12d
setne %al
movl %eax, (%r14)
xorl %eax, %eax
testl %r15d, %r15d
setne %al
movl %eax, 0x4(%r14)
leaq 0x8(%r14), %rdi
callq 0x3372c
leaq 0x28(%r14), %rdi
callq 0x3372c
leaq 0x48(%r14), %rdi
callq 0x3fcfd
leaq 0x121d8(%r14), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0xd0(%r14)
movaps %xmm0, 0xc0(%r14)
movaps %xmm0, 0xb0(%r14)
movaps %xmm0, 0xa0(%r14)
callq 0x3db21
xorl %eax, %eax
movq %rax, 0x12150(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x12140(%r14)
movaps %xmm0, 0x12160(%r14)
movq %rax, 0x12170(%r14)
movaps %xmm0, 0x12180(%r14)
movq %rax, 0x12190(%r14)
movaps %xmm0, 0x12250(%r14)
movq %rax, 0x12260(%r14)
movq %rbx, %rdi
testl %ebp, %ebp
je 0x391d4
callq 0x122a71
movq %rax, 0xe8(%r14)
jmp 0x391e0
callq 0x122979
movq %rax, 0xe0(%r14)
cmpl $0x0, (%r14)
jne 0x39234
leaq 0x108(%r14), %rdi
movq %rbx, %rsi
callq 0x4817f
leaq 0x2c0(%r14), %rdi
movq %rbx, %rsi
callq 0x48173
leaq 0x9040(%r14), %rdi
movl $0x2e8, %edx            # imm = 0x2E8
xorl %esi, %esi
callq 0x20e0
movq $-0x1, 0x9300(%r14)
movq %r14, %rdi
addq $0x9330, %rdi           # imm = 0x9330
movq %rbx, %rsi
callq 0x48129
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x33667
leaq 0x28(%rbx), %rdi
callq 0x33667
leaq 0x48(%rbx), %rdi
callq 0x3fd27
leaq 0xa0(%rbx), %rdi
callq 0x3db85
leaq 0xc0(%rbx), %rdi
callq 0x3db85
movq 0xe0(%rbx), %rdi
callq 0x122a2b
movq 0xe8(%rbx), %rdi
callq 0x122b23
leaq 0x121d8(%rbx), %rdi
callq 0x3dc09
movq 0x121f8(%rbx), %rdi
callq 0x2220
movq 0x12210(%rbx), %rdi
callq 0x2220
movq 0x12150(%rbx), %rdi
callq 0x2220
movq 0x12170(%rbx), %rdi
callq 0x2220
movq 0x12190(%rbx), %rdi
callq 0x2220
movq 0x12260(%rbx), %rdi
callq 0x2220
movq 0x122a8(%rbx), %rdi
callq 0x2220
movq 0x12338(%rbx), %rdi
callq 0x2220
movq 0x12320(%rbx), %rdi
callq 0x2220
cmpl $0x0, (%rbx)
jne 0x396e1
leaq 0x108(%rbx), %rdi
callq 0x481f1
leaq 0x148(%rbx), %rdi
callq 0x4530e
leaq 0x200(%rbx), %rdi
callq 0x4530e
leaq 0x2c0(%rbx), %rdi
callq 0x481db
leaq 0x9040(%rbx), %rdi
callq 0x3cbda
leaq 0x9330(%rbx), %rdi
callq 0x48195
movq %rbx, %rdi
popq %rbx
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x58(%rdi), %rax
movq 0x88(%rdi), %rcx
movq %rax, %rdx
shlq $0x7, %rdx
leaq (%rdx,%rcx,8), %rcx
addq $0xb8, %rcx
testq %rax, %rax
jle 0x39983
movq 0x18(%rdi), %rdx
addq $0x68, %rdx
movq -0x20(%rdx), %rsi
addq -0x40(%rdx), %rsi
addq (%rdx), %rsi
imulq $0x38, %rsi, %rsi
addq %rsi, %rcx
subq $-0x80, %rdx
decq %rax
jne 0x39968
movq 0x30(%rdi), %rax
leaq (%rax,%rax,8), %rax
addq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x220(%rdi), %rcx
testq %rcx, %rcx
je 0x399cd
movq 0x218(%rdi), %rdx
addq $0x8, %rdx
xorl %eax, %eax
movl $0x1, %esi
cmpl $0x1, 0x14(%rdx)
jne 0x399bf
cmpl $0x2, (%rdx)
jb 0x399bf
cmpl $0x2, 0x4(%rdx)
sbbl $-0x1, %eax
movl %esi, %edi
addq $0x28, %rdx
incl %esi
cmpq %rdi, %rcx
ja 0x399ad
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rdi
callq 0x3372c
leaq 0x250d6c(%rip), %rax    # 0x28a758
movq 0x10(%rax), %rbx
movq %rbx, %rdi
callq 0x2090
leaq 0x23(%rax), %rdi
callq 0x2280
movq %rax, %r14
leaq 0x1eb23f(%rip), %rsi    # 0x224c4a
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x2029df(%rip), %rsi    # 0x23c3fe
movq %r14, %rdi
callq 0x2210
movq %rax, %rbx
movq %r14, %rdi
callq 0x2220
cmpq $0x0, 0x251846(%rip)    # 0x28b280
jle 0x39ad5
xorl %r14d, %r14d
leaq 0x2517e6(%rip), %r15    # 0x28b230
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x33cf8
movl $0x3e, %edi
movq %rbx, %rsi
callq 0x2270
movq 0x2517ff(%rip), %rax    # 0x28b270
movq (%rax,%r14,8), %rcx
movq 0x8(%rax,%r14,8), %rdx
movq 0x2517b7(%rip), %rdi    # 0x28b238
addq %rcx, %rdi
incq %r14
subq %rcx, %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x2410
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2270
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x2410
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2270
cmpq 0x2517b1(%rip), %r14    # 0x28b280
jl 0x39a4f
leaq 0x8(%rsp), %rdi
callq 0x33667
movq %rbx, %rdi
callq 0x2190
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Assembly.cpp
// Function: Output_corrected_fastq()
void Output_corrected_fastq()
{
    long long i; uint64_t k;
    UC_Read g_read; asg8_v dv;
    init_UC_Read(&g_read); kv_init(dv);
    char* gfa_name = (char*)malloc(strlen(asm_opt.output_file_name)+35);
    sprintf(gfa_name, "%s.ec.fq", asm_opt.output_file_name);
    FILE* fp = 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);
        fprintf(fp, "@%.*s\n", (int32_t)Get_NAME_LENGTH(R_INF, i), Get_NAME(R_INF, i));
        fprintf(fp, "%.*s\n", (int32_t)g_read.length, g_read.seq);        
        fprintf(fp, "+\n");
        retrive_bqual(&dv, NULL, i, -1, -1, 0, sc_bn);
        for (k = 0; k < dv.n; k++) fprintf(fp, "%c", (char)(sc_tb[dv.a[k]] + 33 - 1));
        fprintf(fp, "\n");
    }
    destory_UC_Read(&g_read); kv_destroy(dv);
    fclose(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x28(%rsp), %rdi
callq 0x3372c
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x250c35(%rip), %rax    # 0x28a758
movq 0x10(%rax), %rbx
movq %rbx, %rdi
callq 0x2090
leaq 0x23(%rax), %rdi
callq 0x2280
movq %rax, %r14
leaq 0x1eb111(%rip), %rsi    # 0x224c53
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x2028a8(%rip), %rsi    # 0x23c3fe
movq %r14, %rdi
callq 0x2210
movq %rax, %rbx
movq %r14, %rdi
callq 0x2220
cmpq $0x0, 0x25170f(%rip)    # 0x28b280
jle 0x39c6d
leaq 0x1eabde(%rip), %rbp    # 0x22475c
leaq 0x10(%rsp), %r14
leaq 0x1eaff6(%rip), %r12    # 0x224b80
xorl %r15d, %r15d
leaq 0x28(%rsp), %rdi
leaq 0x251697(%rip), %rsi    # 0x28b230
movq %r15, %rdx
callq 0x33cf8
movq 0x2516c8(%rip), %rax    # 0x28b270
movl 0x8(%rax,%r15,8), %edx
movq (%rax,%r15,8), %rcx
subl %ecx, %edx
addq 0x25167e(%rip), %rcx    # 0x28b238
movq %rbx, %rdi
leaq 0x1eb098(%rip), %rsi    # 0x224c5c
xorl %eax, %eax
callq 0x22b0
movl 0x30(%rsp), %edx
movq 0x28(%rsp), %rcx
movq %rbx, %rdi
leaq 0x2002d8(%rip), %rsi    # 0x239eb6
xorl %eax, %eax
callq 0x22b0
movl $0x2, %esi
movl $0x1, %edx
movq %rbp, %rdi
movq %rbx, %rcx
callq 0x2410
movq $0x2, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq $-0x1, %rcx
movq $-0x1, %r8
xorl %r9d, %r9d
callq 0x342bc
cmpq $0x0, 0x10(%rsp)
je 0x39c50
xorl %r13d, %r13d
movq 0x20(%rsp), %rax
movzbl (%rax,%r13), %eax
movb (%r12,%rax,8), %al
addb $0x20, %al
movsbl %al, %edi
movq %rbx, %rsi
callq 0x2270
incq %r13
cmpq 0x10(%rsp), %r13
jb 0x39c2b
incq %r15
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2270
cmpq 0x251619(%rip), %r15    # 0x28b280
jl 0x39b8d
leaq 0x28(%rsp), %rdi
callq 0x33667
movq 0x20(%rsp), %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2190
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x2515d9(%rip), %rcx    # 0x28b280
testq %rcx, %rcx
jne 0x39cd3
xorl %ebx, %ebx
movq 0x25032b(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x1eafb0(%rip), %rsi    # 0x224c6f
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22b0
movl $0x1, %edi
callq 0x2250
movq 0x250306(%rip), %r12    # 0x289fe0
leaq 0x1eaf82(%rip), %r14    # 0x224c63
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x25156b(%rip), %rax    # 0x28b258
cmpb $0x0, (%rax,%r15)
jne 0x39d05
incq %r15
movq 0x251582(%rip), %rcx    # 0x28b280
cmpq %rcx, %r15
jb 0x39ce6
jmp 0x39cae
incq %rbx
movq (%r12), %rdi
movq 0x25155d(%rip), %rax    # 0x28b270
movl 0x8(%rax,%r15,8), %ecx
movq (%rax,%r15,8), %r8
subl %r8d, %ecx
addq 0x251512(%rip), %r8     # 0x28b238
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x39cf4
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2516fc(%rip), %r15    # 0x28b448
xorl %eax, %eax
movq %rax, (%r15)
leaq 0x2516e8(%rip), %r12    # 0x28b440
movq %rax, (%r12)
leaq 0x2509f5(%rip), %r14    # 0x28a758
testb $0x2, (%r14)
jne 0x39d8d
leaq 0x2509e8(%rip), %rdi    # 0x28a758
leaq 0x2514b9(%rip), %rsi    # 0x28b230
leaq 0x8(%rsp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x14025
movq %rax, (%r12)
leaq 0x25169c(%rip), %rax    # 0x28b430
movq (%rax), %rsi
leaq 0xc(%rsp), %rax
movq %rax, (%rsp)
leaq 0x251489(%rip), %r8     # 0x28b230
leaq 0x8(%rsp), %r9
movq %r14, %rdi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x1448a
movq %rax, (%r15)
xorl %r13d, %r13d
cmpq %r13, 0x18(%r14)
movl 0x7c(%r14), %edi
movq 0x2514ad(%rip), %rcx    # 0x28b280
leaq 0x796(%rip), %rax       # 0x3a570
leaq 0x32(%rip), %rsi        # 0x39e13
cmoveq %rax, %rsi
movq %rbx, %rdx
callq 0x1047b4
movq (%r12), %rdi
callq 0x114a78
movq %r13, (%r12)
movq (%r15), %rdi
callq 0x113930
movq %r13, (%r15)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0x3372c
cmpq $0x0, 0x250914(%rip)    # 0x28b2c8
je 0x3aa30
leaq 0x1ff4f9(%rip), %r12    # 0x239eb6
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %r13
cmpq $-0x1, %r13
je 0x3aa24
leaq 0x8(%rsp), %rdi
leaq 0x250857(%rip), %rsi    # 0x28b230
movq %r13, %rdx
callq 0x33cf8
movq 0x250888(%rip), %rax    # 0x28b270
movl 0x8(%rax,%r13,8), %edx
movq (%rax,%r13,8), %rcx
subl %ecx, %edx
addq 0x25083e(%rip), %rcx    # 0x28b238
movq %r15, %rdi
leaq 0x1ea2f2(%rip), %rsi    # 0x224cf6
movq %rbx, %r8
xorl %eax, %eax
callq 0x22b0
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x22b0
incq %rbp
cmpq 0x25089a(%rip), %rbp    # 0x28b2c8
jb 0x3a9bf
leaq 0x8(%rsp), %rdi
callq 0x33667
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %r15
movq %r15, (%rsp)
leaq 0x24fab4(%rip), %rbx    # 0x28a758
leaq 0x250585(%rip), %r8     # 0x28b230
leaq 0x14(%rsp), %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r9
callq 0x1448a
leaq 0x250770(%rip), %r12    # 0x28b438
movq %rax, (%r12)
movl (%r14), %esi
movl %esi, 0xd0(%rbx)
movl (%r15), %eax
movl %eax, 0xd4(%rbx)
movq %rbx, %rdi
callq 0x2f59
movslq 0x7c(%rbx), %rdi
movq 0x25058f(%rip), %rsi    # 0x28b280
callq 0x18bc94
movq (%r12), %rdi
callq 0x113930
movq $0x0, (%r12)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq