LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/anchor.cpp
// Function: hpc_ext_check(All_reads*, unsigned int, long, long, long, unsigned long, char*)
void hpc_ext_check(All_reads *rref, uint32_t id, int64_t s0, int64_t e0, int64_t l, uint64_t rev, char *buf)
{
	if(s0 < 0) s0 = 0; if(e0 > l) e0 = l;
	int64_t s = s0 - 256, e = e0 + 256, n, k, os0, oe0, os1, oe1; char c; if(s < 0) s = 0; if(e > l) e = l;
	recover_UC_Read_sub_region(buf, s, e - s, rev, rref, id); 
	os0 = s0 - s; oe0 = e0 - s; n = e - s; os1 = os0; oe1 = oe0;
	c = buf[os0];
	for (k = os0 - 1; k >= 0 && buf[k] == c; k--); os1 = k + 1;

	c = buf[oe0-1];
	for (k = oe0; k < n && buf[k] == c; k++); oe1 = k;

	if(os1 != os0 || oe1 != oe0) {
		fprintf(stderr, "[M::%s]\to0::[%ld,%ld)\to1::[%ld,%ld)\n", __func__, os0 + s0, oe0 + s0, os1 + s0, oe1 + s0);
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdi, %r8
movq 0x50(%rsp), %r14
xorl %eax, %eax
testq %rdx, %rdx
cmovgq %rdx, %rax
movq %rax, 0x8(%rsp)
cmpq %rbx, %rcx
movq %rbx, %r15
movq %rcx, 0x10(%rsp)
cmovlq %rcx, %r15
movl $0x101, %eax            # imm = 0x101
cmpq %rax, %rdx
movl $0x100, %r12d           # imm = 0x100
cmovgeq %rdx, %r12
leaq 0x100(%r15), %rax
cmpq %rbx, %rax
cmovlq %rax, %rbx
leaq -0x100(%r12), %rbp
movq %rbx, %r13
subq %rbp, %r13
movl %esi, %eax
movzbl %r9b, %ecx
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rax, %r9
callq 0x32ef8
movq 0x8(%rsp), %r10
movq %r10, %rcx
subq %rbp, %rcx
subq %rbp, %r15
movb (%r14,%rcx), %dl
movq %rcx, %rax
sarq $0x3f, %rax
andq %rcx, %rax
movq %r10, %rsi
subq %r12, %rsi
movl $0x101, %edi            # imm = 0x101
addq %rdi, %rsi
leaq -0x1(%rsi), %r9
testq %r9, %r9
jle 0x1329fd
cmpb %dl, -0x2(%r14,%rsi)
movq %r9, %rsi
je 0x1329e8
jmp 0x132a00
movq %rax, %r9
movq %r15, %rax
cmpq 0x10(%rsp), %rbx
jle 0x132a20
movb -0x1(%r14,%r15), %dl
movq %r15, %rax
cmpb %dl, (%r14,%rax)
jne 0x132a20
incq %rax
cmpq %r13, %rax
jl 0x132a12
cmpq %rcx, %r9
jne 0x132a39
cmpq %r15, %rax
jne 0x132a39
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1625a0(%rip), %rdx    # 0x294fe0
movq (%rdx), %rdi
addq %r10, %rcx
addq %r10, %r15
addq %r10, %r9
addq %r10, %rax
movq %rax, (%rsp)
leaq 0x10871f(%rip), %rsi    # 0x23b179
leaq 0x10873d(%rip), %rdx    # 0x23b19e
movq %r15, %r8
xorl %eax, %eax
callq 0x22b0
jmp 0x132a2a
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/anchor.cpp
// Function: h_ec_lchain_re_gen_qry(ha_abuf_s*, unsigned long*, unsigned long*, unsigned long*, unsigned long*, unsigned long, unsigned long*, unsigned long*)
uint64_t h_ec_lchain_re_gen_qry(ha_abuf_t *ab, uint64_t *k, uint64_t *l, uint64_t *i, uint64_t *idx_a, uint64_t idx_n, uint64_t *tid, uint64_t *trev)
{
	while ((*k) <= ab->n_a) {
        if ((*k) == ab->n_a || (ab->a[*k].srt>>32) != (ab->a[*l].srt>>32)) {
			for (; ((*i) < idx_n) && ((idx_a[*i]>>32) < (ab->a[*l].srt>>32)); (*i)++);
			if(((*i) < idx_n) && ((ab->a[*l].srt>>32) == (idx_a[*i]>>32))) {
				(*tid) = ab->a[*l].srt>>33; (*trev) = (ab->a[*l].srt>>32) & 1; 
				
				return 1;
			}
            (*l) = (*k);
        }
		++(*k);
    }
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %r14
movq (%rdi), %r15
cmpq %r15, %r14
jbe 0x133f76
xorl %eax, %eax
jmp 0x13400e
movq 0x38(%rsp), %r11
movq %r9, %rbx
negq %rbx
xorl %eax, %eax
cmpq %r15, %r14
je 0x133fa6
movq 0x30(%rdi), %r15
leaq (%r14,%r14,2), %r12
movq (%rdx), %r13
leaq (%r13,%r13,2), %r13
movq (%r15,%r13,8), %r13
xorq (%r15,%r12,8), %r13
shrq $0x20, %r13
je 0x133ffc
movq (%rcx), %r15
cmpq %r9, %r15
jae 0x133ff6
movq 0x30(%rdi), %r14
incq %r15
movq -0x8(%r8,%r15,8), %r13
movq %r13, %rbp
shrq $0x20, %rbp
movq (%rdx), %r12
leaq (%r12,%r12,2), %r12
movq (%r14,%r12,8), %r10
movq %r10, %r12
shrq $0x20, %r12
cmpl %r12d, %ebp
jae 0x133fed
movq %r15, (%rcx)
leaq (%rbx,%r15), %r10
incq %r10
incq %r15
cmpq $0x1, %r10
jne 0x133fb5
jmp 0x133ff6
xorq %r10, %r13
shrq $0x20, %r13
je 0x134019
movq (%rsi), %r14
movq %r14, (%rdx)
incq %r14
movq %r14, (%rsi)
movq (%rdi), %r15
cmpq %r15, %r14
jbe 0x133f83
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shrq $0x21, %r10
movq %r10, (%r11)
movq (%rdx), %rax
leaq (%rax,%rax,2), %rax
movq (%r14,%rax,8), %rax
shrq $0x20, %rax
andl $0x1, %eax
movq 0x40(%rsp), %rcx
movq %rax, (%rcx)
movl $0x1, %eax
jmp 0x13400e
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/anchor.cpp
// Function: get_mz1(char const*, int, int, int, unsigned int, int, ha_abuf_s*, void const*, ha_pt_s*, int, kvec_t_u8_warp*, kvec_t_u64_warp*, ha_pt_s*, int, int, float, st_mt_t*, int, int, void*, unsigned long)
uint64_t get_mz1(const char *str, int len, int w, int k, uint32_t rid, int is_hpc, ha_abuf_t *ab, const void *hf, ha_pt_t *ha_idx, int sample_dist, kvec_t_u8_warp* k_flag, kvec_t_u64_warp* dbg_ct, ha_pt_t *pt, int min_freq, int32_t dp_min_len, float dp_e, st_mt_t *mt, int32_t ws, int32_t is_unique, void *km, uint64_t beg_i)
{
	ab->mz.n = beg_i;
	// get the list of anchors
	mz1_ha_sketch(str, len, w, k, 0, !(asm_opt.flag & HA_F_NO_HPC), &ab->mz, hf, asm_opt.mz_sample_dist, k_flag, dbg_ct, NULL, -1, asm_opt.dp_min_len, -1, mt, asm_opt.mz_rewin, 0, NULL);

	radix_sort_ha_mz1_v_srt(ab->mz.a + beg_i, ab->mz.a + ab->mz.n);

	if(ha_idx) {
		uint64_t i;

		if (ab->mz.m > ab->old_mz_m) {
			ab->old_mz_m = ab->mz.m;
			REALLOC(ab->seed, ab->old_mz_m);
		}

		for (i = 0; i < ab->mz.n; ++i) {
			ab->seed[i].a = NULL;
			ab->seed[i].n = ha_pt_cnt(ha_idx, ab->mz.a[i].x);
		}
	}

	return ab->mz.n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0xb0(%rsp), %rbx
movq 0xa0(%rsp), %r15
movq 0xa8(%rsp), %rax
movaps 0xc0(%rsp), %xmm0
movq 0xe8(%rsp), %r8
movq 0x108(%rsp), %r14
leaq 0x18(%r15), %r12
movl %r14d, 0x18(%r15)
leaq 0x1612bd(%rip), %r10    # 0x295758
movl (%r10), %r9d
movl 0xa0(%r10), %r11d
notl %r9d
andl $0x1, %r9d
movl 0xa8(%r10), %ebp
movl 0x1f8(%r10), %r10d
xorl %r13d, %r13d
movq %r13, 0x58(%rsp)
movl %r11d, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl %r10d, 0x38(%rsp)
movq %r13, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movl %ebp, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq %r12, (%rsp)
movl $0x0, 0x50(%rsp)
movl $0xffffffff, 0x30(%rsp) # imm = 0xFFFFFFFF
movss 0x1066b0(%rip), %xmm0   # 0x23abb0
xorl %r8d, %r8d
callq 0x121477
movq 0x20(%r15), %rax
shlq $0x4, %r14
addq %rax, %r14
movl 0x18(%r15), %esi
shlq $0x4, %rsi
addq %rax, %rsi
movq %r14, %rdi
callq 0x12882b
testq %rbx, %rbx
je 0x13458e
movl 0x1c(%r15), %esi
cmpl 0x10(%r15), %esi
jbe 0x13454a
movl %esi, 0x10(%r15)
movq 0x28(%r15), %rdi
shlq $0x4, %rsi
callq 0x2370
movq %rax, 0x28(%r15)
cmpl $0x0, (%r12)
je 0x134594
movq 0x28(%r15), %rcx
xorl %r14d, %r14d
xorl %r12d, %r12d
movq $0x0, 0x8(%rcx,%r14)
movq 0x20(%r15), %rax
movq (%rax,%r14), %rsi
movq %rbx, %rdi
callq 0x1195d5
movq 0x28(%r15), %rcx
movl %eax, (%rcx,%r14)
incq %r12
movl 0x18(%r15), %eax
addq $0x10, %r14
cmpq %rax, %r12
jb 0x13455b
jmp 0x134596
movl (%r12), %eax
jmp 0x134596
xorl %eax, %eax
movl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/anchor.cpp
// Function: get_pi_ec_chain(ha_abuf_s*, unsigned long, unsigned long, unsigned int, char*, unsigned long, unsigned long, unsigned long, overlap_region_alloc*, Candidates_list*, double, int, kvec_t_u8_warp*, kvec_t_u64_warp*, st_mt_t*, unsigned int*, unsigned int*, unsigned int, long, double, unsigned int, long, long, long, long, double, double)
void get_pi_ec_chain(ha_abuf_t *ab, uint64_t rid, uint64_t rl, uint32_t tid, char* ts, uint64_t tl, uint64_t mz_w, uint64_t mz_k, overlap_region_alloc *overlap_list, Candidates_list *cl, double bw_thres, 
								int apend_be, kvec_t_u8_warp* k_flag, kvec_t_u64_warp* dbg_ct, st_mt_t *sp, uint32_t *high_occ, uint32_t *low_occ, /**uint32_t is_accurate,**/ uint32_t gen_off, int64_t enable_mcopy, double mcopy_rate, uint32_t mcopy_khit_cut, 
								int64_t max_skip, int64_t max_iter, int64_t max_dis, int64_t quick_check, double chn_pen_gap, double chn_pen_skip)
{
	extern void *ha_flt_tab;
	extern ha_pt_t *ha_idx;
	uint64_t rn = ab->mz.n, tn, cn = 0;

	tn = get_mz1(ts, tl, mz_w, mz_k, 0, !(asm_opt.flag & HA_F_NO_HPC), ab, ha_flt_tab, NULL, asm_opt.mz_sample_dist, k_flag, dbg_ct, NULL, -1, asm_opt.dp_min_len, -1, sp, asm_opt.mz_rewin, 0, NULL, rn);

	cn = lchain_qgen_mcopy_fast_re0(ab, ha_idx, ab->mz.a, rn, ab->mz.a + rn, tn - rn, tid, cl, high_occ, low_occ);

	if(cn) {
		lchain_qgen_mcopy_fast_re1(cl, cl->length - cn, overlap_list, rid, rl, tl, apend_be, max_skip, max_iter, max_dis, chn_pen_gap, chn_pen_skip, bw_thres, quick_check, gen_off, enable_mcopy, mcopy_rate, mcopy_khit_cut);
	}

	ab->mz.n = rn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %r9, %r15
movl %ecx, %r12d
movq %rdx, (%rsp)
movq %rsi, %r13
movq %rdi, %rbx
movq 0x78(%rsp), %rbp
movl 0x60(%rsp), %edx
movl 0x68(%rsp), %ecx
movups 0x88(%rsp), %xmm0
movq 0x98(%rsp), %rax
movl 0x18(%rdi), %r14d
leaq 0x161e2b(%rip), %rsi    # 0x296430
movq (%rsi), %rsi
subq $0x70, %rsp
movq %r14, 0x68(%rsp)
movq %rax, 0x48(%rsp)
movups %xmm0, 0x20(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
movq $0x0, 0x10(%rsp)
movq %r8, %rdi
movl %r15d, %esi
callq 0x13444e
addq $0x70, %rsp
movq 0x20(%rbx), %rdx
movq %r14, %r8
shlq $0x4, %r8
addq %rdx, %r8
subq %r14, %rax
movl %r12d, %ecx
subq $0x20, %rsp
movaps 0xc0(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movq %rbp, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rbx, %rdi
movq %r14, %rcx
movq %rax, %r9
callq 0x12bf97
addq $0x20, %rsp
testq %rax, %rax
je 0x1346fa
movl 0xc0(%rsp), %r11d
movl 0xb0(%rsp), %r12d
movl 0x80(%rsp), %r10d
movq 0x70(%rsp), %rdx
movl 0x8(%rbp), %esi
subl %eax, %esi
movq %rbp, %rdi
movl %r13d, %ecx
movq (%rsp), %r8
movq %r15, %r9
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
pushq %r11
pushq 0xc0(%rsp)
pushq %r12
pushq 0xf8(%rsp)
pushq 0xf8(%rsp)
pushq 0xf8(%rsp)
pushq 0xf8(%rsp)
pushq %r10
callq 0x12f698
addq $0x40, %rsp
movl %r14d, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/extract.cpp
// Function: ha_extract_print_list(All_reads const*, int, char const*)
void ha_extract_print_list(const All_reads *rs, int n_rounds, const char *o)
{
	int i, n;
	char **list;
	list = gv_read_list(o, &n);
	ha_extract_print(rs, n_rounds, n, list);
	for (i = 0; i < n; ++i) free(list[i]);
	free(list);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
leaq 0x4(%rsp), %r14
movq %rdx, %rdi
movq %r14, %rsi
callq 0x135199
movq %rax, %rbx
movslq (%r14), %r14
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rax, %rcx
callq 0x135584
testq %r14, %r14
jle 0x13655b
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2220
incq %r15
cmpq %r15, %r14
jne 0x13654a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2220
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: init_ha_ug_index_opt(ha_ug_index*, ma_ug_t*, int, pldat_t*, unsigned long, unsigned long, unsigned long)
void init_ha_ug_index_opt(ha_ug_index* idx, ma_ug_t *ug, int k, pldat_t* p, uint64_t up_occ, 
uint64_t low_occ, uint64_t thread_num)
{
    uint64_t i, n;
    for (idx->uID_bits=1; (uint64_t)(1<<idx->uID_bits)<(uint64_t)ug->u.n; idx->uID_bits++);
    idx->pos_bits = 64 - idx->uID_bits - 1;
    idx->uID_mode = (((uint64_t)-1) << (64-idx->uID_bits))>>1;
    idx->pos_mode = ((uint64_t)-1) >> (64-idx->pos_bits);
    idx->rev_mode = ((uint64_t)1) << 63;
    idx->ug = ug;
    idx->k = k;
    idx->pre = HIC_COUNTER_BITS;
    idx->tot = 1 << idx->pre;
    idx->tot_pos = 0;
    ///idx->up_bound = 1;
    idx->up_bound = up_occ;
    idx->low_bound = low_occ;
    CALLOC(idx->idx_buf, idx->tot);
    for (i = 0; i < idx->tot; i++)
    {
        idx->idx_buf[i].h = hc_pt_init();
    }
    for (i = n = 0; i < ug->u.n; i++)
    {
        n += ug->u.a[i].len;
    }
    n = n << 3;
    p->h = idx;
    p->buf_bytes = n>>7;
    CALLOC(p->cnt, idx->tot);
    CALLOC(p->buf, idx->tot);
    for (i = 0; i < idx->tot; i++)
    {
        kv_init(p->cnt[i].a);
        kv_init(p->buf[i].a);
    }
    p->n_thread = thread_num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbp
movl $0x1, %eax
xorl %esi, %esi
movl $0x1, %edi
movl %eax, %ecx
shll %cl, %edi
movslq %edi, %rcx
incq %rax
decq %rsi
cmpq %rcx, %rbp
ja 0x13a3cf
movq %rsi, %rcx
negq %rcx
movq %rcx, 0x18(%r14)
leaq 0x3f(%rsi), %rcx
movq %rcx, 0x28(%r14)
movq $-0x1, %rdi
movq $-0x1, %r10
movl %esi, %ecx
shlq %cl, %r10
shrq %r10
movl %eax, %ecx
shrq %cl, %rdi
movq %r10, 0x20(%r14)
movq %rdi, 0x30(%r14)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x38(%r14)
movq %r15, (%r14)
movslq %edx, %rax
movq %rax, 0x40(%r14)
movq $0xc, 0x50(%r14)
movq $0x1000, 0x58(%r14)     # imm = 0x1000
movq $0x0, 0x60(%r14)
movq %r8, 0x68(%r14)
movq %r9, 0x70(%r14)
movl $0x1000, %edi           # imm = 0x1000
movl $0x20, %esi
callq 0x2120
movq %rax, %r12
movq %rax, 0x78(%r14)
xorl %r13d, %r13d
movl $0x1, %edi
movl $0x18, %esi
callq 0x2120
movq %rax, (%r12,%r13)
addq $0x20, %r13
cmpq $0x20000, %r13          # imm = 0x20000
jne 0x13a46c
testq %rbp, %rbp
je 0x13a4be
movq 0x10(%r15), %rcx
xorl %eax, %eax
movl (%rcx), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
addq %rdx, %rax
addq $0x28, %rcx
decq %rbp
jne 0x13a497
shrq $0x4, %rax
movabsq $0x1ffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFF
andq %rax, %rcx
jmp 0x13a4c0
xorl %ecx, %ecx
movq %r14, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movl $0x1000, %edi           # imm = 0x1000
movl $0x18, %esi
callq 0x2120
movq %rax, 0x18(%rbx)
movl $0x1000, %edi           # imm = 0x1000
movl $0x18, %esi
callq 0x2120
movq %rax, 0x20(%rbx)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: hc_pt_t_gen_single(hc_pt1_t*, unsigned long*, unsigned long*)
void hc_pt_t_gen_single(hc_pt1_t* pt, uint64_t* up_bound, uint64_t* low_bound)
{
    khint_t k;
    uint64_t c;

    if(up_bound || low_bound)
    {
        for (k = 0; k != kh_end(pt->h); ++k) {
            if (kh_exist(pt->h, k)) {
                if((up_bound && kh_val(pt->h, k) > (*up_bound)) || 
                            (low_bound && kh_val(pt->h, k) < (*low_bound)))
                {
                    kh_val(pt->h, k) = 0;
                    kh_key(pt->h, k) = (kh_key(pt->h, k)&HIC_KEY_MODE)|
                                (kh_val(pt->h, k)<HIC_MAX_COUNT?kh_val(pt->h, k):HIC_MAX_COUNT);
                }
            }
        }
    }
    

    for (k = 0, pt->n = 0; k != kh_end(pt->h); ++k) {
        if (kh_exist(pt->h, k)) {
            c = kh_val(pt->h, k);
            kh_val(pt->h, k) = pt->n;
            pt->n += c;
            pt->end = k;
        }
    }
    CALLOC(pt->a, pt->n);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %r8
movq %rsi, %rcx
orq %rdx, %rcx
je 0x13a8e6
xorl %edi, %edi
movl $0x0, %r9d
testq %r8, %r8
je 0x13a887
movb (%rax), %cl
movl $0x1, %r9d
shll %cl, %r9d
cmpl %r9d, %edi
je 0x13a8e6
movq 0x8(%rax), %rcx
movl %edi, %r9d
shrl $0x5, %r9d
movl (%rcx,%r9,4), %ecx
btl %edi, %ecx
jae 0x13a8e2
movl %edi, %ecx
testq %rsi, %rsi
je 0x13a8b8
movq %rcx, %r9
shlq $0x4, %r9
movq 0x8(%r8,%r9), %r9
cmpq (%rsi), %r9
ja 0x13a8ce
testq %rdx, %rdx
je 0x13a8e2
movq %rcx, %r9
shlq $0x4, %r9
movq 0x8(%r8,%r9), %r9
cmpq (%rdx), %r9
jae 0x13a8e2
shlq $0x4, %rcx
movq $0x0, 0x8(%r8,%rcx)
andw $0xf000, (%r8,%rcx)     # imm = 0xF000
incl %edi
jmp 0x13a871
movq $0x0, 0x8(%rbx)
xorl %edi, %edi
xorl %edx, %edx
movl $0x0, %esi
testq %r8, %r8
je 0x13a905
movb (%rax), %cl
movl $0x1, %esi
shll %cl, %esi
cmpl %esi, %edx
je 0x13a93b
movq 0x8(%rax), %rcx
movl %edx, %esi
shrl $0x5, %esi
movl (%rcx,%rsi,4), %ecx
btl %edx, %ecx
jae 0x13a937
movl %edx, %ecx
shlq $0x4, %rcx
movq 0x8(%r8,%rcx), %rsi
addq %rdi, %rsi
movq %rdi, 0x8(%r8,%rcx)
movq %rsi, 0x8(%rbx)
movl %edx, 0x18(%rbx)
movq %rsi, %rdi
incl %edx
jmp 0x13a8f2
movl $0x8, %esi
callq 0x2120
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: destory_hc_pt_index(ha_ug_index*)
void destory_hc_pt_index(ha_ug_index* idx)
{
    if(idx->idx_buf)
    {
        uint64_t i = 0;
        for (i = 0; i < idx->tot; i++)
        {
            if(idx->idx_buf[i].a) free(idx->idx_buf[i].a);
            if(idx->idx_buf[i].h) hc_pt_destroy(idx->idx_buf[i].h);
        }
        free(idx->idx_buf);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x13af7a
cmpq $0x0, 0x58(%rbx)
je 0x13af6a
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x78(%rbx), %rax
movq 0x10(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x13af36
callq 0x2220
movq 0x78(%rbx), %rax
movq (%rax,%r15), %r14
testq %r14, %r14
je 0x13af59
movq 0x10(%r14), %rdi
callq 0x2220
movq 0x8(%r14), %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2220
incq %r12
addq $0x20, %r15
cmpq 0x58(%rbx), %r12
jb 0x13af1f
movq 0x78(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2220
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: hc_pt_t_gen(ha_ug_index*, pldat_t*)
void hc_pt_t_gen(ha_ug_index* idx, pldat_t* pl)
{
    if(pl == NULL)
    {
        uint64_t i;
        for (i = 0; i < idx->tot; i++)
        {
            hc_pt_t_gen_single(&(idx->idx_buf[i]), &(idx->up_bound), &(idx->low_bound));
        }
    }
    else
    {
        kt_for(pl->n_thread, worker_for_sort, pl, pl->h->tot);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x13afa5
movq %rsi, %rdx
movl 0x28(%rsi), %edi
movq 0x10(%rsi), %rax
movq 0x58(%rax), %rcx
leaq 0x4f(%rip), %rsi        # 0x13afef
jmp 0x108f2c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
je 0x13afe5
leaq 0x68(%rbx), %r14
leaq 0x70(%rbx), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x78(%rbx), %rdi
addq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x13a85c
incq %r13
addq $0x20, %r12
cmpq 0x58(%rbx), %r13
jb 0x13afc6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: worker_for_sort(void*, long, int)
static void worker_for_sort(void *data, long i, int tid) // callback for kt_for()
{
    pldat_t *pl = (pldat_t*)data;
    hc_pt1_t *h = &(pl->h->idx_buf[i]);
    khint_t k;
    uint64_t beg, cnt = 0;
    uint64_t* pos_list;
    for (k = 0; k != kh_end(h->h); ++k) {
        if (kh_exist(h->h, k)) {
            beg = kh_val(h->h, k);
            pos_list = h->a + beg;
            if((kh_key(h->h, k)&HIC_MAX_COUNT)<HIC_MAX_COUNT)
            {
                cnt = kh_key(h->h, k)&HIC_MAX_COUNT;
            }
            else if(k == h->end)
            {
                cnt = h->n - beg;
            }
            else
            {
                for (k++; k != kh_end(h->h); ++k)
                {
                    if (kh_exist(h->h, k)) 
                    {
                        cnt = kh_val(h->h, k) - beg;
                        break;
                    }
                }
            }
            if(cnt > 0) radix_sort_hc_pos(pos_list, pos_list+cnt);
        }
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rax
shlq $0x5, %rbx
addq 0x78(%rax), %rbx
xorl %r15d, %r15d
movl $0xfff, %r14d           # imm = 0xFFF
xorl %ebp, %ebp
movq (%rbx), %rdx
movq 0x10(%rdx), %rax
movl $0x0, %esi
testq %rax, %rax
je 0x13b02a
movb (%rdx), %cl
movl $0x1, %esi
shll %cl, %esi
cmpl %esi, %ebp
je 0x13b0c3
movq 0x8(%rdx), %rsi
movl %ebp, %ecx
shrl $0x5, %ecx
movl (%rsi,%rcx,4), %ecx
btl %ebp, %ecx
jae 0x13b0bc
movl %ebp, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdi
movq (%rax,%rcx), %rcx
andq %r14, %rcx
cmpq %r14, %rcx
jne 0x13b09e
cmpl 0x18(%rbx), %ebp
jne 0x13b065
movq 0x8(%rbx), %r15
jmp 0x13b099
testq %rax, %rax
je 0x13b077
movb (%rdx), %cl
movl $0x1, %r8d
shll %cl, %r8d
jmp 0x13b07a
xorl %r8d, %r8d
incl %ebp
cmpl %r8d, %ebp
je 0x13b0a1
movl %ebp, %ecx
shrl $0x5, %ecx
movl (%rsi,%rcx,4), %ecx
btl %ebp, %ecx
jae 0x13b065
movl %ebp, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %r15
subq %rdi, %r15
jmp 0x13b0a1
movq %rcx, %r15
testq %r15, %r15
je 0x13b0b9
shlq $0x3, %rdi
addq 0x10(%rbx), %rdi
leaq (%rdi,%r15,8), %rsi
callq 0x13951f
jmp 0x13b0bc
xorl %r15d, %r15d
incl %ebp
jmp 0x13b010
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: debug_hash_value(char*, unsigned long, unsigned long)
uint64_t debug_hash_value(char *r, uint64_t end, uint64_t k_mer)
{
    uint64_t i;
    uint64_t x[4], mask = (1ULL<<k_mer) - 1, shift = k_mer - 1, skip;
    for (i = end + 1 - k_mer, x[0] = x[1] = x[2] = x[3] = 0; i <= end; i++)
    {
        int c = seq_nt4_table[(uint8_t)r[i]];
        ///c = 00, 01, 10, 11
        if (c < 4) { // not an "N" base
            ///x[0] & x[1] are the forward k-mer
            ///x[2] & x[3] are the reverse complementary k-mer
            x[0] = (x[0] << 1 | (c&1))  & mask;
            x[1] = (x[1] << 1 | (c>>1)) & mask;
            x[2] = x[2] >> 1 | (uint64_t)(1 - (c&1))  << shift;
            x[3] = x[3] >> 1 | (uint64_t)(1 - (c>>1)) << shift;
        }
    }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $-0x1, %rax
movq $-0x1, %rbx
movl %edx, %ecx
shlq %cl, %rbx
movq %rsi, %r14
subq %rdx, %r14
incq %r14
cmpq %rsi, %r14
ja 0x13bcb1
notq %rbx
leaq -0x1(%rdx), %rcx
xorl %r9d, %r9d
leaq 0xfe08f(%rip), %r15     # 0x239c20
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %r8d, %r8d
movzbl (%rdi,%r14), %r12d
movzbl (%r15,%r12), %r12d
cmpq $0x3, %r12
ja 0x13bbf0
movl %r12d, %r13d
andl $0x1, %r13d
leaq (,%r9,2), %r9
addq %r13, %r9
andq %rbx, %r9
addq %r10, %r10
shrl %r12d
movq %r12, %rbp
orq %r10, %rbp
xorl $0x1, %r13d
shlq %cl, %r13
andq %rbx, %rbp
shrq %r11
movl $0x1, %r10d
subl %r12d, %r10d
shlq %cl, %r10
orq %r13, %r11
shrq %r8
orq %r10, %r8
movq %rbp, %r10
incq %r14
cmpq %rsi, %r14
jbe 0x13bb9a
cmpq %r8, %r10
jne 0x13bc06
cmpq %r11, %r9
je 0x13bcb1
setae %al
testb %al, %al
cmovneq %r11, %r9
cmpq $0x20, %rdx
ja 0x13bc2a
shlq $0x20, %r9
testb %al, %al
cmovneq %r8, %r10
orq %r9, %r10
movq %r10, %rax
jmp 0x13bcb1
movq %r9, %rcx
notq %rcx
shlq $0x15, %r9
addq %rcx, %r9
movq %r9, %rcx
shrq $0x18, %rcx
xorq %r9, %rcx
imulq $0x109, %rcx, %rcx      # imm = 0x109
movq %rcx, %rdx
shrq $0xe, %rdx
xorq %rcx, %rdx
leaq (%rdx,%rdx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
movq %rcx, %rdx
shrq $0x1c, %rdx
xorq %rcx, %rdx
testb %al, %al
cmovneq %r8, %r10
movq %r10, %rax
notq %rax
shlq $0x15, %r10
addq %rax, %r10
movq %r10, %rax
shrq $0x18, %rax
xorq %r10, %rax
imulq $0x109, %rax, %rax      # imm = 0x109
movq %rax, %rcx
shrq $0xe, %rcx
xorq %rax, %rcx
leaq (%rcx,%rcx,4), %rax
leaq (%rcx,%rax,4), %rax
movq %rax, %rcx
shrq $0x1c, %rcx
xorq %rax, %rcx
addq %rdx, %rcx
movq %rcx, %rax
shlq $0x1f, %rax
addq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: get_5_3_list(ha_ug_index*, s_hit*, unsigned long, s_hit**, unsigned long*, s_hit**, unsigned long*)
void get_5_3_list(ha_ug_index* idx, s_hit* p, uint64_t cnt, s_hit** l5, uint64_t* l5_occ, 
s_hit** l3, uint64_t* l3_occ)
{
    (*l5) = (*l3) = NULL;
    (*l5_occ) = (*l3_occ) = 0;
    uint64_t i, j, rev, uID, ref_p, self_p, eLen, tLen, cur_beg, num;
    uint64_t beg_5 = (uint64_t)-1;
    for (j = 1, i = 0, num = 0; j <= cnt; ++j)
    {
        if(j == cnt || p[j].off_cnt != p[i].off_cnt)
        {
            interpret_pos((ha_ug_index*)idx, &p[i], &rev, &uID, &ref_p, &self_p, &eLen, &tLen);
            ///cur_end = self_p;
            cur_beg = self_p + 1 - tLen;
            num++;
            if(cur_beg <= beg_5)
            {
                (*l3_occ) = (*l5_occ); (*l3) = (*l5);
                beg_5 = cur_beg; (*l5_occ) = j - i; (*l5) = p + i;
            }
            else
            {
                (*l3_occ) = j - i; (*l3) = p + i;
            }
            i = j;///must
        }
    }

    ///if(num > 2) fprintf(stderr, "ERROR: get_5_3_list\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x30(%rsp), %rax
xorl %edi, %edi
movq %rdi, (%r9)
movq %rdi, (%rcx)
movq %rdi, (%rax)
movq %rdi, (%r8)
testq %rdx, %rdx
je 0x13d564
leaq 0x1(%rdx), %r10
cmpq $0x3, %r10
movl $0x2, %edi
cmovaeq %r10, %rdi
leaq 0x18(%rsi), %r10
movl $0x1, %r11d
movq $-0x1, %r14
xorl %ebx, %ebx
movq %rbx, %r15
shlq $0x4, %r15
cmpq %r11, %rdx
jne 0x13d4fb
movq 0x8(%rsi,%r15), %r12
jmp 0x13d505
movq 0x8(%rsi,%r15), %r12
cmpq %r12, (%r10)
je 0x13d558
movl %r12d, %r15d
movq %r12, %r13
shrq $0x20, %r13
movzwl %r13w, %r13d
shrq $0x30, %r12
addq %r13, %r12
subq %r12, %r15
incq %r15
movq %rax, %r12
movq %r9, %r13
cmpq %r14, %r15
ja 0x13d540
movq (%r8), %r14
movq %r14, (%rax)
movq (%rcx), %r14
movq %r14, (%r9)
movq %r8, %r12
movq %rcx, %r13
movq %r15, %r14
movq %r11, %r15
subq %rbx, %r15
shlq $0x4, %rbx
addq %rsi, %rbx
movq %r15, (%r12)
movq %rbx, (%r13)
movq %r11, %rbx
incq %r11
addq $0x10, %r10
cmpq %r11, %rdi
jne 0x13d4e8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: test_reads(reads_t*, char const*)
void test_reads(reads_t* x, const char *fn)
{
    gzFile fp;
    kseq_t *ks;
    int ret, i = 0;

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

    kseq_destroy(ks);
    gzclose(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x101b47(%rip), %rsi    # 0x23f7f7
movq %rax, %rdi
callq 0x22d0
testq %rax, %rax
je 0x13dd4f
movq %rax, %r14
movq %rax, %rdi
callq 0x13d88c
movq %rax, %r15
movq %rax, %rdi
callq 0x13d8d6
testl %eax, %eax
js 0x13dd31
leaq 0xfd732(%rip), %r12     # 0x23b414
xorl %r13d, %r13d
movq (%r15), %rdx
movq 0x10(%r15), %rdi
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rbp
movq 0x10(%rbx), %rsi
addq %rbp, %rsi
callq 0x21a0
testl %eax, %eax
jne 0x13dd15
incq %r13
movq %r15, %rdi
callq 0x13d8d6
testl %eax, %eax
jns 0x13dce5
jmp 0x13dd31
movq 0x1572c4(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
movq %r12, %rsi
movl %r13d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x22b0
jmp 0x13dd04
movq %r15, %rdi
callq 0x13dc3f
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2390
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: print_hits(ha_ug_index*, kvec_pe_hit*, enzyme const*, enzyme const*)
void print_hits(ha_ug_index* idx, kvec_pe_hit* hits, const enzyme *fn1, const enzyme *fn2)
{
    uint64_t k, shif = 64 - idx->uID_bits;
    reads_t r1;
    load_reads(&r1, fn1, fn2);
    char dir[2] = {'+', '-'};
    for (k = 0; k < hits->a.n; ++k) 
    { 
        fprintf(stderr, "%.*s\t%c\ts-utg%.6dl\t%lu\t%c\te-utg%.6dl\t%lu\ti:%lu\n", 
        (int)(r1.name_Len.a[hits->a.a[k].id + 1] - r1.name_Len.a[hits->a.a[k].id]), 
        r1.name.a + r1.name_Len.a[hits->a.a[k].id],
        dir[hits->a.a[k].s>>63], (int)((hits->a.a[k].s<<1)>>shif)+1, hits->a.a[k].s&idx->pos_mode,
        dir[hits->a.a[k].e>>63], (int)((hits->a.a[k].e<<1)>>shif)+1, hits->a.a[k].e&idx->pos_mode,
        hits->a.a[k].id);        
    }
    destory_reads(&r1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x40, %ebx
subq 0x18(%rdi), %rbx
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x13d591
cmpq $0x0, (%r15)
jne 0x13ddc9
leaq 0x8(%rsp), %rdi
callq 0x13dd5e
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1c29d
jmp 0x13ddb5
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: print_hits_simp(ha_ug_index*, kvec_pe_hit*)
void print_hits_simp(ha_ug_index* idx, kvec_pe_hit* hits)
{
    uint64_t k, shif = 64 - idx->uID_bits;
    char dir[2] = {'+', '-'};
    for (k = 0; k < hits->a.n; ++k) 
    { 
        if(((hits->a.a[k].s<<1)>>shif) == ((hits->a.a[k].e<<1)>>shif)) continue;
        fprintf(stderr, "r-%lu-th\t%c\trs-utg%.6dl\t%lu\t%c\tre-utg%.6dl\t%lu\n", 
        hits->a.a[k].id,
        dir[hits->a.a[k].s>>63], (int)((hits->a.a[k].s<<1)>>shif)+1, hits->a.a[k].s&idx->pos_mode,
        dir[hits->a.a[k].e>>63], (int)((hits->a.a[k].e<<1)>>shif)+1, hits->a.a[k].e&idx->pos_mode);        
    }
}

// Assembly:
movq (%rsi), %rax
testq %rax, %rax
je 0x13dea6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x40, %r15d
subq 0x18(%rdi), %r15
movl $0x10, %r13d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdx
movq -0x10(%rdx,%r13), %r9
leaq (%r9,%r9), %r8
movl %r15d, %ecx
shrq %cl, %r8
movq -0x8(%rdx,%r13), %rsi
leaq (%rsi,%rsi), %r10
shrq %cl, %r10
cmpq %r10, %r8
jne 0x13de40
incq %r12
addq $0x20, %r13
cmpq %rax, %r12
jb 0x13de0e
jmp 0x13de98
movq 0x157199(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
movq (%rdx,%r13), %rdx
movq %r9, %rax
shrq $0x3f, %rax
leaq 0xfd440(%rip), %rbp     # 0x23b29c
movsbl (%rax,%rbp), %ecx
incl %r8d
movq 0x30(%r14), %r11
andq %r11, %r9
andq %rsi, %r11
shrq $0x3f, %rsi
movsbl (%rsi,%rbp), %ebp
incl %r10d
subq $0x8, %rsp
leaq 0xfd5dc(%rip), %rsi     # 0x23b45f
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %rbp
callq 0x22b0
addq $0x20, %rsp
movq (%rbx), %rax
jmp 0x13de32
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: destory_bubbles(bubble_type*)
void destory_bubbles(bubble_type* bub)
{
    if(bub->index) free(bub->index);
    kv_destroy(bub->list);
    kv_destroy(bub->num);
    kv_destroy(bub->pathLen);
    kv_destroy(bub->b_s_idx);
    kv_destroy(bub->chain_weight);
    asg_destroy(bub->b_g);
    ma_ug_destroy(bub->b_ug);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x13deb8
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
callq 0x2220
movq 0x58(%rbx), %rdi
callq 0x2220
movq 0x70(%rbx), %rdi
callq 0x2220
movq 0xd8(%rbx), %rdi
callq 0x2220
movq 0xb8(%rbx), %rdi
callq 0xa0494
movq 0xc0(%rbx), %rdi
popq %rbx
jmp 0xa0761
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: get_bubbles(bubble_type*, unsigned long, unsigned int*, unsigned int*, unsigned int**, unsigned int*, unsigned long*)
void get_bubbles(bubble_type* bub, uint64_t id, uint32_t* beg, uint32_t* sink, uint32_t** a, uint32_t* n, uint64_t* pathBase)
{
    if(a) (*a) = bub->list.a + bub->num.a[id] + 2;
    if(n) (*n) = bub->num.a[id+1] - bub->num.a[id] - 2;
    if(beg) (*beg) = bub->list.a[bub->num.a[id]];
    if(sink) (*sink) = bub->list.a[bub->num.a[id] + 1];
    if(pathBase) (*pathBase) = bub->pathLen.a[id];
}

// Assembly:
testq %r8, %r8
je 0x13df1d
movq 0x28(%rdi), %rax
movq 0x40(%rdi), %r10
movl (%r10,%rsi,4), %r10d
leaq (%rax,%r10,4), %rax
addq $0x8, %rax
movq %rax, (%r8)
testq %r9, %r9
je 0x13df36
movq 0x40(%rdi), %rax
movl 0x4(%rax,%rsi,4), %r8d
subl (%rax,%rsi,4), %r8d
addl $-0x2, %r8d
movl %r8d, (%r9)
testq %rdx, %rdx
je 0x13df4d
movq 0x28(%rdi), %rax
movq 0x40(%rdi), %r8
movl (%r8,%rsi,4), %r8d
movl (%rax,%r8,4), %eax
movl %eax, (%rdx)
movq 0x8(%rsp), %rax
testq %rcx, %rcx
je 0x13df6c
movq 0x28(%rdi), %rdx
movq 0x40(%rdi), %r8
movl (%r8,%rsi,4), %r8d
incl %r8d
movl (%rdx,%r8,4), %edx
movl %edx, (%rcx)
testq %rax, %rax
je 0x13df7c
movq 0x58(%rdi), %rcx
movq (%rcx,%rsi,8), %rcx
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: get_unitig_het_arb(ma_ug_t*, unsigned int, unsigned char*, kv_u_trans_t*, unsigned int, unsigned int, unsigned int, unsigned int)
uint32_t get_unitig_het_arb(ma_ug_t* ug, uint32_t uid, uint8_t *r_het_flag, kv_u_trans_t *ref, uint32_t m_het_occ,
uint32_t m_het_label, uint32_t p_het_label, uint32_t n_het_label)
{
    if(ref && ref->idx.n > 0 && u_trans_n(*ref, uid) > 0) return m_het_label;
    ma_utg_t *u = &(ug->u.a[uid]);
    uint32_t k, rId;
    uint32_t het_occ, hom_occ;
    for (k = 0, het_occ = hom_occ = 0; k < u->n; k++)
    {
        rId = u->a[k]>>33;
        if((r_het_flag[rId] & P_HET)) return m_het_label;
        if((r_het_flag[rId] & C_HET) || (r_het_flag[rId] & P_HET))
        {
            het_occ++;
        }
        else
        {
            hom_occ++;
        }
    }

    if((het_occ+hom_occ) == 0) return n_het_label; ///hom
    if((het_occ > ((het_occ+hom_occ)*0.8)) && ((het_occ+hom_occ) > m_het_occ)) return m_het_label; ///must het
    if(het_occ >= hom_occ) return p_het_label; ///potential het
    return n_het_label; ///hom
}

// Assembly:
movl %r9d, %eax
movl %esi, %esi
testq %rcx, %rcx
je 0x13e81c
cmpq $0x0, 0x18(%rcx)
je 0x13e81c
movq 0x28(%rcx), %rcx
cmpl $0x0, (%rcx,%rsi,8)
je 0x13e81c
retq
movq 0x10(%rdi), %rcx
leaq (%rsi,%rsi,4), %rsi
movl 0x10(%rcx,%rsi,8), %edi
testq %rdi, %rdi
je 0x13e867
leaq (%rcx,%rsi,8), %rcx
movq 0x18(%rcx), %r9
xorl %r10d, %r10d
xorl %esi, %esi
xorl %ecx, %ecx
movq (%r9,%r10,8), %r11
shrq $0x21, %r11
movzbl (%rdx,%r11), %r11d
testb $0x2, %r11b
jne 0x13e81b
andl $0x1, %r11d
addl %r11d, %ecx
xorl $0x1, %r11d
addl %r11d, %esi
incq %r10
cmpq %r10, %rdi
jne 0x13e83c
jmp 0x13e86b
xorl %ecx, %ecx
xorl %esi, %esi
movl 0x10(%rsp), %edx
movl %esi, %edi
addl %ecx, %edi
je 0x13e89e
cmpl %r8d, %edi
jbe 0x13e897
movl %ecx, %r8d
cvtsi2sd %r8, %xmm0
movl %edi, %edi
cvtsi2sd %rdi, %xmm1
mulsd 0xf2d1f(%rip), %xmm1    # 0x2315b0
ucomisd %xmm1, %xmm0
ja 0x13e81b
cmpl %esi, %ecx
cmovael 0x8(%rsp), %edx
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: update_bub_b_s_idx(bubble_type*)
void update_bub_b_s_idx(bubble_type* bub) 
{
    memset(bub->b_s_idx.a, -1, bub->b_s_idx.n * sizeof(uint64_t));
    uint32_t i, v, beg, sink, n_bub = bub->num.n - 1;
    for (i = 0; i < n_bub; i++)
    {
        get_bubbles(bub, i, &beg, &sink, NULL, NULL, NULL);

        if(beg != (uint32_t)-1)
        {
            v = beg>>1;
            if(bub->b_s_idx.a[v] == (uint64_t)-1)
            {
                bub->b_s_idx.a[v] <<= 32;
                bub->b_s_idx.a[v] |= i;
            }
            else if((bub->b_s_idx.a[v] & 0xffffffff00000000) == 0xffffffff00000000)
            {
                bub->b_s_idx.a[v] <<= 32;
                bub->b_s_idx.a[v] |= i;
            }
        }

        

        if(sink != (uint32_t)-1)
        {
            v = sink>>1;
            if(bub->b_s_idx.a[v] == (uint64_t)-1)
            {
                bub->b_s_idx.a[v] <<= 32;
                bub->b_s_idx.a[v] |= i;
            }
            else if((bub->b_s_idx.a[v] & 0xffffffff00000000) == 0xffffffff00000000)
            {
                bub->b_s_idx.a[v] <<= 32;
                bub->b_s_idx.a[v] |= i;
            }
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdx
movq 0x70(%rdi), %rdi
shlq $0x3, %rdx
movl $0xff, %esi
callq 0x20e0
movl 0x30(%rbx), %esi
decl %esi
je 0x13f393
movabsq $-0x100000001, %rax     # imm = 0xFFFFFFFEFFFFFFFF
movq 0x28(%rbx), %rcx
movq 0x40(%rbx), %rdx
movl %esi, %esi
xorl %edi, %edi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl (%rdx,%rdi,4), %r9d
movl (%rcx,%r9,4), %r10d
incl %r9d
movl (%rcx,%r9,4), %r9d
cmpq %r8, %r10
je 0x13f35b
shrl %r10d
movq 0x70(%rbx), %r11
movq (%r11,%r10,8), %r14
cmpq $-0x1, %r14
je 0x13f350
cmpq %rax, %r14
jbe 0x13f35b
shlq $0x20, %r14
orq %rdi, %r14
jmp 0x13f357
leaq (%rax,%rdi), %r14
incq %r14
movq %r14, (%r11,%r10,8)
cmpl $-0x1, %r9d
je 0x13f38b
shrl %r9d
movq 0x70(%rbx), %r10
movq (%r10,%r9,8), %r11
cmpq $-0x1, %r11
je 0x13f380
cmpq %rax, %r11
jbe 0x13f38b
shlq $0x20, %r11
orq %rdi, %r11
jmp 0x13f387
leaq (%rax,%rdi), %r11
incq %r11
movq %r11, (%r10,%r9,8)
incq %rdi
cmpq %rdi, %rsi
jne 0x13f31d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: push_hc_edge(hc_linkeage*, unsigned long, double, int, unsigned long*)
hc_edge* push_hc_edge(hc_linkeage* x, uint64_t uID, double weight, int dir, uint64_t* d)
{
    uint64_t k, n;
    hc_edge* a = NULL;
    hc_edge* p = NULL;
    if(dir == 0)
    {
        a = x->e.a;
        n = x->e.n;
    }
    else
    {
        a = x->f.a;
        n = x->f.n;
    }
    
    for (k = 0; k < n; k++)
    {
        if(a[k].del) continue;
        if(a[k].uID == uID)
        {
            a[k].weight += weight;
            if(d) a[k].dis = (*d);
            return &(a[k]);
        }
    }

    if(dir == 0)
    {
        kv_pushp(hc_edge, x->e, &p);
    }
    else
    {
        kv_pushp(hc_edge, x->f, &p);
    }
    
    ///p->del = p->enzyme = 0;
    p->del = 0;
    p->uID = uID;
    p->weight = weight;
    if(d) p->dis = (*d);
    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rdi), %rax
leaq 0x10(%rdi), %rcx
leaq 0x18(%rdi), %rsi
testl %edx, %edx
cmoveq %rcx, %rax
cmoveq %rdi, %rsi
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x14172e
movq (%rax), %rax
cmpb $0x0, 0x18(%rax)
js 0x141725
movl 0x8(%rax), %esi
cmpq %r14, %rsi
je 0x1417df
addq $0x28, %rax
decq %rcx
jne 0x141713
testl %edx, %edx
je 0x141782
movq 0x18(%r15), %rcx
movq 0x28(%r15), %rax
cmpq 0x20(%r15), %rcx
jne 0x141778
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
movl $0x2, %ecx
cmovneq %rdx, %rcx
movq %rcx, 0x20(%r15)
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rsi
movq %rax, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2370
movsd 0x8(%rsp), %xmm0
movq %rax, 0x28(%r15)
movq 0x18(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%r15)
jmp 0x1417cd
movq (%r15), %rcx
movq 0x10(%r15), %rax
cmpq 0x8(%r15), %rcx
jne 0x1417c6
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
movl $0x2, %ecx
cmovneq %rdx, %rcx
movq %rcx, 0x8(%r15)
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rsi
movq %rax, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2370
movsd 0x8(%rsp), %xmm0
movq %rax, 0x10(%r15)
movq (%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r15)
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rax
andb $0x7f, 0x18(%rax)
movl %r14d, 0x8(%rax)
jmp 0x1417e3
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
testq %rbx, %rbx
je 0x1417f3
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: get_enzyme_occ_debug(char*, long long, char*, long long)
long long get_enzyme_occ_debug(char* t, long long tlen, char* p, long long plen)
{
    long long s = 0, j, occ = 0;
    while(s <= (tlen - plen)) 
    { 
        j = plen-1; 

        while(j >= 0)
        {
            if(seq_nt4_table[(uint8_t)t[s+j]] >= 4) break;
            if((p[j] != t[s+j]) && seq_nt4_table[(uint8_t)p[j]] < 4) break;
            j--; 
        } 
        
        if (j < 0) occ++;
        s++;
    } 

    return occ;
}

// Assembly:
subq %rcx, %rsi
jge 0x141805
xorl %eax, %eax
retq
pushq %rbx
incq %rsi
decq %rdi
xorl %eax, %eax
leaq 0xf840b(%rip), %r8      # 0x239c20
xorl %r9d, %r9d
testq %rcx, %rcx
jle 0x14185a
movq %rcx, %r10
movzbl (%rdi,%r10), %r11d
cmpb $0x3, (%r8,%r11)
ja 0x14184e
movzbl -0x1(%rdx,%r10), %ebx
cmpb %r11b, %bl
je 0x14183e
cmpb $0x4, (%r8,%rbx)
jb 0x14184e
decq %r10
leaq 0x1(%r10), %r11
cmpq $0x1, %r11
ja 0x141820
xorl %r10d, %r10d
xorl %r11d, %r11d
testq %r10, %r10
sete %r11b
jmp 0x141860
movl $0x1, %r11d
addq %r11, %rax
incq %r9
incq %rdi
cmpq %rsi, %r9
jne 0x141818
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: check_exact_match(char*, long long, char*, long long)
int check_exact_match(char* x, long long xlen, char* y, long long ylen)
{
    long long i;
    if(xlen != ylen) return 0;
    for (i = 0; i < xlen; i++)
    {
        if(seq_nt4_table[(uint8_t)x[i]] >= 4) return 0;
        if((x[i] != y[i]) && seq_nt4_table[(uint8_t)y[i]] < 4) return 0;
    } 

    return 1;
}

// Assembly:
xorl %eax, %eax
cmpq %rcx, %rsi
jne 0x1418af
movl $0x1, %eax
testq %rsi, %rsi
jle 0x1418af
xorl %ecx, %ecx
leaq 0xf8396(%rip), %r8      # 0x239c20
movzbl (%rdi,%rcx), %r9d
cmpb $0x3, (%r8,%r9)
ja 0x1418b0
movzbl (%rdx,%rcx), %r10d
cmpb %r10b, %r9b
je 0x1418a7
cmpb $0x4, (%r8,%r10)
jb 0x1418b0
incq %rcx
cmpq %rcx, %rsi
jne 0x14188a
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: get_enzyme_occ(char*, long long, char*, long long)
long long get_enzyme_occ(char* t, long long tlen, char* p, long long plen)
{
    long long i, c, s = 0, j, occ = 0;
    int badchar[5]; badchar[0] = badchar[1] = badchar[2] = badchar[3] = badchar[4] = -1;
    for (i = 0; i < plen; i++)
    {
        c = seq_nt4_table[(uint8_t)p[i]];
        badchar[c] = i; 
        if(c == 4) badchar[0] = badchar[1] = badchar[2] = badchar[3] = i; 
    } 
    badchar[4] = -1;

    while(s <= (tlen - plen)) 
    { 
        j = plen-1; 

        while(j >= 0)
        {
            if(seq_nt4_table[(uint8_t)t[s+j]] >= 4) break;
            if((p[j] != t[s+j]) && seq_nt4_table[(uint8_t)p[j]] < 4) break;
            j--; 
        } 
        
            
        if (j < 0) 
        { 
            occ++;
            ///s += (s+m < n)? m-badchar[txt[s+m]] : 1; 
            s++;
        } 
        else
        {
            /*******************************for debug************************************/
            // long long f, end = s + MAX(1, j - badchar[seq_nt4_table[(uint8_t)t[s+j]]]);
            // for (f = s+1; f < end; f++)
            // {
            //     if(check_exact_match(t+f, plen, p, plen))
            //     {
            //         fprintf(stderr, "s: %lld, end: %lld, s+j: %lld, t[s+j]: %c, badchar: %d, j: %lld\n", 
            //                     s, end, s+j, t[s+j], badchar[seq_nt4_table[(uint8_t)t[s+j]]], j);
            //     }
            // }            
            /*******************************for debug************************************/
            
            s += MAX(1, j - badchar[seq_nt4_table[(uint8_t)t[s+j]]]); 
        }
    } 

    return occ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, -0x20(%rsp)
testq %rcx, %rcx
jle 0x141900
xorl %eax, %eax
leaq 0xf834c(%rip), %r8      # 0x239c20
movzbl (%rdx,%rax), %r9d
movzbl (%r8,%r9), %r9d
movl %eax, -0x20(%rsp,%r9,4)
cmpl $0x4, %r9d
jne 0x1418f8
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, -0x20(%rsp)
incq %rax
cmpq %rax, %rcx
jne 0x1418d4
movl $0xffffffff, -0x10(%rsp) # imm = 0xFFFFFFFF
subq %rcx, %rsi
js 0x141982
leaq -0x1(%rcx), %r8
xorl %eax, %eax
leaq 0xf8306(%rip), %r9      # 0x239c20
movl $0x1, %r10d
xorl %r11d, %r11d
testq %rcx, %rcx
jle 0x141960
leaq (%rdi,%r11), %r14
movq %r8, %rbx
movzbl (%r14,%rbx), %r12d
movzbl (%r9,%r12), %r15d
cmpq $0x3, %r15
ja 0x141968
movzbl (%rdx,%rbx), %r13d
cmpb %r12b, %r13b
je 0x141950
cmpb $0x4, (%r9,%r13)
jb 0x141968
leaq -0x1(%rbx), %r15
incq %rbx
cmpq $0x1, %rbx
movq %r15, %rbx
ja 0x14192f
incq %rax
incq %r11
jmp 0x14197b
movslq -0x20(%rsp,%r15,4), %r14
subq %r14, %rbx
cmpq $0x2, %rbx
cmovlq %r10, %rbx
addq %rbx, %r11
cmpq %rsi, %r11
jle 0x141923
jmp 0x141984
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: push_pdq(pdq*, unsigned long, unsigned long)
void push_pdq(pdq* q, uint64_t v, uint64_t dis)
{
    kv_push(uint64_t, q->x, set_dv_adv(v, dis, q->uID_mode, q->uID_shift));
    pdq_cnt(*q)++;
    int c_i = pdq_cnt(*q), p_i = c_i>>1;

    while ((p_i > 0) && (weight(*q, c_i) < weight(*q, p_i)))
    {
        swap_pdq(&(q->x.a[c_i]), &(q->x.a[p_i]));
        c_i  = p_i;
        p_i = c_i >> 1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdx
cmpq 0x20(%rdi), %rdx
jne 0x141ac9
leaq (%rdx,%rdx), %rax
testq %rdx, %rdx
movl $0x2, %esi
cmovneq %rax, %rsi
movq %rsi, 0x20(%rbx)
movq 0x28(%rbx), %rdi
shlq $0x3, %rsi
callq 0x2370
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %rdx
jmp 0x141acd
movq 0x28(%rbx), %rax
movb 0x50(%rbx), %cl
shlq %cl, %r15
andq 0x48(%rbx), %r14
orq %r15, %r14
leaq 0x1(%rdx), %rcx
movq %rcx, 0x18(%rbx)
movq %r14, (%rax,%rdx,8)
movq (%rax), %rdx
incq %rdx
movq %rdx, (%rax)
movl %edx, %ecx
sarl %ecx
testl %ecx, %ecx
jle 0x141b4a
movslq %edx, %rsi
movl %ecx, %edx
movq (%rax,%rsi,8), %r8
movq 0x48(%rbx), %r9
movb 0x50(%rbx), %cl
movq %r9, %rdi
andq %r8, %rdi
movq %rdi, 0x58(%rbx)
shrq %cl, %r8
movq %r8, 0x60(%rbx)
movl %edx, %edi
movq (%rax,%rdi,8), %r10
andq %r10, %r9
shrq %cl, %r10
movq %r9, 0x58(%rbx)
movq %r10, 0x60(%rbx)
cmpq %r10, %r8
jae 0x141b4a
movq (%rax,%rsi,8), %rcx
movq (%rax,%rdi,8), %r8
movq %r8, (%rax,%rsi,8)
movq %rcx, (%rax,%rdi,8)
movl %edi, %ecx
shrl %ecx
cmpl $0x1, %edi
ja 0x141af7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: pop_pdq(pdq*, unsigned long*, unsigned long*)
void pop_pdq(pdq* q, uint64_t* min_v, uint64_t* min_dis)
{
    (*min_v) = (*min_dis) = (uint64_t)-1;
    if(pdq_cnt(*q) == 0) return;
    get_dv_adv((*q).x.a[1], (*q).uID_mode, (*q).uID_shift, min_v, min_dis);
    /*******************************for debug************************************/
    // uint64_t i;
    // for (i = 1; i < q->x.n; i++)
    // {
    //     if(weight(*q, i) < (*min_dis)) fprintf(stderr, "ERROR\n");
    // }
    /*******************************for debug************************************/
    ///min = q->x.a[1];
    swap_pdq(&(q->x.a[1]), &(q->x.a[pdq_cnt(*q)]));
    pdq_cnt(*q)--;
    q->x.n--;

    int c_i = 1, left_i, right_i, min_i, flag = 1;
    while(flag == 1) 
    {
        flag = 0;
        left_i = c_i << 1;
        right_i = left_i + 1;
        if(left_i > (int)(pdq_cnt(*q)))
        {
            break; // both children are null
        } 
        else if(right_i > (int)(pdq_cnt(*q)))
        {
            min_i = left_i; // right children is null
        }
        else
        {
            min_i = (weight(*q, left_i) < weight(*q, right_i))? left_i : right_i;
        }

        if(weight(*q, c_i) > weight(*q, min_i))
        {
            swap_pdq(&(q->x.a[c_i]), &(q->x.a[min_i]));
            c_i = min_i;
            flag = 1;
        }
    }
}

// Assembly:
pushq %rbx
movq $-0x1, %rax
movq %rax, (%rdx)
movq %rax, (%rsi)
movq 0x28(%rdi), %rax
cmpq $0x0, (%rax)
je 0x141c62
movq 0x8(%rax), %r8
movb 0x50(%rdi), %cl
movq 0x48(%rdi), %r9
andq %r8, %r9
movq %r9, (%rsi)
shrq %cl, %r8
movq %r8, (%rdx)
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq (%rax,%rcx,8), %rsi
movq %rsi, 0x8(%rax)
movq %rdx, (%rax,%rcx,8)
decq (%rax)
decq 0x18(%rdi)
movl (%rax), %r11d
cmpl $0x2, %r11d
jl 0x141c62
movl $0x1, %r8d
movl $0x2, %esi
movl $0x3, %r9d
movq 0x48(%rdi), %rdx
movq 0x50(%rdi), %rcx
cmpl %r11d, %esi
jge 0x141c00
movslq %esi, %r10
movq (%rax,%r10,8), %r10
movq %rdx, %r11
andq %r10, %r11
movq %r11, 0x58(%rdi)
shrq %cl, %r10
movq %r10, 0x60(%rdi)
movslq %r9d, %r11
movq (%rax,%r11,8), %r11
movq %r11, %rbx
shrq %cl, %r11
andq %rdx, %rbx
movq %rbx, 0x58(%rdi)
movq %r11, 0x60(%rdi)
cmpq %r11, %r10
jb 0x141c00
movl %r9d, %esi
movl %esi, %r10d
movslq %r8d, %rsi
movq (%rax,%rsi,8), %r9
movq %rdx, %r8
andq %r9, %r8
movq %r8, 0x58(%rdi)
shrq %cl, %r9
movq %r9, 0x60(%rdi)
movslq %r10d, %r8
movq (%rax,%r8,8), %r11
andq %r11, %rdx
shrq %cl, %r11
movq %rdx, 0x58(%rdi)
movq %r11, 0x60(%rdi)
cmpq %r11, %r9
jbe 0x141c62
movq (%rax,%rsi,8), %rcx
movq (%rax,%r8,8), %rdx
movq %rdx, (%rax,%rsi,8)
movq %rcx, (%rax,%r8,8)
movl %r8d, %esi
addl %r8d, %esi
leal 0x1(,%r8,2), %r9d
movl (%rax), %r11d
movl %r10d, %r8d
cmpl %r11d, %esi
jle 0x141bbb
popq %rbx
retq