LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/CommandLines.cpp
// Function: inter_gsize(char*)
int64_t inter_gsize(char *argv)
{
    int64_t len = strlen(argv);
    double s;
    if(len <= 1) return -2;
    char t = argv[len-1];
    if(t != 'k' && t != 'K' && t != 'm' && t != 'M' && t != 'g' && t != 'G') return -2;
    char *ss=(char*)malloc(len);
    memcpy(ss, argv, len-1); ss[len-1] = '\0';
    s = atof(ss);
    free(ss);
    if(t == 'k' || t == 'K') return s*1000;
    if(t == 'm' || t == 'M') return s*1000000;
    if(t == 'g' || t == 'G') return s*1000000000;
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2090
movq %rax, %r14
movq $-0x2, %rax
cmpq $0x2, %r14
jl 0x306c2
movzbl -0x1(%rbx,%r14), %r13d
leal -0x47(%r13), %ecx
cmpl $0x26, %ecx
ja 0x306c2
movabsq $0x5100000051, %rdx     # imm = 0x5100000051
btq %rcx, %rdx
jae 0x306c2
movq %r14, %r15
decq %r15
movq %r14, %rdi
callq 0x2280
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2160
movb $0x0, -0x1(%r12,%r14)
movq %r12, %rdi
callq 0x2260
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x2220
andl $0x4f, %r13d
cmpl $0x47, %r13d
je 0x306af
cmpl $0x4d, %r13d
je 0x3069f
cmpl $0x4b, %r13d
movsd 0x8(%rsp), %xmm0
jne 0x306bd
mulsd 0x1fd98b(%rip), %xmm0   # 0x22e028
jmp 0x306bd
movsd 0x8(%rsp), %xmm0
mulsd 0x1fd95b(%rip), %xmm0   # 0x22e008
jmp 0x306bd
movsd 0x8(%rsp), %xmm0
mulsd 0x1fd963(%rip), %xmm0   # 0x22e020
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Process_Read.cpp
// Function: destory_All_reads(All_reads*)
void destory_All_reads(All_reads* r)
{
	uint64_t i = 0;
	for (i = 0; i < r->total_reads; i++) {
		if (r->N_site[i]) free(r->N_site[i]);
		if (r->read_sperate[i]) free(r->read_sperate[i]);
		if (r->paf && r->paf[i].buffer) free(r->paf[i].buffer);
		if (r->reverse_paf && r->reverse_paf[i].buffer) free(r->reverse_paf[i].buffer);
		if(r->rsc && r->rsc[i]) free(r->rsc[i]);
		///if (r->pb_regions) kv_destroy(r->pb_regions[i].a);
	}
	free(r->paf);
	free(r->reverse_paf);
	free(r->N_site);
	free(r->read_sperate);
	free(r->name);
	free(r->name_index);
	free(r->read_length);
	free(r->trio_flag);
	free(r->rsc);
	///if (r->pb_regions) free(r->pb_regions);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
je 0x31d35
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x31cce
callq 0x2220
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x31ce0
callq 0x2220
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x31cf7
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x31cf7
callq 0x2220
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x31d11
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x31d11
callq 0x2220
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x31d28
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x31d28
callq 0x2220
incq %r15
addq $0x18, %r14
cmpq 0x50(%rbx), %r15
jb 0x31cbd
movq 0x78(%rbx), %rdi
callq 0x2220
movq 0x80(%rbx), %rdi
callq 0x2220
movq (%rbx), %rdi
callq 0x2220
movq 0x10(%rbx), %rdi
callq 0x2220
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
callq 0x2220
movq 0x18(%rbx), %rdi
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Process_Read.cpp
// Function: destory_read_bin(All_reads*)
int destory_read_bin(All_reads* r)
{

	uint64_t i = 0;
	for (i = 0; i < r->total_reads; i++)
	{
		if (r->N_site[i]) free(r->N_site[i]);
		if (r->read_sperate[i]) free(r->read_sperate[i]);
		if (r->cigars[i].record) free(r->cigars[i].record);
		if (r->cigars[i].lost_base) free(r->cigars[i].lost_base);
		if (r->second_round_cigar[i].record) free(r->second_round_cigar[i].record);
		if (r->second_round_cigar[i].lost_base) free(r->second_round_cigar[i].lost_base);
	}

	free(r->N_site);
	free(r->read_length);
	free(r->read_size);
	free(r->read_sperate);
	free(r->name);
	free(r->name_index);
	free(r->trio_flag);
	free(r->cigars);
	free(r->second_round_cigar);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
je 0x32abf
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x32a56
callq 0x2220
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x32a68
callq 0x2220
movq 0x68(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x32a7e
callq 0x2220
movq 0x68(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x32a8d
callq 0x2220
movq 0x70(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x32aa3
callq 0x2220
movq 0x70(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x32ab2
callq 0x2220
incq %r15
addq $0x28, %r14
cmpq 0x50(%rbx), %r15
jb 0x32a45
movq (%rbx), %rdi
callq 0x2220
movq 0x18(%rbx), %rdi
callq 0x2220
movq 0x20(%rbx), %rdi
callq 0x2220
movq 0x10(%rbx), %rdi
callq 0x2220
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x68(%rbx), %rdi
callq 0x2220
movq 0x70(%rbx), %rdi
callq 0x2220
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Process_Read.cpp
// Function: init_aux_table()
void init_aux_table()
{
	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:
cmpb $0x0, 0x262cb9(%rip)    # 0x295a30
je 0x32d7a
retq
pushq %rbx
xorl %eax, %eax
leaq 0x2629ac(%rip), %rcx    # 0x295730
leaq 0x262ca5(%rip), %rdx    # 0x295a30
leaq 0x26289e(%rip), %rsi    # 0x295630
leaq 0x26299c(%rip), %rdi    # 0x295735
leaq 0x263090(%rip), %r8     # 0x295e30
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 0x32da0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x262bee(%rip)    # 0x295a30
je 0x32e45
retq
pushq %rbx
xorl %eax, %eax
leaq 0x2628e1(%rip), %rcx    # 0x295730
leaq 0x262bda(%rip), %rdx    # 0x295a30
leaq 0x2627d3(%rip), %rsi    # 0x295630
leaq 0x2628d1(%rip), %rdi    # 0x295735
leaq 0x262fc5(%rip), %r8     # 0x295e30
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 0x32e6b
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3341e
movq %rsi, 0x10(%r14)
movq (%r14), %rdi
callq 0x2370
movq %rax, (%r14)
testq %r12, %r12
je 0x33485
cmpq $0x0, 0x8(%r14)
jle 0x33452
xorl %eax, %eax
leaq 0x2625fd(%rip), %rcx    # 0x295a30
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 0x33433
movq (%r15), %rax
movq (%rax,%rbx,8), %rax
testq %rax, %rax
je 0x33496
cmpq $0x0, (%rax)
je 0x33496
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 0x33469
jmp 0x33496
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_O3/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), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq (%rax,%rbx,8), %r13
leaq 0x4(%rdx), %rsi
cmpq 0x10(%rdi), %rsi
jle 0x334eb
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 0x335b7
movq %rbx, (%rsp)
sarq $0x2, %rax
movb %sil, %cl
leaq (%rax,%rcx), %rbp
decq %rbp
leaq 0x262905(%rip), %rbx    # 0x295e30
testq %r12, %r12
je 0x3354f
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
testq %rbp, %rbp
js 0x3356e
movq (%r14), %rax
movzbl (%r13,%rbp), %ecx
movl (%rbx,%rcx,4), %ecx
movl %ecx, (%rax,%r12)
addq $0x4, %r12
addq $-0x1, %rbp
jb 0x33554
movq (%r15), %rax
movq (%rsp), %rsi
movq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0x335a8
cmpq $0x0, (%rax)
jle 0x335a8
xorl %ecx, %ecx
movq (%r14), %rdx
movq 0x8(%rax,%rcx,8), %rax
notq %rax
addq 0x8(%r14), %rdx
movb $0x4e, (%rax,%rdx)
movq (%r15), %rax
movq (%rax,%rsi,8), %rax
incq %rcx
cmpq (%rax), %rcx
jl 0x33586
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
movl $0x4e, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33609
leaq 0x8(,%r13,8), %rdi
callq 0x2280
movq %r13, (%rax)
jmp 0x3360b
xorl %eax, %eax
movq %rax, (%rbx)
movl $0x1, %eax
cmpq $0x4, %r14
jae 0x33622
xorl %edi, %edi
xorl %edx, %edx
jmp 0x336e2
movl $0x2, %ecx
xorl %edx, %edx
leaq 0x262000(%rip), %rsi    # 0x295630
movzbl -0x2(%r12,%rcx), %edi
movb (%rdi,%rsi), %dil
cmpb $0x4, %dil
jb 0x33650
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 0x33671
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 0x3368d
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 0x336ae
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 0x33630
addq $-0x2, %rdi
cmpq %r14, %rdi
jae 0x3372a
movl $0x6, %ecx
xorl %esi, %esi
leaq 0x261f3b(%rip), %r8     # 0x295630
movzbl (%r12,%rdi), %r9d
movb (%r9,%r8), %r9b
cmpb $0x4, %r9b
jb 0x33711
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 0x336f5
movb %sil, (%r15,%rdx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33796
pushq %r15
pushq %r14
pushq %rbx
leal -0x1(%rcx), %eax
xorl %r10d, %r10d
leaq 0x1fd3e5(%rip), %r11    # 0x230b30
movl %eax, %ebx
testq %rcx, %rcx
je 0x33775
movb (%rsi,%r10), %bl
subb %r9b, %bl
movzbl %bl, %r14d
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpq %r14, (%r11,%r15,8)
jae 0x33775
incb %bl
movzbl %bl, %r15d
cmpq %rcx, %r15
jb 0x33762
movl %eax, %ebx
movq %r10, %r14
notq %r14
addq %rdx, %r14
testq %r8, %r8
cmoveq %r10, %r14
movb %bl, (%rdi,%r14)
incq %r10
cmpq %rdx, %r10
jne 0x3374b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x337f1
xorl %edx, %edx
xorl %r9d, %r9d
cmpq $0x8, %rcx
jbe 0x337c2
xorl %r10d, %r10d
jmp 0x337e1
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 0x337cb
addq %rbx, %r9
movb %r10b, (%rdi,%rdx)
incq %rdx
leaq (%r9,%rax), %r10
cmpq %r8, %r10
jbe 0x337b7
cmpq %r8, %r9
jae 0x3381e
xorl %eax, %eax
movq %r9, %r10
movzbl %al, %eax
shll %cl, %eax
orb (%rsi,%r10), %al
incq %r10
cmpq %r10, %r8
jne 0x337fb
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_O3/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, %rbp
movq %rdi, -0x8(%rsp)
xorl %r10d, %r10d
movl $0x8, %eax
xorl %edx, %edx
divq %rcx
movl $0x1, %edx
shll %cl, %edx
movslq %edx, %rdx
movl $0x0, %r11d
cmpq %rbp, %rax
ja 0x338c6
leal -0x1(%rdx), %ebx
xorl %r11d, %r11d
leaq 0x1fd2cf(%rip), %r14    # 0x230b30
xorl %r10d, %r10d
movq %rbp, %rdi
xorl %r15d, %r15d
cmpq $0x8, %rcx
ja 0x338ae
xorl %r12d, %r12d
movb (%rsi,%r11), %r9b
subb %r8b, %r9b
movzbl %r9b, %ebp
xorl %r9d, %r9d
xorl %r13d, %r13d
cmpq %rbp, (%r14,%r9,8)
jae 0x33899
incb %r13b
movzbl %r13b, %r9d
cmpq %rdx, %r9
jb 0x33884
movl %ebx, %r13d
movzbl %r15b, %r15d
shll %cl, %r15d
orb %r13b, %r15b
incq %r11
incq %r12
cmpq %rax, %r12
jb 0x33873
movq -0x8(%rsp), %r9
movb %r15b, (%r9,%r10)
incq %r10
leaq (%r11,%rax), %r9
movq %rdi, %rbp
cmpq %rdi, %r9
jbe 0x33864
cmpq %rbp, %r11
jae 0x33928
leal -0x1(%rdx), %ebx
xorl %eax, %eax
leaq 0x1fd259(%rip), %r14    # 0x230b30
movq %r11, %r15
movb (%rsi,%r15), %r9b
subb %r8b, %r9b
movzbl %r9b, %r13d
xorl %r9d, %r9d
xorl %r12d, %r12d
cmpq %r13, (%r14,%r9,8)
jae 0x33900
incb %r12b
movzbl %r12b, %r9d
cmpq %rdx, %r9
jb 0x338eb
movl %ebx, %r12d
movzbl %al, %eax
shll %cl, %eax
orb %r12b, %al
incq %r15
cmpq %rbp, %r15
jne 0x338da
subl %ebp, %r11d
movzbl %al, %eax
imull %r11d, %ecx
addb $0x8, %cl
shll %cl, %eax
movq -0x8(%rsp), %rcx
movb %al, (%rcx,%r10)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33c7b
movq %rax, %rcx
negq %rcx
leaq (%rsi,%rdi), %rdx
decq %rdx
xorl %r8d, %r8d
leaq 0x2619ec(%rip), %r9     # 0x295630
leaq 0x261aea(%rip), %r10    # 0x295735
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 0x33c4e
testb $0x1, %sil
je 0x33c9d
movzbl (%rdi,%rax), %ecx
leaq 0x2619a4(%rip), %rdx    # 0x295630
movzbl (%rcx,%rdx), %ecx
leaq 0x261a9e(%rip), %rdx    # 0x295735
movb (%rcx,%rdx), %cl
movb %cl, (%rdi,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33ce2
leaq 0x1fca88(%rip), %rsi    # 0x230765
movq %rbx, %rdi
jmp 0x33cf3
movq 0x2612cf(%rip), %rax    # 0x294fb8
movq (%rax), %rdi
leaq 0x1fca72(%rip), %rsi    # 0x230765
movq %rbp, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x22b0
testq %r13, %r13
je 0x33d6d
leal -0x1(%r15), %r14d
leaq 0x1fce20(%rip), %r12    # 0x230b30
xorl %ebp, %ebp
movl %r14d, %eax
testq %r15, %r15
je 0x33d40
movq 0x8(%rsp), %rax
movb (%rax,%rbp), %al
subb 0x10(%rsp), %al
movzbl %al, %ecx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rcx, (%r12,%rdx,8)
jae 0x33d40
incb %al
movzbl %al, %edx
cmpq %r15, %rdx
jb 0x33d2d
movl %r14d, %eax
movzbl %al, %edx
testq %rbx, %rbx
je 0x33d4d
movq %rbx, %rdi
jmp 0x33d57
movq 0x261264(%rip), %rax    # 0x294fb8
movq (%rax), %rdi
leaq 0x20328a(%rip), %rsi    # 0x236fe8
xorl %eax, %eax
callq 0x22b0
incq %rbp
cmpq %r13, %rbp
jne 0x33d12
testq %rbx, %rbx
je 0x33d7c
movl $0xa, %edi
movq %rbx, %rsi
jmp 0x33d8b
movq 0x261235(%rip), %rax    # 0x294fb8
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_O3/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 0x33ddc
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 0x33db6
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_O3/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 0x33e7c
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 0x33e45
movq 0x48(%rbx), %rdi
callq 0x2220
cmpq $0x0, (%rbx)
je 0x33eaa
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 0x33e91
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_O3/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 $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpl %r8d, %ecx
jae 0x342f5
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, %r14
leaq 0x38(%rdx), %rax
movq %rax, 0x8(%rsp)
movq %r15, (%rsp)
leal (%r15,%r13), %ebx
cmpl %r12d, %ebx
movl %r12d, %ebp
cmovbl %ebx, %ebp
movq 0x20(%r14), %rax
movq 0x30(%r14), %rdi
cmpq 0x28(%r14), %rax
jne 0x34215
leaq (%rax,%rax), %rcx
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rcx
movq %rcx, 0x28(%r14)
shlq $0x2, %rcx
leaq (%rcx,%rcx,8), %rsi
callq 0x2370
movq %rax, %rdi
movq %rax, 0x30(%r14)
movq 0x20(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r14)
leaq (%rax,%rax,8), %r8
movl $0xffffffff, (%rdi,%r8,4) # imm = 0xFFFFFFFF
andb $-0x21, 0x20(%rdi,%r8,4)
movl %r13d, 0x4(%rdi,%r8,4)
movl %ebp, 0x8(%rdi,%r8,4)
movl (%r14), %esi
movl %esi, 0xc(%rdi,%r8,4)
movl %ebp, %edx
subl %r13d, %edx
movl %edx, %ecx
shrl $0x2, %ecx
movl %edx, %eax
andl $0x3, %eax
cmpl $0x1, %eax
sbbl $-0x1, %ecx
addl %esi, %ecx
movl %ecx, 0x10(%rdi,%r8,4)
movq 0x10(%r14), %rax
cmpq %rcx, 0x8(%r14)
jae 0x342c9
leaq (%rdi,%r8,4), %r15
decq %rcx
movq %rcx, %rdx
shrq %rdx
orq %rcx, %rdx
movq %rdx, %rcx
shrq $0x2, %rcx
orq %rdx, %rcx
movq %rcx, %rdx
shrq $0x4, %rdx
orq %rcx, %rdx
movq %rdx, %rcx
shrq $0x8, %rcx
orq %rdx, %rcx
movq %rcx, %rsi
shrq $0x10, %rsi
orq %rcx, %rsi
incq %rsi
movq %rsi, 0x8(%r14)
movq %rax, %rdi
callq 0x2370
movq %rax, 0x10(%r14)
movl 0x10(%r15), %ecx
movl 0xc(%r15), %esi
movl 0x4(%r15), %r13d
movl 0x8(%r15), %edx
movq (%rsp), %r15
subl %r13d, %edx
movq %rcx, (%r14)
movl %esi, %edi
addq %rax, %rdi
movl %r13d, %r8d
movq 0x10(%rsp), %rax
leaq (%rax,%r8), %rsi
movl %edx, %edx
movq 0x8(%rsp), %rcx
callq 0x33eca
movl %ebp, %r13d
cmpl %r12d, %ebx
jb 0x341ce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34827
movq %rsi, %r15
movq %rdi, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x1(%r15), %r12
leaq (%r12,%r12,8), %r13
cmpl $-0x1, %eax
je 0x3478d
leaq (,%r13,2), %rdx
addq %r13, %rdx
addq %r12, %rdx
movl 0x8(%r14,%rdx), %ecx
cmpl %eax, %ecx
jbe 0x347a3
addq %r14, %rdx
movl 0x4(%rdx), %ecx
cmpl %ecx, %eax
cmovael %ecx, %eax
jmp 0x34815
movl 0x18(%rbx), %eax
leaq (,%r13,2), %rcx
addq %r13, %rcx
addq %r12, %rcx
movl 0x8(%r14,%rcx), %ecx
cmpl %ecx, %eax
jbe 0x34802
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x347fd
movq 0x30(%rbx), %rsi
movl $0x1, %edi
xorl %r8d, %r8d
leaq (%r8,%r8,8), %r9
movl (%rsi,%r9,4), %r8d
movl %r8d, %r10d
shrl $0xf, %r10d
andl $0x7fff, %r10d          # imm = 0x7FFF
addl 0x4(%rsi,%r9,4), %r10d
cmpl %r10d, %ecx
jne 0x347f3
leaq (%rsi,%r9,4), %r9
movl 0x8(%r9), %r9d
andl $0x7fff, %r8d           # imm = 0x7FFF
subl %r8d, %r9d
cmpl %r9d, %eax
je 0x34802
movl %edi, %r8d
incl %edi
cmpq %r8, %rdx
ja 0x347bc
callq 0x3a8d
leaq (,%r13,2), %rax
addq %r13, %rax
addq %r12, %rax
movl 0x4(%r14,%rax), %eax
cmpq $0x1, %r15
movq %r12, %r15
jg 0x34759
cmpl $-0x1, %eax
jne 0x3482a
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0x34883
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x3487e
movq 0x30(%rbx), %rdx
movl $0x1, %esi
xorl %edi, %edi
leaq (%rdi,%rdi,8), %r8
movl (%rdx,%r8,4), %edi
movl %edi, %r9d
shrl $0xf, %r9d
andl $0x7fff, %r9d           # imm = 0x7FFF
addl 0x4(%rdx,%r8,4), %r9d
jne 0x34875
leaq (%rdx,%r8,4), %r8
movl 0x8(%r8), %r8d
andl $0x7fff, %edi           # imm = 0x7FFF
subl %edi, %r8d
cmpl %r8d, %eax
je 0x34883
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x34842
callq 0x3aa9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Process_Read.cpp
// Function: retrieve_u_cov(ul_idx_t const*, unsigned long, unsigned char, unsigned long, unsigned char, long*)
uint32_t retrieve_u_cov(const ul_idx_t *ul, uint64_t id, uint8_t strand, uint64_t pos, uint8_t dir, int64_t *pi)
{
	uint64_t *a = ul->cc->interval.a + ul->cc->idx[id], cc = 0, ff = 0;
	int64_t a_n = ul->cc->idx[id+1]-ul->cc->idx[id], k = 0, cc_i = pi? *pi:0;
	if(a_n == 0) return 0;
	if(cc_i + 1 >= a_n || cc_i < 0) cc_i = 0;
	if(strand) pos = ul->ug->u.a[id].len - pos - 1;
	if(dir == 0) {
		for (k = cc_i; k + 1 < a_n; k++) {
			if(pos>=(a[k]>>32) && pos<(a[k+1]>>32)) {
				cc = (uint32_t)a[k];
				ff = 1;
				break;
			}
		}

		if(ff == 0) {
			for (k = 0; k < cc_i; k++) {
					if(pos>=(a[k]>>32) && pos<(a[k+1]>>32)) {
					cc = (uint32_t)a[k];
					ff = 1;
					break;
				}
			}
		}
	} else {
		for (k = cc_i; k >= 0; k--) {
			if(pos>=(a[k]>>32) && pos<(a[k+1]>>32)) {
				cc = (uint32_t)a[k];
				ff = 1;
				break;
			}
		}

		if(ff == 0) {
			for (k = cc_i+1; k + 1 < a_n; k++) {
				if(pos>=(a[k]>>32) && pos<(a[k+1]>>32)) {
					cc = (uint32_t)a[k];
					ff = 1;
					break;
				}
			}
		}
	}
	
	if(pi) *pi = ff?k:0;
	return cc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq (%r14), %rax
movl (%rax,%rsi,4), %ebx
movl 0x4(%rax,%rsi,4), %r11d
xorl %eax, %eax
testq %r9, %r9
je 0x36285
movq (%r9), %r10
jmp 0x36288
xorl %r10d, %r10d
cmpl %ebx, %r11d
je 0x363cb
subl %ebx, %r11d
leaq 0x1(%r10), %rax
xorl %r15d, %r15d
testq %r10, %r10
cmovleq %r15, %r10
cmpq %r11, %rax
cmovgeq %r15, %r10
testb %dl, %dl
je 0x362c6
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq (%rsi,%rsi,4), %rdx
movl (%rax,%rdx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
notq %rcx
addq %rax, %rcx
movq 0x18(%r14), %rsi
testb %r8b, %r8b
je 0x36354
leaq (%rsi,%rbx,8), %rsi
addq $0x8, %rsi
movq %r10, %rdx
movq -0x8(%rsi,%rdx,8), %rax
movq %rax, %rdi
shrq $0x20, %rdi
cmpq %rdi, %rcx
jb 0x362fc
movl 0x4(%rsi,%rdx,8), %edi
cmpq %rdi, %rcx
jb 0x363c3
leaq -0x1(%rdx), %rax
testq %rdx, %rdx
movq %rax, %rdx
jg 0x362de
leaq 0x2(%r10), %rax
cmpq %r11, %rax
jae 0x363bf
incq %r10
movl $0x2, %edi
subq %r11, %rdi
movq %r10, %rdx
movq -0x8(%rsi,%rdx,8), %rax
movq %rax, %r8
shrq $0x20, %r8
cmpq %r8, %rcx
jb 0x36342
movl 0x4(%rsi,%rdx,8), %r8d
cmpq %r8, %rcx
jb 0x363c3
leaq (%rdi,%rdx), %rax
incq %rax
incq %rdx
cmpq $0x1, %rax
jne 0x36323
jmp 0x363bf
leaq 0x1(%r10), %rax
cmpq %r11, %rax
jae 0x3638e
leaq (%rsi,%rbx,8), %rdi
addq $0x8, %rdi
decq %r11
movq %r10, %rdx
movq -0x8(%rdi,%rdx,8), %rax
movq %rax, %r8
shrq $0x20, %r8
cmpq %r8, %rcx
jb 0x36386
movl 0x4(%rdi,%rdx,8), %r8d
cmpq %r8, %rcx
jb 0x363c3
incq %rdx
cmpq %rdx, %r11
jne 0x3636b
testq %r10, %r10
je 0x363bf
leaq (%rsi,%rbx,8), %rsi
addq $0x8, %rsi
xorl %edx, %edx
movq -0x8(%rsi,%rdx,8), %rax
movq %rax, %rdi
shrq $0x20, %rdi
cmpq %rdi, %rcx
jb 0x363b7
movl 0x4(%rsi,%rdx,8), %edi
cmpq %rdi, %rcx
jb 0x363c3
incq %rdx
cmpq %rdx, %r10
jne 0x3639d
xorl %eax, %eax
xorl %edx, %edx
testq %r9, %r9
je 0x363cb
movq %rdx, (%r9)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x36c85
movq %rsi, %rbx
cmpl $0x0, 0x10(%rsi)
je 0x36c85
movq %rdi, %r15
movl (%rbx), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl $0x4e, %esi
callq 0x20e0
cmpl $0x0, 0x10(%rbx)
je 0x36c85
xorl %ebp, %ebp
leaq 0x25f676(%rip), %rsi    # 0x296230
xorl %r14d, %r14d
movq %rbx, 0x8(%rsp)
movq 0x18(%rbx), %rax
movq (%rax,%rbp,8), %r12
testl %r12d, %r12d
je 0x36c73
movq %r12, %r13
shrq $0x21, %r13
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
callq 0x333e0
movq (%rbx), %rax
btq $0x20, %r12
movl %r12d, %ecx
jb 0x36c1f
movl %r14d, %edx
xorl %r9d, %r9d
movq 0x8(%rsp), %rbx
leaq 0x25f627(%rip), %rsi    # 0x296230
movb (%rax,%r9), %dil
leal (%rdx,%r9), %r8d
movb %dil, (%r15,%r8)
incq %r9
cmpq %r9, %rcx
jne 0x36c09
jmp 0x36c73
leaq 0x25f60a(%rip), %rsi    # 0x296230
movq 0x18(%rsi), %rdx
movq (%rdx,%r13,8), %rdx
decq %rdx
movl %r14d, %r9d
movq 0x8(%rsp), %rbx
leaq 0x25e9f0(%rip), %r10    # 0x295630
leaq 0x25eaee(%rip), %r11    # 0x295735
movl %edx, %edi
movsbq (%rax,%rdi), %rdi
testq %rdi, %rdi
js 0x36c5e
movzbl (%rdi,%r10), %edi
movb (%rdi,%r11), %dil
jmp 0x36c61
movb $0x4e, %dil
movl %r9d, %r8d
movb %dil, (%r15,%r8)
decq %rdx
incl %r9d
decq %rcx
jne 0x36c47
addl %r12d, %r14d
incq %rbp
movl 0x10(%rbx), %eax
cmpq %rax, %rbp
jb 0x36bc2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x37b6c
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, %rdi
movq %rax, 0x10(%r14)
jmp 0x37b70
movq 0x10(%r14), %rdi
leaq 0x38(%r14), %rcx
movl %ebp, %edx
movq %r12, %rsi
xorl %r8d, %r8d
callq 0x33eca
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_O3/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 0x37e9a
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x37e86
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 0x37e51
movq (%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2220
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1edfb4
movq %rax, %r14
movd %r15d, %xmm0
movd %r12d, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm1
pandn 0x1f84f6(%rip), %xmm1   # 0x230bd0
movq %xmm1, (%rax)
leaq 0x8(%rax), %rdi
callq 0x32e2d
leaq 0x28(%r14), %rdi
callq 0x32e2d
leaq 0x48(%r14), %rdi
callq 0x3f19e
leaq 0x121d8(%r14), %rdi
pxor %xmm0, %xmm0
movdqa %xmm0, 0xd0(%r14)
movdqa %xmm0, 0xc0(%r14)
movdqa %xmm0, 0xb0(%r14)
movdqa %xmm0, 0xa0(%r14)
callq 0x3d002
xorl %eax, %eax
movq %rax, 0x12150(%r14)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x12140(%r14)
movdqa %xmm0, 0x12160(%r14)
movq %rax, 0x12170(%r14)
movdqa %xmm0, 0x12180(%r14)
movq %rax, 0x12190(%r14)
movdqa %xmm0, 0x12250(%r14)
movq %rax, 0x12260(%r14)
movq %rbx, %rdi
testl %ebp, %ebp
je 0x38788
callq 0x128945
movq %rax, 0xe8(%r14)
jmp 0x38794
callq 0x12884d
movq %rax, 0xe0(%r14)
cmpl $0x0, (%r14)
jne 0x387e8
leaq 0x108(%r14), %rdi
movq %rbx, %rsi
callq 0x47773
leaq 0x2c0(%r14), %rdi
movq %rbx, %rsi
callq 0x47767
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 0x4771d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x32d68
leaq 0x28(%rbx), %rdi
callq 0x32d68
leaq 0x48(%rbx), %rdi
callq 0x3f1c8
leaq 0xa0(%rbx), %rdi
callq 0x3d066
leaq 0xc0(%rbx), %rdi
callq 0x3d066
movq 0xe0(%rbx), %rdi
callq 0x1288ff
movq 0xe8(%rbx), %rdi
callq 0x1289f7
leaq 0x121d8(%rbx), %rdi
callq 0x3d0ea
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 0x38c5f
leaq 0x108(%rbx), %rdi
callq 0x477e5
leaq 0x148(%rbx), %rdi
callq 0x44943
leaq 0x200(%rbx), %rdi
callq 0x44943
leaq 0x2c0(%rbx), %rdi
callq 0x477cf
leaq 0x9040(%rbx), %rdi
callq 0x3c0c0
leaq 0x9330(%rbx), %rdi
callq 0x47789
movq %rbx, %rdi
popq %rbx
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38f01
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 0x38ee6
movq 0x30(%rdi), %rax
leaq (%rax,%rax,8), %rax
addq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38f4b
movq 0x218(%rdi), %rdx
addq $0x8, %rdx
xorl %eax, %eax
movl $0x1, %esi
cmpl $0x1, 0x14(%rdx)
jne 0x38f3d
cmpl $0x2, (%rdx)
jb 0x38f3d
cmpl $0x2, 0x4(%rdx)
sbbl $-0x1, %eax
movl %esi, %edi
addq $0x28, %rdx
incl %esi
cmpq %rdi, %rcx
ja 0x38f2b
retq
xorl %eax, %eax
retq