LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_cnt_insert_list(ha_pt_s*, int, unsigned long const*)
int ha_pt_cnt_insert_list(ha_pt_t *h, int n, const uint64_t *a)
{
	int j, mask = (1<<h->pre) - 1, n_ins = 0;
	ha_pt1_t *g;
	if (n == 0) return 0;
	g = &h->h[a[0]&mask];
	for (j = 0; j < n; ++j) {
		uint64_t x = a[j] >> h->pre;
		khint_t k;
		assert((a[j]&mask) == (a[0]&mask));
		k = yak_pt_get(g->h, x<<YAK_COUNTER_BITS);
		if (k == kh_end(g->h)) continue; // TODO: understand why we sometimes come here
		++kh_val(g->h, k);
		++n_ins;
	}
	// fprintf(stderr, "n: %d, n_ins: %d\n", n, n_ins);
	return n_ins;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
testl %esi, %esi
je 0x113900
movl 0x4(%rdi), %ecx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rsp)
shll %cl, %r12d
testl %esi, %esi
jle 0x113900
movq %rdx, %rbx
notl %r12d
movl %r12d, %r13d
andl (%rdx), %r13d
shlq $0x5, %r13
addq 0x18(%rdi), %r13
movl %esi, %eax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
movq (%rbx,%r14,8), %rsi
movl (%rbx), %eax
xorl %esi, %eax
testl %r12d, %eax
jne 0x113911
movq 0x10(%rsp), %rcx
shrq %cl, %rsi
movq (%r13), %r15
shlq $0xc, %rsi
movq %r15, %rdi
callq 0x1137f5
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x1138e3
movb (%r15), %cl
movl $0x1, %esi
shll %cl, %esi
jmp 0x1138e5
xorl %esi, %esi
cmpl %esi, %eax
je 0x1138f6
movl %eax, %eax
shlq $0x4, %rax
incq 0x8(%rdx,%rax)
incl %ebp
incq %r14
cmpq %r14, 0x8(%rsp)
jne 0x1138a9
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11a26a(%rip), %rdi    # 0x22db82
leaq 0x11a210(%rip), %rsi    # 0x22db2f
leaq 0x11a277(%rip), %rcx    # 0x22db9d
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_destroy(ha_pt_s*)
void ha_pt_destroy(ha_pt_t *h)
{
	int i;
	if (h == 0) return;
	for (i = 0; i < 1<<h->pre; ++i) {
		yak_pt_destroy(h->h[i].h);
		if(h->h[i].a){
			free(h->h[i].a); h->h[i].a = NULL;
		}
		if(h->h[i].al){
			free(h->h[i].al); h->h[i].al = NULL;
		}	
	}
	free(h->h); free(h);
}

// Assembly:
testq %rdi, %rdi
je 0x1139c8
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1f, 0x4(%rdi)
je 0x1139b2
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x1139c9
movq 0x18(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x11397a
callq 0x2220
movq 0x18(%rbx), %rax
movq $0x0, 0x10(%rax,%r14)
movq 0x18(%rbx), %rax
movq 0x18(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x11399a
callq 0x2220
movq 0x18(%rbx), %rax
movq $0x0, 0x18(%rax,%r14)
movb 0x4(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
incq %r15
cltq
addq $0x20, %r14
cmpq %rax, %r15
jl 0x11394d
movq 0x18(%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_get(ha_pt_s const*, unsigned long, int*)
const ha_idxpos_t *ha_pt_get(const ha_pt_t *h, uint64_t hash, int *n)
{
	khint_t k;
	const ha_pt1_t *g = &h->h[hash & ((1ULL<<h->pre) - 1)];
	*n = 0;
	k = yak_pt_get(g->h, hash >> h->pre << YAK_COUNTER_BITS);
	if (k == kh_end(g->h)) return 0;
	*n = kh_key(g->h, k) & YAK_MAX_COUNT;
	return &g->a[kh_val(g->h, k)];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movb 0x4(%rdi), %cl
movq $-0x1, %r12
shlq %cl, %r12
movq 0x18(%rdi), %r15
notq %r12
andq %rsi, %r12
shlq $0x5, %r12
movl $0x0, (%rdx)
movq (%r15,%r12), %r14
movb 0x4(%rdi), %cl
shrq %cl, %rsi
shlq $0xc, %rsi
movq %r14, %rdi
callq 0x1137f5
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x113a45
movb (%r14), %cl
movl $0x1, %esi
shll %cl, %esi
jmp 0x113a47
xorl %esi, %esi
cmpl %esi, %eax
jne 0x113a4f
xorl %eax, %eax
jmp 0x113a6f
addq %r12, %r15
movl %eax, %eax
shlq $0x4, %rax
movl $0xfff, %ecx            # imm = 0xFFF
andl (%rdx,%rax), %ecx
movl %ecx, (%rbx)
movq 0x8(%rdx,%rax), %rax
shlq $0x3, %rax
addq 0x10(%r15), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ptl_get(ha_pt_s const*, unsigned long, int*)
const ha_idxposl_t *ha_ptl_get(const ha_pt_t *h, uint64_t hash, int *n)
{
	khint_t k;
	const ha_pt1_t *g = &h->h[hash & ((1ULL<<h->pre) - 1)];
	*n = 0;
	k = yak_pt_get(g->h, hash >> h->pre << YAK_COUNTER_BITS);
	if (k == kh_end(g->h)) return 0;
	*n = kh_key(g->h, k) & YAK_MAX_COUNT;
	return &g->al[kh_val(g->h, k)];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movb 0x4(%rdi), %cl
movq $-0x1, %r12
shlq %cl, %r12
movq 0x18(%rdi), %r15
notq %r12
andq %rsi, %r12
shlq $0x5, %r12
movl $0x0, (%rdx)
movq (%r15,%r12), %r14
movb 0x4(%rdi), %cl
shrq %cl, %rsi
shlq $0xc, %rsi
movq %r14, %rdi
callq 0x1137f5
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x113ad2
movb (%r14), %cl
movl $0x1, %esi
shll %cl, %esi
jmp 0x113ad4
xorl %esi, %esi
cmpl %esi, %eax
jne 0x113adc
xorl %eax, %eax
jmp 0x113afc
addq %r12, %r15
movl %eax, %eax
shlq $0x4, %rax
movl $0xfff, %ecx            # imm = 0xFFF
andl (%rdx,%rax), %ecx
movl %ecx, (%rbx)
movq 0x8(%rdx,%rax), %rax
shlq $0x4, %rax
addq 0x18(%r15), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_cnt(ha_pt_s const*, unsigned long)
const int ha_pt_cnt(const ha_pt_t *h, uint64_t hash)
{
	khint_t k;
	const ha_pt1_t *g = &h->h[hash & ((1ULL<<h->pre) - 1)];
	k = yak_pt_get(g->h, hash >> h->pre << YAK_COUNTER_BITS);
	if (k == kh_end(g->h)) return 0;
	return kh_key(g->h, k) & YAK_MAX_COUNT;
}

// Assembly:
pushq %rbx
movq 0x18(%rdi), %rax
movb 0x4(%rdi), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rsi, %rdx
shlq $0x5, %rdx
movq (%rax,%rdx), %rbx
shrq %cl, %rsi
shlq $0xc, %rsi
movq %rbx, %rdi
callq 0x1137f5
movl %eax, %edx
movq 0x10(%rbx), %rsi
xorl %eax, %eax
movl $0x0, %edi
testq %rsi, %rsi
je 0x113b52
movb (%rbx), %cl
movl $0x1, %edi
shll %cl, %edi
cmpl %edi, %edx
je 0x113b64
movl %edx, %ecx
shlq $0x4, %rcx
movl $0xfff, %eax            # imm = 0xFFF
andl (%rsi,%rcx), %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: debug_ct_index(void*, void*)
void debug_ct_index(void* q_ct_idx, void* r_ct_idx)
{
	ha_ct_t* ct_idx = (ha_ct_t*)q_ct_idx;
	yak_ct_t *g = NULL;
	uint64_t i;
	khint_t k;
	for (i = 0; (int)i < 1<<ct_idx->pre; i++)
	{
		g = ct_idx->h[i].h;
		for (k = 0; k < kh_end(g); ++k) 
		{
			if (kh_exist(g, k)) 
			{
				int c = kh_key(g, k) & YAK_MAX_COUNT;
				uint64_t hash = ((kh_key(g, k) >> ct_idx->pre)<<ct_idx->pre) | i;
				int q = query_ct_index(r_ct_idx, hash);
				if(q!=c)
				{
					fprintf(stderr, "ERROR:c: %d, q: %d\n", c, q);
				}
			}
		}
	}
}

// Assembly:
cmpl $0x1f, 0x4(%rdi)
je 0x114b6d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movq 0x20(%r14), %rax
movq %r13, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r12
xorl %r15d, %r15d
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x114ae5
movb (%r12), %cl
movl $0x1, %edx
shlq %cl, %rdx
jmp 0x114ae7
xorl %edx, %edx
cmpq %rdx, %r15
jae 0x114b48
movq 0x8(%r12), %rcx
movl %r15d, %edx
shrl $0x5, %edx
movl (%rcx,%rdx,4), %ecx
btl %r15d, %ecx
jae 0x114b25
movq (%rax,%r15,8), %rsi
movl %esi, %ebp
andl $0xfff, %ebp            # imm = 0xFFF
movb 0x4(%r14), %cl
shrq %cl, %rsi
shlq %cl, %rsi
orq %r13, %rsi
movq %rbx, %rdi
callq 0x114b6e
cmpl %ebp, %eax
jne 0x114b2a
incq %r15
jmp 0x114acd
movq 0x1754af(%rip), %rcx    # 0x289fe0
movq (%rcx), %rdi
leaq 0x11923f(%rip), %rsi    # 0x22dd7a
movl %ebp, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x22b0
jmp 0x114b25
incq %r13
movb 0x4(%r14), %cl
movl $0x1, %eax
shll %cl, %eax
cmpl %r13d, %eax
jg 0x114abb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: query_ct_index(void*, unsigned long)
int query_ct_index(void* ct_idx, uint64_t hash)
{
	ha_ct1_t *g = &(((ha_ct_t*)ct_idx)->h[hash & ((1ULL<<((ha_ct_t*)ct_idx)->pre) - 1)]);
	khint_t k;
	k = yak_ct_get(g->h, hash);
	if (k == kh_end(g->h)) return 0;
	return ((kh_key(g->h, k)&YAK_MAX_COUNT)==YAK_MAX_COUNT)?-1:(kh_key(g->h, k)&YAK_MAX_COUNT);
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rax
movb 0x4(%rdi), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rsi, %rdx
shlq $0x4, %rdx
movq (%rax,%rdx), %rbx
movq %rbx, %rdi
callq 0x1151b4
movl %eax, %edx
movq 0x10(%rbx), %rsi
xorl %eax, %eax
movl $0x0, %edi
testq %rsi, %rsi
je 0x114bb1
movb (%rbx), %cl
movl $0x1, %edi
shll %cl, %edi
cmpl %edi, %edx
je 0x114bce
movl %edx, %eax
movl $0xfff, %ecx            # imm = 0xFFF
movq (%rsi,%rax,8), %rdx
andq %rcx, %rdx
cmpq %rcx, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %edx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_destroy(ha_ct_t*)
static void ha_ct_destroy(ha_ct_t *h)
{
	int i;
	if (h == 0) return;
	ha_ct_destroy_bf(h);
	for (i = 0; i < 1<<h->pre; ++i)
		yak_ct_destroy(h->h[i].h);
	free(h->h); free(h);
}

// Assembly:
testq %rdi, %rdi
je 0x114e0f
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1132c7
cmpl $0x1f, 0x4(%rbx)
je 0x114df9
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x1160e2
movb 0x4(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
incq %r15
cltq
addq $0x10, %r14
cmpq %rax, %r15
jl 0x114dd4
movq 0x20(%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: write_ct_index(void*, char*)
int write_ct_index(void *i_ct_idx, char* file_name)
{
	char* gfa_name = (char*)malloc(strlen(file_name)+25);
    sprintf(gfa_name, "%s.ct_flt", file_name);
    FILE* fp = fopen(gfa_name, "w");
	if (!fp) {
		free(gfa_name);
        return 0;
    }
	ha_ct_t* ct_idx = (ha_ct_t*)i_ct_idx;
	int i;
	ha_ct1_t *g;
	fwrite(&ct_idx->k, sizeof(ct_idx->k), 1, fp);
	fwrite(&ct_idx->pre, sizeof(ct_idx->pre), 1, fp);
	fwrite(&ct_idx->n_hash, sizeof(ct_idx->n_hash), 1, fp);
	fwrite(&ct_idx->n_shift, sizeof(ct_idx->n_shift), 1, fp);
	fwrite(&ct_idx->tot, sizeof(ct_idx->tot), 1, fp);
	for (i = 0; i < 1<<ct_idx->pre; i++)
	{
		g = &(ct_idx->h[i]);
		yak_ct_save(g->h, fp);
	}


	fprintf(stderr, "[M::%s] Index has been written.\n", __func__);
    free(gfa_name);
	fclose(fp);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x11922c(%rip), %rsi    # 0x22e068
xorl %ebp, %ebp
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x1275ac(%rip), %rsi    # 0x23c3fe
movq %rbx, %rdi
callq 0x2210
testq %rax, %rax
jne 0x114e78
movq %rbx, %rdi
callq 0x2220
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x2410
leaq 0x4(%r14), %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x2410
leaq 0x8(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
leaq 0xc(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
leaq 0x10(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
cmpl $0x1f, 0x4(%r14)
jne 0x114f2b
movq 0x1750e7(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x11916f(%rip), %rsi    # 0x22e072
leaq 0x119189(%rip), %rdx    # 0x22e093
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2190
movl $0x1, %ebp
jmp 0x114e67
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%r14), %rax
movq (%rax,%r13), %rdi
testq %rdi, %rdi
jne 0x114f58
movb (%r12), %cl
movl $0x1, %eax
shll %cl, %eax
incq %rbp
cltq
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x114f30
jmp 0x114ef2
movq %r15, %rsi
callq 0x14830
jmp 0x114f3d
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_hist(ha_ct_t const*, long*, int)
static void ha_ct_hist(const ha_ct_t *h, int64_t cnt[YAK_N_COUNTS], int n_thread)
{
	hist_aux_t a;
	int i, j;
	a.h = h;
	memset(cnt, 0, YAK_N_COUNTS * sizeof(uint64_t));
	CALLOC(a.cnt, n_thread);
	///start 4096 threads
	kt_for(n_thread, worker_ct_hist, &a, 1<<h->pre);
	for (i = 0; i < YAK_N_COUNTS; ++i) cnt[i] = 0;
	for (j = 0; j < n_thread; ++j)
		for (i = 0; i < YAK_N_COUNTS; ++i)
			cnt[i] += a.cnt[j].c[i];
	free(a.cnt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movq %rsp, %r15
movq %rdi, (%r15)
movl $0x8000, %edx           # imm = 0x8000
movq %rsi, %rdi
xorl %esi, %esi
callq 0x20e0
movslq %ebp, %r14
movl $0x8000, %esi           # imm = 0x8000
movq %r14, %rdi
callq 0x2120
movq %rax, 0x8(%r15)
movb 0x4(%r12), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
leaq 0x3d8e(%rip), %rsi      # 0x118d43
movl %r14d, %edi
movq %r15, %rdx
callq 0x1047b4
movl $0x8000, %edx           # imm = 0x8000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20e0
testl %r14d, %r14d
jle 0x115001
movq 0x8(%rsp), %rax
movl %ebp, %ecx
xorl %edx, %edx
xorl %esi, %esi
movq (%rax,%rsi,8), %rdi
addq %rdi, (%rbx,%rsi,8)
incq %rsi
cmpq $0x1000, %rsi           # imm = 0x1000
jne 0x114fdf
incq %rdx
addq $0x8000, %rax           # imm = 0x8000
cmpq %rcx, %rdx
jne 0x114fdd
movq 0x8(%rsp), %rdi
callq 0x2220
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: load_ct_index(void**, char*)
int load_ct_index(void **i_ct_idx, char* file_name)
{
	char* gfa_name = (char*)malloc(strlen(file_name)+25);
    sprintf(gfa_name, "%s.ct_flt", file_name);
    FILE* fp = fopen(gfa_name, "r");
	if (!fp) {
		free(gfa_name);
        return 0;
    }
	ha_ct_t** ct_idx = (ha_ct_t**)i_ct_idx;
	double index_time = 0;
	uint64_t flag = 0;
	int i;
	ha_ct_t *h = 0;
	ha_ct1_t *g;
	CALLOC(h, 1);

	flag += fread(&h->k, sizeof(h->k), 1, fp);
	flag += fread(&h->pre, sizeof(h->pre), 1, fp);
	flag += fread(&h->n_hash, sizeof(h->n_hash), 1, fp);
	flag += fread(&h->n_shift, sizeof(h->n_shift), 1, fp);
	flag += fread(&h->tot, sizeof(h->tot), 1, fp);
	CALLOC(h->h, 1<<h->pre);


	index_time = yak_realtime();
	for (i = 0; i < 1<<h->pre; ++i) 
	{
		g = &(h->h[i]);
		yak_ct_load(&(g->h), fp);
	}

	(*ct_idx) = h;
	fprintf(stderr, "[M::%s::%.3f] ==> Loaded count table\n", __func__, yak_realtime() - index_time);
	fprintf(stderr, "[M::%s] Index has been loaded.\n", __func__);
	free(gfa_name);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %r14
leaq 0x118e29(%rip), %rsi    # 0x22e068
xorl %ebp, %ebp
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x11e352(%rip), %rsi    # 0x2335a7
movq %r14, %rdi
callq 0x2210
testq %rax, %rax
jne 0x115277
movq %r14, %rdi
callq 0x2220
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movq %rbx, %rsi
callq 0x14915
movl $0x1, %ebp
jmp 0x115262
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: uidx_write(void*, ha_pt_s*, char*, ma_ug_t*)
int uidx_write(void *flt_tab, ha_pt_t *ha_idx, char* file_name, ma_ug_t *ug)
{
	char* gfa_name = (char*)malloc(strlen(file_name)+25);
    sprintf(gfa_name, "%s.uidx.bin", file_name);
    FILE* fp = fopen(gfa_name, "w");
    if (!fp) {
        free(gfa_name);
        return 0;
    }

	if(ug) write_dbug(ug, fp);

	yak_ft_t *ha_flt_tab = (yak_ft_t*)flt_tab;

    if(ha_flt_tab)
    {
        fwrite("f", 1, 1, fp);
        yak_ft_save(ha_flt_tab, fp);
    }

	if(ha_idx)
    {
        int i;
        ha_pt1_t *g;
        fwrite("h", 1, 1, fp);
        fwrite(&ha_idx->k, sizeof(ha_idx->k), 1, fp);
        fwrite(&ha_idx->pre, sizeof(ha_idx->pre), 1, fp);
        fwrite(&ha_idx->tot, sizeof(ha_idx->tot), 1, fp);
        fwrite(&ha_idx->tot_pos, sizeof(ha_idx->tot_pos), 1, fp);

        for (i = 0; i < 1<<ha_idx->pre; ++i) 
        {
            g = &(ha_idx->h[i]);
            yak_pt_save(g->h, fp);
            fwrite(&g->n, sizeof(g->n), 1, fp);
            fwrite(g->al, sizeof(ha_idxposl_t), g->n, fp);
        }
    }
	fprintf(stderr, "[M::%s] Index has been written.\n", __func__);
    free(gfa_name);
    fclose(fp);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq %rdx, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x11868d(%rip), %rsi    # 0x22e1ac
xorl %ebp, %ebp
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x1268c9(%rip), %rsi    # 0x23c3fe
movq %rbx, %rdi
callq 0x2210
testq %rax, %rax
jne 0x115b5b
movq %rbx, %rdi
callq 0x2220
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
testq %r13, %r13
je 0x115b6e
movq %r13, %rdi
movq %r15, %rsi
callq 0xc293c
testq %r12, %r12
je 0x115b8b
movl $0x66, %edi
movq %r15, %rsi
callq 0x2270
movq %r12, %rdi
movq %r15, %rsi
callq 0x1154d5
testq %r14, %r14
je 0x115c61
movl $0x68, %edi
movq %r15, %rsi
callq 0x2270
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rcx
callq 0x2410
leaq 0x4(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
leaq 0x8(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
leaq 0x10(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2410
cmpl $0x1f, 0x4(%r14)
je 0x115c61
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x18(%r14), %rax
leaq (%rax,%r13), %r12
addq $0x8, %r12
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x1155be
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x2410
movq (%r12), %rdx
movq 0x10(%r12), %rdi
movl $0x10, %esi
movq %r15, %rcx
callq 0x2410
movb 0x4(%r14), %cl
movl $0x1, %eax
shll %cl, %eax
incq %rbp
cltq
addq $0x20, %r13
cmpq %rax, %rbp
jl 0x115c04
movq 0x174378(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x118400(%rip), %rsi    # 0x22e072
leaq 0x11853f(%rip), %rdx    # 0x22e1b8
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2190
movl $0x1, %ebp
jmp 0x115b4a
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_insert_list(ha_ct_t*, int, int, unsigned long const*)
static int ha_ct_insert_list(ha_ct_t *h, int create_new, int n, const uint64_t *a)
{
	int j, mask = (1<<h->pre) - 1, n_ins = 0;
	ha_ct1_t *g;
	if (n == 0) return 0;
	///corresponding small hash index
	g = &h->h[a[0]&mask];
	for (j = 0; j < n; ++j) {
		int ins = 1, absent;
		///x is a 64-bit word, h->pre=12
		///all elements at a have the same low 12 bits
		///so low 12 bits are not useful
		uint64_t x = a[j] >> h->pre;
		khint_t k;
		assert((a[j]&mask) == (a[0]&mask));
		if (create_new) {
			if (g->b)
				ins = (yak_bf_insert(g->b, x) == h->n_hash);
			///x = the high 52 bits of a[j] + low 12 bits 0
			///the low 12 bits are used for counting
			if (ins) {
				k = yak_ct_put(g->h, x << YAK_COUNTER_BITS | (g->b? 1 : 0), &absent);
				if (absent) ++n_ins;
				if ((kh_key(g->h, k)&YAK_MAX_COUNT) < YAK_MAX_COUNT)
					++kh_key(g->h, k);
			}
		} else {
			k = yak_ct_get(g->h, x<<YAK_COUNTER_BITS);
			if (k != kh_end(g->h) && (kh_key(g->h, k)&YAK_MAX_COUNT) < YAK_MAX_COUNT)
				++kh_key(g->h, k);
		}
	}
	return n_ins;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x0, 0x4(%rsp)
testl %edx, %edx
je 0x1185aa
movq %rcx, %rbx
movq %rdi, %r14
movb 0x4(%rdi), %cl
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
shll %cl, %ebp
testl %edx, %edx
jle 0x1185aa
movl %esi, %r12d
notl %ebp
movq %rbp, 0x20(%rsp)
andl (%rbx), %ebp
shlq $0x4, %rbp
addq 0x20(%r14), %rbp
movl %edx, %eax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
movl $0x0, 0x4(%rsp)
movq %rbx, 0x8(%rsp)
movq (%rbx,%r15,8), %rax
movb 0x4(%r14), %cl
movq %rax, %r13
shrq %cl, %r13
xorl (%rbx), %eax
testl %eax, 0x20(%rsp)
jne 0x1185bd
testl %r12d, %r12d
je 0x118533
movq 0x8(%rbp), %rdi
testq %rdi, %rdi
je 0x1184e9
movq %r13, %rsi
callq 0x112ee1
cmpl 0x8(%r14), %eax
jne 0x11859c
movq (%rbp), %rdi
shlq $0xc, %r13
xorl %esi, %esi
cmpq $0x0, 0x8(%rbp)
setne %sil
orq %r13, %rsi
leaq 0x14(%rsp), %rdx
callq 0x1185dc
cmpl $0x1, 0x14(%rsp)
sbbl $-0x1, 0x4(%rsp)
movq (%rbp), %rcx
movq 0x10(%rcx), %rcx
movl %eax, %edx
movq (%rcx,%rdx,8), %rax
movl %eax, %esi
notl %esi
testl $0xfff, %esi            # imm = 0xFFF
je 0x11859c
leaq (%rcx,%rdx,8), %rcx
jmp 0x118596
movq %r14, %rbx
movl %r12d, %r14d
movq (%rbp), %r12
shlq $0xc, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x1151b4
movq 0x10(%r12), %rdx
testq %rdx, %rdx
je 0x118563
movb (%r12), %cl
movl $0x1, %esi
shll %cl, %esi
jmp 0x118565
xorl %esi, %esi
cmpl %esi, %eax
movl %r14d, %r12d
jne 0x118571
movq %rbx, %r14
jmp 0x118586
movl %eax, %ecx
movq (%rdx,%rcx,8), %rax
movl %eax, %esi
notl %esi
testl $0xfff, %esi            # imm = 0xFFF
movq %rbx, %r14
jne 0x11858d
movq 0x8(%rsp), %rbx
jmp 0x11859c
leaq (%rdx,%rcx,8), %rcx
movq 0x8(%rsp), %rbx
incq %rax
movq %rax, (%rcx)
incq %r15
cmpq %r15, 0x18(%rsp)
jne 0x1184af
movl 0x4(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1155be(%rip), %rdi    # 0x22db82
leaq 0x115564(%rip), %rsi    # 0x22db2f
leaq 0x115dc4(%rip), %rcx    # 0x22e396
movl $0xc3, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: worker_ct_shrink(void*, long, int)
static void worker_ct_shrink(void *data, long i, int tid) // callback for kt_for()
{
	shrink_aux_t *a = (shrink_aux_t*)data;
	ha_ct_t *h = a->h;
	yak_ct_t *g = h->h[i].h, *f;
	khint_t k;
	f = yak_ct_init();
	yak_ct_resize(f, kh_size(g));
	for (k = 0; k < kh_end(g); ++k) {
		if (kh_exist(g, k)) {
			int absent, c = kh_key(g, k) & YAK_MAX_COUNT;
			if (c >= a->min && c <= a->max)
				yak_ct_put(f, kh_key(g, k), &absent);
		}
	}
	yak_ct_destroy(g);
	h->h[i].h = f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rax), %rax
shlq $0x4, %rbx
movq (%rax,%rbx), %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x2120
movq %rax, %r12
movl 0x4(%r15), %esi
movq %rax, %rdi
callq 0x1186d5
xorl %ebp, %ebp
leaq 0x14(%rsp), %r13
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x118aaf
movb (%r15), %cl
movl $0x1, %edx
shlq %cl, %rdx
jmp 0x118ab1
xorl %edx, %edx
cmpq %rdx, %rbp
jae 0x118aed
movq 0x8(%r15), %rcx
movl %ebp, %edx
shrl $0x5, %edx
movl (%rcx,%rdx,4), %ecx
btl %ebp, %ecx
jae 0x118ae8
movq (%rax,%rbp,8), %rsi
movl %esi, %eax
andl $0xfff, %eax            # imm = 0xFFF
cmpl (%r14), %eax
jl 0x118ae8
cmpl 0x4(%r14), %eax
jg 0x118ae8
movq %r12, %rdi
movq %r13, %rdx
callq 0x1185dc
incq %rbp
jmp 0x118a99
movq %r15, %rdi
callq 0x1160e2
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %r12, (%rax,%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/htab.cpp
// Function: worker_ct_hist(void*, long, int)
static void worker_ct_hist(void *data, long i, int tid) // callback for kt_for()
{
	hist_aux_t *a = (hist_aux_t*)data;
	uint64_t *cnt = a->cnt[tid].c;
	yak_ct_t *g = a->h->h[i].h;
	khint_t k;
	for (k = 0; k < kh_end(g); ++k)
		if (kh_exist(g, k))
			++cnt[kh_key(g, k)&YAK_MAX_COUNT];
}

// Assembly:
movslq %edx, %rax
shlq $0xf, %rax
addq 0x8(%rdi), %rax
movq (%rdi), %rcx
movq 0x20(%rcx), %rcx
shlq $0x4, %rsi
movq (%rcx,%rsi), %rdx
movq 0x10(%rdx), %rsi
xorl %edi, %edi
movl $0xfff, %r8d            # imm = 0xFFF
testq %rsi, %rsi
je 0x118d7b
movb (%rdx), %cl
movl $0x1, %r9d
shlq %cl, %r9
jmp 0x118d7e
xorl %r9d, %r9d
cmpq %r9, %rdi
jae 0x118da6
movq 0x8(%rdx), %rcx
movl %edi, %r9d
shrl $0x5, %r9d
movl (%rcx,%r9,4), %ecx
btl %edi, %ecx
jae 0x118da1
movl (%rsi,%rdi,8), %ecx
andl %r8d, %ecx
incq (%rax,%rcx,8)
incq %rdi
jmp 0x118d69
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/hist.cpp
// Function: adj_m_peak_hom(int, int, int, int, int*)
int adj_m_peak_hom(int m_peak_hom, int max_i, int max2_i, int max3_i, int *peak_het)
{
	int64_t mm[3], d, min_i, min_d, i;
	mm[0] = max2_i; mm[1] = max_i; mm[2] = max3_i;
	for (i = 0, min_i = -1, min_d = -1; i < 3; i++){
		if(mm[i] <= 0) continue;
		d = (mm[i] >= m_peak_hom?mm[i]-m_peak_hom:m_peak_hom-mm[i]);
		if(min_d == -1 || min_d > d || (min_d == d && i == 1)){
			min_d = d; min_i = i;
		}
	}
	if(min_i < 0) return m_peak_hom;
	if(mm[min_i] < m_peak_hom){
		d = m_peak_hom - mm[min_i];
		if(d >= mm[min_i]*0.51) {
			*peak_het = mm[min_i];
			return m_peak_hom;
		}
	}

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

// Assembly:
movl %edi, %eax
movslq %edx, %rdx
movq %rdx, -0x18(%rsp)
movslq %esi, %rdx
movq %rdx, -0x10(%rsp)
movslq %ecx, %rcx
movq %rcx, -0x8(%rsp)
movslq %edi, %rdx
movq $-0x1, %rdi
xorl %esi, %esi
movq $-0x1, %rcx
movq -0x18(%rsp,%rsi,8), %r10
testq %r10, %r10
jle 0x118f4b
subq %rdx, %r10
movq %r10, %r9
negq %r9
cmovsq %r10, %r9
cmpq $-0x1, %rdi
sete %r10b
cmpq %r9, %rdi
setg %r11b
orb %r10b, %r11b
jne 0x118f45
cmpq $0x1, %rsi
jne 0x118f4b
cmpq %r9, %rdi
jne 0x118f4b
movq %rsi, %rcx
movq %r9, %rdi
incq %rsi
cmpq $0x3, %rsi
jne 0x118f0f
testq %rcx, %rcx
js 0x118f92
movq -0x18(%rsp,%rcx,8), %rsi
subq %rsi, %rdx
jle 0x118f7b
cvtsi2sd %rdx, %xmm0
cvtsi2sd %rsi, %xmm1
mulsd 0x10c5d3(%rip), %xmm1   # 0x225548
ucomisd %xmm1, %xmm0
jae 0x118f93
testq %rcx, %rcx
jle 0x118f90
movq -0x20(%rsp,%rcx,8), %rax
decq %rcx
testq %rax, %rax
jle 0x118f7b
movl %eax, (%r8)
movl %esi, %eax
retq
movl %esi, (%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/anchor.cpp
// Function: lable_matched_ovlp(overlap_region_alloc*, ma_hit_t_alloc*)
void lable_matched_ovlp(overlap_region_alloc* overlap_list, ma_hit_t_alloc* paf)
{
	uint64_t j = 0, inner_j = 0;
	while (j < overlap_list->length && inner_j < paf->length)
    {
        if(overlap_list->list[j].y_id < paf->buffer[inner_j].tn)
        {
            j++;
        }
        else if(overlap_list->list[j].y_id > paf->buffer[inner_j].tn)
        {
            inner_j++;
        }
        else
        {
            if(overlap_list->list[j].y_pos_strand == paf->buffer[inner_j].rev)
            {
				overlap_list->list[j].is_match = 1;
            }
            j++;
            inner_j++;
        }
    }
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1245e3
pushq %rbp
pushq %r14
pushq %rbx
movl 0xc(%rsi), %ecx
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %rcx, %rdx
jae 0x1245df
movq (%rdi), %rbx
imulq $0xa8, %r8, %r14
leaq (%rbx,%r14), %r9
movq (%rsi), %r10
leaq (%rdx,%rdx,4), %r11
movl 0xc(%r10,%r11,8), %ebp
cmpl %ebp, 0x10(%rbx,%r14)
jae 0x1245bb
incq %r8
jmp 0x1245da
ja 0x1245d7
leaq (%r10,%r11,8), %r10
movl 0x18(%r10), %r10d
shrl $0x1f, %r10d
cmpl %r10d, 0x1c(%r9)
jne 0x1245d4
movb $0x1, 0x2c(%r9)
incq %r8
incq %rdx
cmpq %rax, %r8
jb 0x124590
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/anchor.cpp
// Function: ha_get_ul_candidates_interface(ha_abufl_s*, long, char*, unsigned long, unsigned long, unsigned long, ul_idx_t const*, overlap_region_alloc*, overlap_region_alloc*, Candidates_list*, double, int, int, kvec_t_u8_warp*, kvec_t_u64_warp*, overlap_region*, kvec_t_u64_warp*, st_mt_t*, unsigned int, void*)
void ha_get_ul_candidates_interface(ha_abufl_t *ab, int64_t rid, char* rs, uint64_t rl, uint64_t mz_w, uint64_t mz_k, const ul_idx_t *uref, overlap_region_alloc *overlap_list, overlap_region_alloc *overlap_list_hp, Candidates_list *cl, double bw_thres, 
								 int max_n_chain, int keep_whole_chain, kvec_t_u8_warp* k_flag, kvec_t_u64_warp* chain_idx, overlap_region* f_cigar, kvec_t_u64_warp* dbg_ct, st_mt_t *sp, uint32_t high_occ, void *km)
{
	extern void *ha_flt_tab;
	extern ha_pt_t *ha_idx;

	ha_get_new_ul_candidates(ab, rid, rs, rl, mz_w, mz_k, uref, overlap_list, cl, bw_thres, max_n_chain, keep_whole_chain, k_flag, chain_idx, ha_flt_tab, ha_idx, f_cigar, dbg_ct, sp, high_occ, km);
	if(km) {
		ha_abufl_free_buf(km, ab, 1); 
		destory_Candidates_list_buf(km, cl, 1); 
	}
	ks_introsort_or_xs(overlap_list->length, overlap_list->list);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x70(%rsp)
movq 0x110(%rsp), %r14
movq 0xc8(%rsp), %r15
movq 0xb8(%rsp), %r12
movq 0xb0(%rsp), %rcx
movl 0xd0(%rsp), %eax
movl 0xd8(%rsp), %r10d
movaps 0xe0(%rsp), %xmm1
movaps 0xf0(%rsp), %xmm2
movq 0x100(%rsp), %r11
leaq 0x16698c(%rip), %r13    # 0x28b430
movq (%r13), %r13
leaq 0x166989(%rip), %rbp    # 0x28b438
movq (%rbp), %rbp
movl 0x108(%rsp), %ebx
movl %ebx, 0x60(%rsp)
movq %r15, %rbx
movq %rdi, %r15
movq %r11, 0x58(%rsp)
movq %r14, 0x68(%rsp)
movups %xmm2, 0x48(%rsp)
movq %rbp, 0x40(%rsp)
movq %r13, 0x38(%rsp)
movups %xmm1, 0x28(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x18(%rsp)
movq %rcx, (%rsp)
movq %rbx, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movq 0x70(%rsp), %rcx
callq 0x12324f
testq %r14, %r14
je 0x124b28
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x122a8f
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3fd40
movq (%r12), %rsi
movq 0x10(%r12), %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x120acf
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/anchor.cpp
// Function: lchain_qgen_mcopy_fast_re1(Candidates_list*, unsigned int, overlap_region_alloc*, unsigned int, unsigned long, unsigned long, unsigned int, long, long, long, double, double, double, long, unsigned int, long, double, unsigned int)
void lchain_qgen_mcopy_fast_re1(Candidates_list* cl, uint32_t cl_beg, overlap_region_alloc* ol, uint32_t rid, uint64_t rl, uint64_t tl, 
				uint32_t apend_be, int64_t max_skip, int64_t max_iter, 
				int64_t max_dis, double chn_pen_gap, double chn_pen_skip, double bw_rate, int64_t quick_check, 
				uint32_t gen_off, int64_t enable_mcopy, double mcopy_rate, uint32_t mcopy_khit_cut)
{
	uint64_t cn = cl->length, m = cl_beg;
	if(cl_beg >= cn) return;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r11
movq %rdx, %r9
movq 0x8(%rdi), %rdx
movl %esi, %r14d
subq %r14, %rdx
jbe 0x12962e
movq %r8, %r10
movl %ecx, %eax
movq %rdi, %rbx
movl 0x30(%rsp), %r15d
leaq 0x18(%rdi), %r8
movl 0x58(%rsp), %r12d
movl 0x68(%rsp), %r13d
movq %r14, %rsi
movq %r14, %rcx
pushq $0x1
pushq %r13
pushq 0x70(%rsp)
pushq %r12
pushq %r15
pushq 0x78(%rsp)
pushq %r11
pushq %r10
pushq %rax
pushq 0x90(%rsp)
pushq 0x90(%rsp)
pushq 0x90(%rsp)
callq 0x4287f
addq $0x60, %rsp
addq %r14, %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x337f7
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 0x12c99f
cmpb %dl, -0x2(%r14,%rsi)
movq %r9, %rsi
je 0x12c98a
jmp 0x12c9a2
movq %rax, %r9
movq %r15, %rax
cmpq 0x10(%rsp), %rbx
jle 0x12c9c2
movb -0x1(%r14,%r15), %dl
movq %r15, %rax
cmpb %dl, (%r14,%rax)
jne 0x12c9c2
incq %rax
cmpq %r13, %rax
jl 0x12c9b4
cmpq %rcx, %r9
jne 0x12c9db
cmpq %r15, %rax
jne 0x12c9db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x15d5fe(%rip), %rdx    # 0x289fe0
movq (%rdx), %rdi
addq %r10, %rcx
addq %r10, %r15
addq %r10, %r9
addq %r10, %rax
movq %rax, (%rsp)
leaq 0x10256d(%rip), %rsi    # 0x22ef69
leaq 0x10258b(%rip), %rdx    # 0x22ef8e
movq %r15, %r8
xorl %eax, %eax
callq 0x22b0
jmp 0x12c9cc
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq (%rsi), %rbx
movq (%rdi), %r14
cmpq %r14, %rbx
jbe 0x12dd6b
xorl %eax, %eax
jmp 0x12de23
movq 0x38(%rsp), %r10
movq 0x30(%rsp), %r11
xorl %eax, %eax
cmpq %r14, %rbx
je 0x12dd99
movq 0x30(%rdi), %r14
leaq (%rbx,%rbx,2), %rbx
movq (%rdx), %r15
leaq (%r15,%r15,2), %r15
movq (%r14,%r15,8), %r15
xorq (%r14,%rbx,8), %r15
shrq $0x20, %r15
je 0x12de0e
movq (%rcx), %rbx
cmpq %r9, %rbx
setb %bpl
jae 0x12de08
movq 0x30(%rdi), %r14
movl 0x4(%r8,%rbx,8), %r15d
movq (%rdx), %r12
leaq (%r12,%r12,2), %r12
cmpl 0x4(%r14,%r12,8), %r15d
jae 0x12dde7
incq %rbx
movq %rbx, (%rcx)
cmpq %rbx, %r9
je 0x12de08
movl 0x4(%r8,%rbx,8), %ebp
movq (%rdx), %r15
leaq (%r15,%r15,2), %r15
incq %rbx
cmpl 0x4(%r14,%r15,8), %ebp
jb 0x12ddbf
decq %rbx
cmpq %r9, %rbx
setb %bpl
testb %bpl, %bpl
je 0x12de08
movq 0x30(%rdi), %r14
movq (%rdx), %r15
leaq (%r15,%r15,2), %r15
movq (%r14,%r15,8), %r15
movq (%r8,%rbx,8), %rbx
xorq %r15, %rbx
shrq $0x20, %rbx
je 0x12de2c
movq (%rsi), %rbx
movq %rbx, (%rdx)
movq (%rsi), %rbx
incq %rbx
movq %rbx, (%rsi)
movq (%rdi), %r14
cmpq %r14, %rbx
jbe 0x12dd77
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
shrq $0x21, %r15
movq %r15, (%r11)
movq (%rdx), %rax
leaq (%rax,%rax,2), %rax
movq (%r14,%rax,8), %rax
shrq $0x20, %rax
andl $0x1, %eax
movq %rax, (%r10)
movl $0x1, %eax
jmp 0x12de23
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15c4c4(%rip), %r10    # 0x28a758
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 0x1006a7(%rip), %xmm0   # 0x22e9a0
xorl %r8d, %r8d
callq 0x11b648
movq 0x20(%r15), %rax
shlq $0x4, %r14
addq %rax, %r14
movl 0x18(%r15), %esi
shlq $0x4, %rsi
addq %rax, %rsi
movq %r14, %rdi
callq 0x122957
testq %rbx, %rbx
je 0x12e385
movl 0x1c(%r15), %esi
cmpl 0x10(%r15), %esi
jbe 0x12e343
movl %esi, 0x10(%r15)
movq 0x28(%r15), %rdi
shlq $0x4, %rsi
callq 0x2370
movq %rax, 0x28(%r15)
cmpl $0x0, (%r12)
je 0x12e385
xorl %r14d, %r14d
xorl %r13d, %r13d
movq 0x28(%r15), %rax
movq $0x0, 0x8(%rax,%r14)
movq 0x20(%r15), %rax
movq (%rax,%r14), %rsi
movq %rbx, %rdi
callq 0x113b08
movq 0x28(%r15), %rcx
movl %eax, (%rcx,%r14)
incq %r13
movl 0x18(%r15), %eax
addq $0x10, %r14
cmpq %rax, %r13
jb 0x12e350
movl (%r12), %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15d03a(%rip), %rsi    # 0x28b430
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 0x12e247
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 0x125fd9
addq $0x20, %rsp
testq %rax, %rax
je 0x12e4eb
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 0x1295b8
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_O1/chhylp123[P]hifiasm/extract.cpp
// Function: gfa_strndup(char const*, unsigned long)
char *gfa_strndup(const char *src, size_t n)
{
	char *dst;
	GFA_MALLOC(dst, n + 1);
	strncpy(dst, src, n);
	dst[n] = 0;
	return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
callq 0x2280
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20d0
movb $0x0, (%r15,%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12ef7d
movq %rax, %rbx
movslq (%r14), %r14
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rax, %rcx
callq 0x12f371
testq %r14, %r14
jle 0x130334
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2220
incq %r15
cmpq %r15, %r14
jne 0x130323
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %rax
orq %rdx, %rax
je 0x1347af
movq (%rbx), %rax
movq 0x10(%rax), %rdi
xorl %r8d, %r8d
movl $0x0, %r9d
testq %rdi, %rdi
je 0x13474e
movb (%rax), %cl
movl $0x1, %r9d
shll %cl, %r9d
cmpl %r9d, %r8d
je 0x1347af
movq 0x8(%rax), %rcx
movl %r8d, %r9d
shrl $0x5, %r9d
movl (%rcx,%r9,4), %ecx
btl %r8d, %ecx
jae 0x1347aa
movl %r8d, %ecx
testq %rsi, %rsi
je 0x134781
movq %rcx, %r9
shlq $0x4, %r9
movq 0x8(%rdi,%r9), %r9
cmpq (%rsi), %r9
ja 0x134797
testq %rdx, %rdx
je 0x1347aa
movq %rcx, %r9
shlq $0x4, %r9
movq 0x8(%rdi,%r9), %r9
cmpq (%rdx), %r9
jae 0x1347aa
shlq $0x4, %rcx
movq $0x0, 0x8(%rdi,%rcx)
andw $0xf000, (%rdi,%rcx)    # imm = 0xF000
incl %r8d
jmp 0x134738
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rax), %rdx
xorl %esi, %esi
movl $0x0, %edi
testq %rdx, %rdx
je 0x1347d3
movb (%rax), %cl
movl $0x1, %edi
shll %cl, %edi
cmpl %edi, %esi
je 0x13480a
movq 0x8(%rax), %rcx
movl %esi, %edi
shrl $0x5, %edi
movl (%rcx,%rdi,4), %ecx
btl %esi, %ecx
jae 0x134806
movl %esi, %ecx
shlq $0x4, %rcx
movq 0x8(%rbx), %rdi
movq 0x8(%rdx,%rcx), %r8
addq %rdi, %r8
movq %rdi, 0x8(%rdx,%rcx)
movq %r8, 0x8(%rbx)
movl %esi, 0x18(%rbx)
incl %esi
jmp 0x1347c0
movq 0x8(%rbx), %rdi
movl $0x8, %esi
callq 0x2120
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x0, 0x78(%rdi)
je 0x134e64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
je 0x134e50
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x78(%rbx), %rax
movq 0x10(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x134e1c
callq 0x2220
movq 0x78(%rbx), %rax
movq (%rax,%r15), %r14
testq %r14, %r14
je 0x134e43
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 0x134e09
movq 0x78(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2220
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x134e84
movq %rsi, %rdx
movl 0x28(%rsi), %edi
movq 0x10(%rsi), %rax
movq 0x58(%rax), %rcx
leaq 0x4f(%rip), %rsi        # 0x134ece
jmp 0x1047b4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
je 0x134ec4
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 0x13471e
incq %r13
addq $0x20, %r12
cmpq 0x58(%rbx), %r13
jb 0x134ea5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq