LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: sort_kvec_t_u64_warp(kvec_t_u64_warp*, unsigned int)
void sort_kvec_t_u64_warp(kvec_t_u64_warp* u_vecs, uint32_t is_descend)
{
    radix_sort_arch64(u_vecs->a.a, u_vecs->a.a + u_vecs->a.n);
    if(is_descend)
    {
        uint64_t i, uInfor;
        for (i = 0; i < (u_vecs->a.n>>1); ++i) 
        {
            uInfor = u_vecs->a.a[i];
            u_vecs->a.a[i] = u_vecs->a.a[u_vecs->a.n - i - 1];
            u_vecs->a.a[u_vecs->a.n - i - 1] = uInfor;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %rdi
leaq (%rdi,%rax,8), %rsi
callq 0x9d53f
testl %ebp, %ebp
je 0x9fcc5
movq (%rbx), %rsi
cmpq $0x2, %rsi
jb 0x9fcc5
movq 0x10(%rbx), %rax
movq $-0x8, %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rdi
leaq (%rax,%rsi,8), %rsi
movq (%rcx,%rsi), %rsi
movq %rsi, (%rax,%rdx,8)
movq (%rbx), %rsi
leaq (%rax,%rsi,8), %rsi
movq %rdi, (%rcx,%rsi)
incq %rdx
movq (%rbx), %rsi
movq %rsi, %rdi
shrq %rdi
addq $-0x8, %rcx
cmpq %rdi, %rdx
jb 0x9fc95
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_destroy(asg_t*)
void asg_destroy(asg_t *g)
{
	if (g == 0) return;
	free(g->seq); free(g->idx); free(g->arc); free(g->seq_vis);
     
    if(g->n_F_seq > 0 && g->F_seq)
    {
        uint32_t i = 0;
        for (i = 0; i < g->n_F_seq; i++)
        {
            if(g->F_seq[i].a) free(g->F_seq[i].a);
            if(g->F_seq[i].s) free(g->F_seq[i].s);
        }

        free(g->F_seq);
    }
    

    free(g);
}

// Assembly:
testq %rdi, %rdi
je 0x9fd74
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x30(%rbx), %rdi
callq 0x2220
cmpl $0x0, 0x38(%rbx)
je 0x9fd67
cmpq $0x0, 0x40(%rbx)
je 0x9fd67
cmpl $0x0, 0x38(%rbx)
je 0x9fd5e
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x40(%rbx), %rax
movq 0x18(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x9fd3c
callq 0x2220
movq 0x40(%rbx), %rax
movq 0x20(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x9fd4f
callq 0x2220
incq %r15
movl 0x38(%rbx), %eax
addq $0x28, %r14
cmpq %rax, %r15
jb 0x9fd29
movq 0x40(%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/Overlaps.cpp
// Function: add_overlaps(ma_hit_t_alloc*, ma_hit_t_alloc*, unsigned long*, long long)
void add_overlaps(ma_hit_t_alloc* source_paf, ma_hit_t_alloc* dest_paf, uint64_t* source_index, long long listLen)
{
    long long i;
    ma_hit_t* tmp;
    for (i = 0; i < listLen; i++)
    {
        tmp = &(source_paf->buffer[(uint32_t)(source_index[i])]);
        add_ma_hit_t_alloc(dest_paf, tmp);
    }
}

// Assembly:
testq %rcx, %rcx
jle 0x9fdd8
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movl (%r14,%r13,8), %eax
leaq (%rax,%rax,4), %rsi
shlq $0x3, %rsi
addq (%r12), %rsi
movq %r15, %rdi
callq 0x9fdd9
incq %r13
cmpq %r13, %rbx
jne 0x9fdaf
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: add_ma_hit_t_alloc(ma_hit_t_alloc*, ma_hit_t*)
void add_ma_hit_t_alloc(ma_hit_t_alloc* x, ma_hit_t* element)
{
	if (x->length + 1 > x->size) {
		x->size = x->length + 1;
		kroundup32(x->size);
		REALLOC(x->buffer, x->size);
	}
	x->buffer[x->length++] = *element;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %eax
leal 0x1(%rax), %ecx
cmpl 0x8(%rdi), %ecx
jbe 0x9fe29
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
orl %eax, %ecx
incl %ecx
movl %ecx, 0x8(%r14)
movq (%r14), %rdi
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rsi
callq 0x2370
movq %rax, (%r14)
movq (%r14), %rax
movl 0xc(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%r14)
leaq (%rcx,%rcx,4), %rcx
movq 0x20(%rbx), %rdx
movq %rdx, 0x20(%rax,%rcx,8)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rax,%rcx,8)
movups %xmm0, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: remove_overlaps(ma_hit_t_alloc*, unsigned long*, long long)
void remove_overlaps(ma_hit_t_alloc* source_paf, uint64_t* source_index, long long listLen)
{
    long long i, m;
    for (i = 0; i < listLen; i++)
    {
        source_paf->buffer[(uint32_t)(source_index[i])].qns = (uint64_t)(-1);
    }

    m = 0;
    for (i = 0; i < source_paf->length; i++)
    {
        if(source_paf->buffer[i].qns != (uint64_t)(-1))
        {
            source_paf->buffer[m] = source_paf->buffer[i];
            m++;
        }
    }
    source_paf->length = m;
}

// Assembly:
testq %rdx, %rdx
jle 0x9fe7e
movq (%rdi), %rax
xorl %ecx, %ecx
movl (%rsi,%rcx,8), %r8d
leaq (%r8,%r8,4), %r8
movq $-0x1, (%rax,%r8,8)
incq %rcx
cmpq %rcx, %rdx
jne 0x9fe66
cmpl $0x0, 0xc(%rdi)
je 0x9fecd
xorl %ecx, %ecx
xorl %eax, %eax
xorl %edx, %edx
movq (%rdi), %rsi
cmpq $-0x1, (%rsi,%rcx)
je 0x9febc
leaq (%rsi,%rcx), %r8
leaq (%rax,%rax,4), %r9
movq 0x20(%r8), %r10
movq %r10, 0x20(%rsi,%r9,8)
movups (%r8), %xmm0
movups 0x10(%r8), %xmm1
movups %xmm1, 0x10(%rsi,%r9,8)
movups %xmm0, (%rsi,%r9,8)
incq %rax
incq %rdx
movl 0xc(%rdi), %esi
addq $0x28, %rcx
cmpq %rsi, %rdx
jb 0x9fe8a
jmp 0x9fecf
xorl %eax, %eax
movl %eax, 0xc(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: add_overlaps_from_different_sources(ma_hit_t_alloc*, ma_hit_t_alloc*, unsigned long*, long long)
void add_overlaps_from_different_sources(ma_hit_t_alloc* source_paf_list, ma_hit_t_alloc* dest_paf, 
uint64_t* source_index, long long listLen)
{
    long long i;
    ma_hit_t ele;
    ma_hit_t* tmp;
    uint32_t source_n, source_i;
    for (i = 0; i < listLen; i++)
    {
        source_n = source_index[i] >> 32;
        source_i = (uint32_t)(source_index[i]);
        tmp = &(source_paf_list[source_n].buffer[source_i]);

        ele.del = 0;
        ele.rev = tmp->rev;
        ele.qns = Get_tn((*tmp));
        ele.qns = ele.qns << 32;
        ele.qns = ele.qns | (uint64_t)(Get_ts((*tmp)));
        ele.qe = Get_te((*tmp));

        ele.tn = Get_qn((*tmp));
        ele.ts = Get_qs((*tmp));
        ele.te = Get_qe((*tmp));

        ele.bl = R_INF.read_length[ele.tn];
        ele.ml = tmp->ml;
        ele.el = tmp->el;
        ele.no_l_indel = tmp->no_l_indel;
        
        add_ma_hit_t_alloc(dest_paf, &ele);
    }
}

// Assembly:
testq %rcx, %rcx
jle 0xa0003
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movabsq $0x7fffffff00000000, %rsi # imm = 0x7FFFFFFF00000000
leaq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
xorl %ebp, %ebp
addq $0x7fffffff, %rsi       # imm = 0x7FFFFFFF
movq %rsi, 0x30(%rsp)
movq (%r15,%rbp,8), %rcx
movl %ecx, %edx
shrq $0x20, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rbx,%rcx,8), %rcx
leaq (%rdx,%rdx,4), %rdx
movq %rax, %rsi
btrq $0x3f, %rsi
movq %rsi, 0x20(%rsp)
movq 0x18(%rcx,%rdx,8), %r14
movl %r14d, %esi
andl $0x80000000, %esi       # imm = 0x80000000
andq 0x30(%rsp), %rax
orq %rsi, %rax
movq %rax, 0x20(%rsp)
movl 0xc(%rcx,%rdx,8), %esi
shlq $0x20, %rsi
movq %rsi, 0x8(%rsp)
movl 0x10(%rcx,%rdx,8), %edi
orq %rsi, %rdi
movq %rdi, 0x8(%rsp)
movl 0x14(%rcx,%rdx,8), %esi
movl %esi, 0x10(%rsp)
movq (%rcx,%rdx,8), %rsi
movq %rsi, %rdi
rorq $0x20, %rdi
movq %rdi, 0x14(%rsp)
movl 0x8(%rcx,%rdx,8), %edi
movl %edi, 0x1c(%rsp)
leaq 0x1eb29b(%rip), %rdi    # 0x28b230
movq 0x18(%rdi), %rdi
shrq $0x20, %rsi
movq (%rdi,%rsi,8), %rsi
shlq $0x20, %rsi
movabsq $0x7fffffff00000000, %rdi # imm = 0x7FFFFFFF00000000
andq %rdi, %rsi
andl $0xbfffffff, %eax       # imm = 0xBFFFFFFF
andl $0x40000000, %r14d      # imm = 0x40000000
orq %rax, %r14
orq %rsi, %r14
movq %r14, 0x20(%rsp)
movb 0x20(%rcx,%rdx,8), %al
movb %al, 0x28(%rsp)
movb 0x21(%rcx,%rdx,8), %al
movb %al, 0x29(%rsp)
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x9fdd9
incq %rbp
movq %r14, %rax
cmpq %rbp, %r13
jne 0x9ff17
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: ma_ug_destroy(ma_ug_t*)
void ma_ug_destroy(ma_ug_t *ug)
{
	uint32_t i;
	if (ug == 0) return;
	for (i = 0; i < ug->u.n; ++i) {
		free(ug->u.a[i].a);
		free(ug->u.a[i].s);
	}
	free(ug->u.a);
	asg_destroy(ug->g);
    kv_destroy(ug->occ);
	free(ug);
}

// Assembly:
testq %rdi, %rdi
je 0xa0071
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0xa004a
movl $0x1, %ebp
xorl %eax, %eax
movq 0x10(%rbx), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,4), %r14
movq 0x18(%rcx,%r14), %rdi
callq 0x2220
movq 0x10(%rbx), %rax
movq 0x20(%rax,%r14), %rdi
callq 0x2220
movl %ebp, %eax
incl %ebp
cmpq %rax, (%rbx)
ja 0xa001d
movq 0x10(%rbx), %rdi
callq 0x2220
movq 0x18(%rbx), %rdi
callq 0x9fcdb
movq 0x30(%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2220
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_arc_index_core(unsigned long, unsigned long, asg_arc_t const*)
uint64_t *asg_arc_index_core(size_t max_seq, size_t n, const asg_arc_t *a)
{
	size_t i, last;
	uint64_t *idx;
	idx = (uint64_t*)calloc(max_seq * 2, 8);


    /**
		 * ul: |____________31__________|__________1___________|______________32_____________|
	                       qns            direction of overlap       length of this node (not overlap length)
	**/
    ///so if we use high 32-bit, we store the index of each qn with two direction
	for (i = 1, last = 0; i <= n; ++i)
		if (i == n || a[i-1].ul>>32 != a[i].ul>>32)
			idx[a[i-1].ul>>32] = (uint64_t)last<<32 | (i - last), last = i;

    
	return idx;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
addq %rdi, %rdi
movl $0x8, %esi
callq 0x2120
testq %r14, %r14
je 0xa00db
leaq 0x1(%r14), %rdx
cmpq $0x3, %rdx
movl $0x2, %ecx
cmovaeq %rdx, %rcx
movl $0x1, %edx
xorl %esi, %esi
cmpq %rdx, %r14
je 0xa00b8
movq 0x18(%rbx), %rdi
xorq (%rbx), %rdi
shrq $0x20, %rdi
je 0xa00cf
movq %rdx, %rdi
subq %rsi, %rdi
shlq $0x20, %rsi
orq %rdi, %rsi
movl 0x4(%rbx), %edi
movq %rsi, (%rax,%rdi,8)
movq %rdx, %rsi
incq %rdx
addq $0x18, %rbx
cmpq %rdx, %rcx
jne 0xa00a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_seq_set(asg_t*, int, int, int)
void asg_seq_set(asg_t *g, int sid, int len, int del)
{
	///just malloc size
	if (sid >= (int)g->m_seq) {
		g->m_seq = sid + 1;
		kv_roundup32(g->m_seq);
		g->seq = (asg_seq_t*)realloc(g->seq, g->m_seq * sizeof(asg_seq_t));
	}

	if (sid >= g->n_seq) g->n_seq = sid + 1;
	
    g->seq[sid].del = !!del;
    g->seq[sid].len = len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
cmpl %esi, 0x10(%rdi)
jg 0xa0166
movl %r15d, %eax
shrl %eax
orl %r15d, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %esi
shrl $0x10, %esi
orl %ecx, %esi
incl %esi
movl %esi, 0x10(%r14)
movq 0x20(%r14), %rdi
shlq $0x3, %rsi
callq 0x2370
movq %rax, 0x20(%r14)
movl 0x14(%r14), %eax
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %r15d, %ecx
jg 0xa018c
leal 0x1(%r15), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
andl $0x80000000, %eax       # imm = 0x80000000
orl %ecx, %eax
movl %eax, 0x14(%r14)
xorl %eax, %eax
testl %ebp, %ebp
setne %al
movq 0x20(%r14), %rcx
movslq %r15d, %rdx
shll $0x1f, %eax
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
andl %esi, %ebx
andl (%rcx,%rdx,8), %esi
orl %eax, %esi
movl %esi, (%rcx,%rdx,8)
movq 0x20(%r14), %rax
movl $0x80000000, %ecx       # imm = 0x80000000
andl (%rax,%rdx,8), %ecx
orl %ebx, %ecx
movl %ecx, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_F_seq_set(asg_t*, int)
ma_utg_t* asg_F_seq_set(asg_t *g, int iid)
{
    if(iid < (int)g->r_seq) return NULL;
    uint32_t index = iid - g->r_seq, pre_n_F_seq = g->n_F_seq;

	///just malloc size
	if (index >= g->n_F_seq) {
		g->n_F_seq = index + 1;
		kv_roundup32(g->n_F_seq);
        g->F_seq = (ma_utg_t*)realloc(g->F_seq, g->n_F_seq*sizeof(ma_utg_t));
        memset(g->F_seq + pre_n_F_seq, 0, sizeof(ma_utg_t)*(g->n_F_seq-pre_n_F_seq));
	}

    return &(g->F_seq[index]);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
subl 0x18(%rdi), %ebp
jge 0xa01d7
xorl %eax, %eax
jmp 0xa024a
movq %rdi, %rbx
movl 0x38(%rdi), %r14d
cmpl %r14d, %ebp
jb 0xa023c
movl %ebp, %eax
shrl %eax
orl %ebp, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
movl %eax, 0x38(%rbx)
movq 0x40(%rbx), %rdi
shlq $0x3, %rax
leaq (%rax,%rax,4), %rsi
callq 0x2370
movq %rax, 0x40(%rbx)
leaq (%r14,%r14,4), %rcx
leaq (%rax,%rcx,8), %rdi
movl 0x38(%rbx), %eax
subl %r14d, %eax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
xorl %esi, %esi
callq 0x20e0
movl %ebp, %eax
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x40(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_arc_rm(asg_t*)
void asg_arc_rm(asg_t *g)
{
	/**
	p->ul: |____________31__________|__________1___________|______________32_____________|
	                    qns            direction of overlap       length of this node (not overlap length)
	p->v : |___________31___________|__________1___________|
				        tns              relative strand between query and target
	p->ol: overlap length
	**/
	uint32_t e, n;
	///just clean arc requiring: 1. arc it self must be available 2. both the query and target are available
	for (e = n = 0; e < g->n_arc; ++e) {
		//u and v is the read id
		uint32_t u = g->arc[e].ul>>32, v = g->arc[e].v;
		if (!g->arc[e].del && !g->seq[u>>1].del && !g->seq[v>>1].del)
			g->arc[n++] = g->arc[e];
	}
	if (n < g->n_arc) { // arc index is out of sync
		if (g->idx) free(g->idx);
		g->idx = 0;
	}
	g->n_arc = n;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl 0x4(%rdi), %edx
je 0xa02c4
xorl %eax, %eax
xorl %ecx, %ecx
xorl %ebp, %ebp
movq 0x8(%rbx), %rdx
cmpl $0x0, 0xc(%rdx,%rax)
js 0xa02ad
leaq (%rdx,%rax), %rsi
movq (%rsi), %r8
movq 0x20(%rbx), %rdi
shrq $0x21, %r8
cmpl $0x0, (%rdi,%r8,8)
js 0xa02ad
movl 0x8(%rdx,%rax), %r8d
shrl %r8d
cmpl $0x0, (%rdi,%r8,8)
js 0xa02ad
movl %ebp, %edi
incl %ebp
leaq (%rdi,%rdi,2), %rdi
movq 0x10(%rsi), %r8
movq %r8, 0x10(%rdx,%rdi,8)
movups (%rsi), %xmm0
movups %xmm0, (%rdx,%rdi,8)
incq %rcx
movl 0x4(%rbx), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
addq $0x18, %rax
cmpq %rdx, %rcx
jb 0xa0265
jmp 0xa02c6
xorl %ebp, %ebp
cmpl %edx, %ebp
jae 0xa02e0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xa02d8
callq 0x2220
movq $0x0, 0x28(%rbx)
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movl $0x80000000, %eax       # imm = 0x80000000
andl 0x4(%rbx), %eax
orl %ebp, %eax
movl %eax, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_cleanup(asg_t*)
void asg_cleanup(asg_t *g)
{
    ///remove overlaps, instead of reads
    ///remove edges with del, and free idx
	asg_arc_rm(g);
	if (!g->is_srt) {
		/**
		 * sort by ul, that is, sort by qns + direction
		 * ul: |____________31__________|__________1___________|______________32_____________|
	                       qns            direction of overlap       length of this node (not overlap length)
		**/
		asg_arc_sort(g);
		g->is_srt = 1;
	}
	///index the overlaps in graph with query id
	if (g->idx == 0) asg_arc_index(g);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xa024f
movslq 0x4(%rbx), %rax
testq %rax, %rax
js 0xa0321
movq 0x8(%rbx), %rdi
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,8), %rsi
callq 0x9d313
orb $-0x80, 0x7(%rbx)
cmpq $0x0, 0x28(%rbx)
je 0xa032a
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xa00e3
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_arc_del_multi(asg_t*)
int asg_arc_del_multi(asg_t *g)
{
	//the number of nodes are number of read times 2
	uint32_t *cnt, n_vtx = g->n_seq * 2, n_multi = 0, v;
	cnt = (uint32_t*)calloc(n_vtx, 4);
	for (v = 0; v < n_vtx; ++v) {
		///out-nodes of v
		asg_arc_t *av = asg_arc_a(g, v);
		int32_t i, nv = asg_arc_n(g, v);
		///if v just have one out-node, there is no muti-edge
		if (nv < 2) continue;
		for (i = nv - 1; i >= 0; --i) ++cnt[av[i].v];
		for (i = nv - 1; i >= 0; --i)
			if (--cnt[av[i].v] != 0)
				av[i].del = 1, ++n_multi;
	}
	free(cnt);
	if (n_multi) asg_cleanup(g);

    if(VERBOSE >= 1)
    {
        fprintf(stderr, "[M::%s] removed %d multi-arcs\n", __func__, n_multi);
    }
	
	return n_multi;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x14(%rdi), %r14d
addl %r14d, %r14d
movl $0x4, %esi
movq %r14, %rdi
callq 0x2120
testl %r14d, %r14d
je 0xa03cc
movl %r14d, %ecx
xorl %edx, %edx
xorl %ebp, %ebp
movq 0x28(%rbx), %rsi
movq (%rsi,%rdx,8), %rsi
cmpl $0x2, %esi
jl 0xa03c2
movq 0x8(%rbx), %rdi
movq %rsi, %r8
shrq $0x20, %r8
decl %esi
leaq (%r8,%r8,2), %r8
leaq (%rsi,%rsi,2), %r9
incq %rsi
shlq $0x3, %r9
leaq (%r9,%r8,8), %r8
leaq (%rdi,%r8), %r9
addq $0x8, %r9
movq %rsi, %r10
movl (%r9), %r11d
incl (%rax,%r11,4)
addq $-0x18, %r9
decq %r10
jg 0xa0392
addq %r8, %rdi
addq $0xc, %rdi
movl -0x4(%rdi), %r8d
decl (%rax,%r8,4)
je 0xa03b9
orb $-0x80, 0x3(%rdi)
incl %ebp
addq $-0x18, %rdi
decq %rsi
jg 0xa03a9
incq %rdx
cmpq %rcx, %rdx
jne 0xa035a
jmp 0xa03ce
xorl %ebp, %ebp
movq %rax, %rdi
callq 0x2220
testl %ebp, %ebp
je 0xa03e2
movq %rbx, %rdi
callq 0xa02fa
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_arc_del_asymm(asg_t*)
int asg_arc_del_asymm(asg_t *g)
{
	uint32_t e, n_asymm = 0;
	///g->n_arc is the number of overlaps 
	for (e = 0; e < g->n_arc; ++e) {
		uint32_t v = g->arc[e].v^1, u = g->arc[e].ul>>32^1;
		uint32_t i, nv = asg_arc_n(g, v);
		asg_arc_t *av = asg_arc_a(g, v);
		for (i = 0; i < nv; ++i)
			if (av[i].v == u) break;
		if (i == nv) g->arc[e].del = 1, ++n_asymm;
	}
	if (n_asymm) asg_cleanup(g);
    if(VERBOSE >= 1)
    {
	    fprintf(stderr, "[M::%s] removed %d asymmetric arcs\n", __func__, n_asymm);
    }
	return n_asymm;
}

// Assembly:
pushq %rbx
testl $0x7fffffff, 0x4(%rdi)  # imm = 0x7FFFFFFF
je 0xa046f
xorl %eax, %eax
xorl %ebx, %ebx
movq 0x8(%rdi), %rcx
movq 0x28(%rdi), %rsi
leaq (%rax,%rax,2), %rdx
movl 0x8(%rcx,%rdx,8), %r8d
xorq $0x1, %r8
movq (%rsi,%r8,8), %rsi
movl $0x0, %r8d
testl %esi, %esi
je 0xa0450
movl 0x4(%rcx,%rdx,8), %r9d
movq %rsi, %r8
shrq $0x20, %r8
leaq (%r8,%r8,2), %r8
leaq (%rcx,%r8,8), %r10
addq $0x8, %r10
xorl %r8d, %r8d
movl (%r10), %r11d
xorl %r9d, %r11d
cmpl $0x1, %r11d
je 0xa0450
incl %r8d
addq $0x18, %r10
cmpl %r8d, %esi
jne 0xa0435
movl %esi, %r8d
cmpl %esi, %r8d
jne 0xa045c
orb $-0x80, 0xf(%rcx,%rdx,8)
incl %ebx
incq %rax
movl 0x4(%rdi), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpq %rcx, %rax
jb 0xa03f7
jmp 0xa0471
xorl %ebx, %ebx
testl %ebx, %ebx
je 0xa047a
callq 0xa02fa
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_specific_overlap(ma_hit_t_alloc*, unsigned int, unsigned int)
long long get_specific_overlap(ma_hit_t_alloc* x, uint32_t qn, uint32_t tn)
{
    long long i;
    for (i = 0; i < x->length; i++)
    {
        if(x->buffer[i].tn == tn 
        &&
          ((uint32_t)(x->buffer[i].qns>>32)) == qn)
        {
            return i;
        }        
    }

    return -1;
}

// Assembly:
movl 0xc(%rdi), %ecx
movq $-0x1, %rax
testq %rcx, %rcx
je 0xa0525
movq (%rdi), %r8
xorl %edi, %edi
cmpl %edx, 0xc(%r8)
jne 0xa0519
cmpl %esi, 0x4(%r8)
je 0xa0526
incq %rdi
addq $0x28, %r8
cmpq %rdi, %rcx
jne 0xa050d
retq
movq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: normalize_ma_hit_t_single_side_advance_mult(ma_hit_t_alloc*, long, long)
void normalize_ma_hit_t_single_side_advance_mult(ma_hit_t_alloc* src, int64_t n_src, int64_t n_thread)
{
    ma_hit_t_aux aux; int64_t k; uint64_t z; ma_hit_t e;
    aux.n_thread = n_thread; aux.src = src; CALLOC(aux.buf, aux.n_thread);

    kt_for(aux.n_thread, update_ma_hit_t_norm, &aux, n_src);

    for (k = 0; k < aux.n_thread; k++) {
        for (z = 0; z < aux.buf[k].a.n; z++) {
            set_reverse_overlap(&e, &(src[aux.buf[k].a.a[z]>>32].buffer[(uint32_t)(aux.buf[k].a.a[z])]));
            src[aux.buf[k].a.a[z]>>32].buffer[(uint32_t)(aux.buf[k].a.a[z])].del = e.del = 1;
            add_ma_hit_t_alloc(&(src[Get_qn(e)]), &e);
        }
        free(aux.buf[k].a.a);
    }
    free(aux.buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %rdx, 0x10(%r12)
movq %rdi, 0x8(%r12)
movl $0x20, %esi
movq %rdx, %rdi
callq 0x2120
movq %rax, (%r12)
leaq 0x177(%rip), %rsi       # 0xa0aa0
movl %r14d, %edi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1047b4
cmpq $0x0, 0x10(%r12)
jle 0xa0a87
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq %rsp, %rax
movq 0x18(%rax), %r12
xorl %r13d, %r13d
movabsq $0x7fffffff00000000, %r15 # imm = 0x7FFFFFFF00000000
movq 0x30(%rsp), %rax
movq %r13, 0x28(%rsp)
shlq $0x5, %r13
cmpq $0x0, (%rax,%r13)
je 0xa0a6a
xorl %r14d, %r14d
movq 0x10(%rax,%r13), %rcx
movq (%rcx,%r14,8), %rcx
movl %ecx, %edx
shrq $0x20, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rbx,%rcx,8), %rcx
leaq (%rdx,%rdx,4), %rdx
movl 0xc(%rcx,%rdx,8), %esi
movq %rsi, %rdi
shlq $0x20, %rdi
movq %rdi, (%rsp)
movl 0x10(%rcx,%rdx,8), %r8d
orq %rdi, %r8
movq %r8, (%rsp)
movl 0x14(%rcx,%rdx,8), %edi
movl %edi, 0x8(%rsp)
movq (%rcx,%rdx,8), %rdi
rorq $0x20, %rdi
leaq (%rsi,%rsi,2), %rsi
movq %rdi, 0xc(%rsp)
movl 0x8(%rcx,%rdx,8), %edi
movl %edi, 0x14(%rsp)
movq 0x18(%rcx,%rdx,8), %rdi
movl %edi, %r8d
btrq $0x1f, %r12
andl $0x80000000, %r8d       # imm = 0x80000000
orq %r8, %r12
movq %r12, 0x18(%rsp)
movl %edi, %r8d
andl $0x40000000, %r8d       # imm = 0x40000000
andq $-0x40000001, %r12      # imm = 0xBFFFFFFF
orq %r8, %r12
movb 0x20(%rcx,%rdx,8), %r8b
movb %r8b, 0x20(%rsp)
movq %r12, 0x18(%rsp)
movb 0x21(%rcx,%rdx,8), %cl
andq %r15, %rdi
movb %cl, 0x21(%rsp)
movl %r12d, %r12d
orq %rdi, %r12
orq %rbp, %r12
movq %r12, 0x18(%rsp)
movq 0x10(%rax,%r13), %rax
movq (%rax,%r14,8), %rax
movl %eax, %ecx
shrq $0x20, %rax
leaq (%rax,%rax,2), %rax
movq (%rbx,%rax,8), %rax
leaq (%rcx,%rcx,4), %rcx
orq %rbp, 0x18(%rax,%rcx,8)
leaq (%rbx,%rsi,8), %rdi
movq %rsp, %rsi
callq 0x9fdd9
incq %r14
movq 0x30(%rsp), %rax
cmpq (%rax,%r13), %r14
jb 0xa097d
movq 0x10(%rax,%r13), %rdi
callq 0x2220
movq 0x28(%rsp), %r13
incq %r13
cmpq 0x40(%rsp), %r13
jl 0xa0961
movq 0x30(%rsp), %rdi
callq 0x2220
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_end_match_length(ma_hit_t*, UC_Read*, UC_Read*, unsigned int*, unsigned int*)
void get_end_match_length(ma_hit_t* edge, UC_Read* query, UC_Read* target,
uint32_t* left, uint32_t* right)
{
    (*left) = (*right) = 0;

    uint32_t query_beg, query_end, target_beg, target_end, targetLen, oLen;
    long long i;
    targetLen = Get_READ_LENGTH(R_INF, Get_tn(*edge));
    query_beg = Get_qs(*edge);
    query_end = Get_qe(*edge)-1;
    recover_UC_Read(query, &R_INF, Get_qn(*edge));
    
    if(edge->rev)
    {
        target_beg = targetLen-(Get_te(*edge)-1)-1;
        target_end = targetLen-Get_ts(*edge)-1;
        recover_UC_Read_RC(target, &R_INF, Get_tn(*edge));
    }
    else
    {
        target_beg = Get_ts(*edge);
        target_end = Get_te(*edge)-1;
        recover_UC_Read(target, &R_INF, Get_tn(*edge));
    }

    oLen = Get_qe(*edge) - Get_qs(*edge);
    /***************************left*******************************/
    for (i = 0; i < oLen; i++)
    {
        if(query->seq[query_beg+i]!=target->seq[target_beg+i]) break;
        (*left)++;
    }
    /***************************left*******************************/

    /***************************right*******************************/
    for (i = 0; i < oLen; i++)
    {
        if(query->seq[query_end-i]!=target->seq[target_end-i]) break;
        (*right)++;
    }
    /***************************right*******************************/
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r8
movq %rdi, %r13
xorl %eax, %eax
movl %eax, (%rbx)
movl %eax, (%rcx)
leaq 0x1ea57f(%rip), %rsi    # 0x28b230
movq 0x18(%rsi), %rax
movl 0xc(%rdi), %ecx
movq (%rax,%rcx,8), %r14
movq (%rdi), %rdx
movl 0x8(%rdi), %eax
movl %eax, 0x4(%rsp)
movq %rdx, 0x10(%rsp)
shrq $0x20, %rdx
movq %r8, 0x8(%rsp)
movq %r8, %rdi
callq 0x33cf8
testb $-0x80, 0x1b(%r13)
jne 0xa0d02
movl 0xc(%r13), %edx
movl 0x10(%r13), %r14d
movl 0x14(%r13), %ebp
decl %ebp
leaq 0x1ea538(%rip), %rsi    # 0x28b230
movq %r15, %rdi
callq 0x33cf8
jmp 0xa0d28
movl %r14d, %eax
subl 0x14(%r13), %eax
movl 0xc(%r13), %edx
movl 0x10(%r13), %ebp
notl %ebp
addl %r14d, %ebp
movl %eax, %r14d
leaq 0x1ea510(%rip), %rsi    # 0x28b230
movq %r15, %rdi
callq 0x33dc3
movl (%r13), %ecx
movl 0x8(%r13), %edx
movl %edx, %eax
subl %ecx, %eax
je 0xa0d6c
movl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdi
addq (%rdi), %rsi
movl %r14d, %edi
addq (%r15), %rdi
cmpq $0x1, %rax
movq %rax, %r8
adcq $0x0, %r8
xorl %r9d, %r9d
movb (%rsi,%r9), %r10b
cmpb (%rdi,%r9), %r10b
jne 0xa0d6c
incl (%r12)
incq %r9
cmpq %r9, %r8
jne 0xa0d56
cmpl %ecx, %edx
je 0xa0da5
movl 0x4(%rsp), %ecx
decl %ecx
movl %ecx, %ecx
movl %ebp, %edx
xorl %esi, %esi
cmpq $0x1, %rax
movl $0x0, %edi
sbbq %rax, %rdi
addq (%r15), %rdx
movq 0x8(%rsp), %rax
addq (%rax), %rcx
movb (%rcx,%rsi), %al
cmpb (%rdx,%rsi), %al
jne 0xa0da5
incl (%rbx)
decq %rsi
cmpq %rsi, %rdi
jne 0xa0d93
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/Overlaps.cpp
// Function: drop_edges_by_trio(ma_hit_t_alloc*, long long)
void drop_edges_by_trio(ma_hit_t_alloc* sources, long long num_sources)
{
    double startTime = Get_T();

    long long i, j;
    uint32_t qn, tn;
    for (i = 0; i < num_sources; i++)
    {
        for (j = 0; j < sources[i].length; j++)
        {
            if(sources[i].buffer[j].del) continue;
            
            qn = Get_qn(sources[i].buffer[j]);
            tn = Get_tn(sources[i].buffer[j]);

            if(R_INF.trio_flag[qn] != AMBIGU && R_INF.trio_flag[tn] != AMBIGU)
            {
                if(R_INF.trio_flag[qn] != R_INF.trio_flag[tn])
                {
                    sources[i].buffer[j].del = 1;
                    continue;
                }
            }

            sources[i].buffer[j].del = 0;
        }
    }

    if(VERBOSE >= 1)
    {
        fprintf(stderr, "[M::%s] takes %0.2fs\n\n", __func__, Get_T()-startTime);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x300fc
testq %rbx, %rbx
jle 0xa13a0
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %ecx, %ecx
leaq 0x1e9f01(%rip), %rdx    # 0x28b230
leaq (%rcx,%rcx,2), %rsi
cmpl $0x0, 0xc(%r14,%rsi,8)
je 0xa1398
leaq (%r14,%rsi,8), %rsi
movl $0x18, %edi
xorl %r8d, %r8d
movq (%rsi), %r9
movq (%r9,%rdi), %r10
testq %r10, %r10
js 0xa1388
movl -0x14(%r9,%rdi), %r11d
movq 0x28(%rdx), %r15
movb (%r15,%r11), %r11b
testb %r11b, %r11b
je 0xa1384
movl -0xc(%r9,%rdi), %r12d
movb (%r15,%r12), %bpl
testb %bpl, %bpl
je 0xa1384
cmpb %bpl, %r11b
je 0xa1384
addq %rax, %r10
incq %r10
movq %r10, (%r9,%rdi)
jmp 0xa1388
andq %rax, (%r9,%rdi)
incq %r8
movl 0xc(%rsi), %r9d
addq $0x28, %rdi
cmpq %r9, %r8
jb 0xa1347
incq %rcx
cmpq %rbx, %rcx
jne 0xa132f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_specific_overlap_with_del(ma_hit_t_alloc*, ma_sub_t*, unsigned int, unsigned int)
ma_hit_t* get_specific_overlap_with_del(ma_hit_t_alloc* sources, ma_sub_t *coverage_cut, 
uint32_t qn, uint32_t tn)
{
    if(coverage_cut[qn].del || coverage_cut[tn].del) return NULL;
    ma_hit_t_alloc* x = &(sources[qn]);
    uint32_t i;
    for (i = 0; i < x->length; i++)
    {
        if(x->buffer[i].del) continue;
        if(coverage_cut[Get_qn(x->buffer[i])].del) continue;
        if(coverage_cut[Get_tn(x->buffer[i])].del) continue;

        if(Get_tn(x->buffer[i])==tn 
        &&
           Get_qn(x->buffer[i])==qn)
        {
            return &(x->buffer[i]);
        }        
    }

    return NULL;
}

// Assembly:
movl %edx, %eax
leaq (%rax,%rax,2), %rax
cmpl $0x0, (%rsi,%rax,4)
js 0xa1418
movl %ecx, %r8d
leaq (%r8,%r8,2), %r8
cmpl $0x0, (%rsi,%r8,4)
js 0xa1418
movl 0xc(%rdi,%rax,8), %r8d
testq %r8, %r8
je 0xa1418
leaq (%rdi,%rax,8), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
js 0xa140f
movq (%rax), %rdi
shrq $0x20, %rdi
leaq (%rdi,%rdi,2), %r9
cmpl $0x0, (%rsi,%r9,4)
js 0xa140f
movl 0xc(%rax), %r9d
leaq (%r9,%r9,2), %r10
cmpl $0x0, (%rsi,%r10,4)
setns %r10b
xorl %ecx, %r9d
xorl %edx, %edi
orl %r9d, %edi
sete %dil
testb %r10b, %dil
jne 0xa141a
addq $0x28, %rax
decq %r8
jne 0xa13d4
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: delete_all_edges(ma_hit_t_alloc*, ma_sub_t*, unsigned int)
void delete_all_edges(ma_hit_t_alloc* sources, ma_sub_t *coverage_cut, uint32_t qn)
{
    ma_hit_t_alloc* x = &(sources[qn]);
    uint32_t i;
    for (i = 0; i < x->length; i++)
    {
        x->buffer[i].del = 1;
        delete_single_edge(sources, coverage_cut, Get_tn(x->buffer[i]), Get_qn(x->buffer[i]));
    }
    coverage_cut[qn].del = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edx, %eax
leaq (%rax,%rax,2), %rax
movq %rax, (%rsp)
cmpl $0x0, 0xc(%rdi,%rax,8)
je 0xa149f
movq %rdi, %r14
movq (%rsp), %rax
leaq (%rdi,%rax,8), %r12
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
xorl %ebp, %ebp
xorl %r15d, %r15d
movq (%r12), %rax
orq %r13, 0x18(%rax,%rbp)
movq (%r12), %rax
movl 0x4(%rax,%rbp), %ecx
movl 0xc(%rax,%rbp), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa13a9
testq %rax, %rax
je 0xa148e
orq %r13, 0x18(%rax)
incq %r15
movl 0xc(%r12), %eax
addq $0x28, %rbp
cmpq %rax, %r15
jb 0xa1465
movq (%rsp), %rax
orb $-0x80, 0x3(%rbx,%rax,4)
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/Overlaps.cpp
// Function: get_real_sources_length(ma_hit_t_alloc*, ma_sub_t*, int, int, unsigned int)
uint32_t get_real_sources_length(ma_hit_t_alloc* sources, ma_sub_t *coverage_cut, 
int max_hang, int min_ovlp, uint32_t query)
{
    uint32_t qn = query>>1;
    if(coverage_cut[qn].del) return 0;
    int32_t r;
    asg_arc_t t;
    ma_hit_t *h = NULL;
    ma_sub_t *sq = NULL;
    ma_sub_t *st = NULL;
    ma_hit_t_alloc* x = &(sources[qn]);
    uint32_t i, occ = 0;
    for (i = 0; i < x->length; i++)
    {
        h = &(x->buffer[i]);
        if(h->del) continue;
        ///now the edge has not been removed
        sq = &(coverage_cut[Get_qn(*h)]);
        st = &(coverage_cut[Get_tn(*h)]);
        if(sq->del || st->del) continue;
        r = ma_hit2arc(h, sq->e - sq->s, st->e - st->s, max_hang, 
                                asm_opt.max_hang_rate, min_ovlp, &t);
        ///if it is a contained read
        if(r < 0) continue;
        if((t.ul>>32) == query) occ++;
    }

    return occ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %eax
shrl %eax
leaq (%rax,%rax,2), %rax
cmpl $0x0, (%rsi,%rax,4)
js 0xa1586
movl 0xc(%rdi,%rax,8), %r13d
testq %r13, %r13
je 0xa1586
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
leaq (%rdi,%rax,8), %rax
movq (%rax), %r12
leaq 0x1e925d(%rip), %rax    # 0x28a758
movss 0x158(%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movl %r8d, %eax
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
cmpq $0x0, 0x18(%r12)
js 0xa157b
movl 0x4(%r12), %eax
leaq (%rax,%rax,2), %rcx
movl (%r14,%rcx,4), %eax
testl %eax, %eax
js 0xa157b
movl 0xc(%r12), %edx
leaq (%rdx,%rdx,2), %rdx
leaq (%r14,%rdx,4), %rdx
movl (%rdx), %edi
testl %edi, %edi
js 0xa157b
leaq (%r14,%rcx,4), %rcx
movl 0x4(%rcx), %esi
subl %eax, %esi
movl 0x4(%rdx), %edx
subl %edi, %edx
movq %r12, %rdi
movl %ebp, %ecx
movss 0x4(%rsp), %xmm0
movl %ebx, %r8d
leaq 0x10(%rsp), %r9
callq 0xa159b
testl %eax, %eax
js 0xa157b
xorl %eax, %eax
movq 0x8(%rsp), %rcx
cmpl %ecx, 0x14(%rsp)
sete %al
addl %eax, %r15d
addq $0x28, %r12
decq %r13
jne 0xa1514
jmp 0xa1589
xorl %r15d, %r15d
movl %r15d, %eax
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/Overlaps.cpp
// Function: set_R_to_U(R_to_U*, unsigned int, unsigned int, unsigned int, unsigned char*)
void set_R_to_U(R_to_U* x, uint32_t rID, uint32_t uID, uint32_t is_Unitig, uint8_t* flag)
{
    if(flag && (*flag) == FAKE_LABLE) return;
     
	if(rID >= x->len)
	{
		x->index = (uint32_t*)realloc(x->index, (rID + 1)*sizeof(uint32_t));
        memset(x->index + x->len, -1, sizeof(uint32_t)*((rID + 1) - x->len));
        x->len = rID + 1;
	}

	x->index[rID] = uID & (uint32_t)(0x7fffffff);
	x->index[rID] = x->index[rID] | (uint32_t)(is_Unitig<<31);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
testq %r8, %r8
je 0xa1cf1
cmpb $0x4, (%r8)
je 0xa1d42
movl %r15d, %r12d
cmpq %r12, (%r14)
ja 0xa1d2f
movq 0x8(%r14), %rdi
incl %r15d
leaq (,%r15,4), %rsi
callq 0x2370
movq %rax, 0x8(%r14)
movq (%r14), %rcx
leaq (%rax,%rcx,4), %rdi
movq %r15, %rdx
subq %rcx, %rdx
shlq $0x2, %rdx
movl $0xff, %esi
callq 0x20e0
movq %r15, (%r14)
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq 0x8(%r14), %rax
shll $0x1f, %ebx
orl %ebp, %ebx
movl %ebx, (%rax,%r12,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: transfor_R_to_U(R_to_U*)
void transfor_R_to_U(R_to_U* x)
{
    uint64_t i = 0;
    uint32_t rID, uID, is_Unitig;
    for (i = 0; i < x->len; i++)
    {
        rID = i;
        get_R_to_U(x, rID, &uID, &is_Unitig);
        if(uID == (uint32_t)-1) continue;
        if(is_Unitig == 1) continue;


        ///here i/rID is contained in uID
        rID = uID;
        while (1)
        {
            get_R_to_U(x, rID, &uID, &is_Unitig);
            if(uID == (uint32_t)-1) break;
            if(is_Unitig == 1) break;
            rID = uID;
        }

        set_R_to_U(x, i, rID, 0, NULL);
    }


    /**
    for (i = 0; i < x->len; i++)
    {
        rID = i;
        get_R_to_U(x, rID, &uID, &is_Unitig);
        if(uID == (uint32_t)-1) continue;
        if(is_Unitig == 1) continue;
        ///here i/rID is contained in uID
        rID = uID;
        get_R_to_U(x, rID, &uID, &is_Unitig);
        if(uID != (uint32_t)-1)
        {
            fprintf(stderr, "ERROR\n");
        }
    }
    **/
    
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0xa1dbe
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl %r14d, %ecx
movq 0x8(%rbx), %rdx
movl (%rdx,%rcx,4), %ecx
testl %ecx, %ecx
js 0xa1dac
movl %ecx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rdx, %rax
jbe 0xa1d90
movq 0x8(%rbx), %rsi
movl (%rsi,%rdx,4), %esi
cmpl $-0x1, %esi
je 0xa1d90
movl %esi, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shrl $0x1f, %esi
jmp 0xa1d92
xorl %esi, %esi
cmpl $-0x1, %ecx
je 0xa1d9c
testb %sil, %sil
je 0xa1d6b
movq %rbx, %rdi
movl %r14d, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa1cd4
incq %r14
movq (%rbx), %rax
cmpq %rax, %r14
jb 0xa1d5d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: collect_sides_trio(ma_hit_t_alloc*, unsigned long, ma_sub_t*, ma_sub_t*, unsigned int)
void collect_sides_trio(ma_hit_t_alloc* paf, uint64_t rLen, ma_sub_t* max_left, ma_sub_t* max_right,
uint32_t trio_flag)
{
    long long j;
    uint32_t qs, qe;
    for (j = 0; j < paf->length; j++)
    {
        if(paf->buffer[j].del) continue;

        if(R_INF.trio_flag[Get_tn(paf->buffer[j])] == trio_flag) continue;

        qs = Get_qs(paf->buffer[j]);
        qe = Get_qe(paf->buffer[j]);

        ///overlaps from left side
        if(qs == 0)
        {
            if(qs < max_left->s) max_left->s = qs;
            if(qe > max_left->e) max_left->e = qe;
        }

        ///overlaps from right side
        if(qe == rLen)
        {
            if(qs < max_right->s) max_right->s = qs;
            if(qe > max_right->e) max_right->e = qe;
        }

        ///note: if (qs == 0 && qe == rLen)
        ///this overlap would be added to both b_left and b_right
        ///that is what we want
    }
}

// Assembly:
cmpl $0x0, 0xc(%rdi)
je 0xa2417
pushq %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
leaq 0x1e8eab(%rip), %r9     # 0x28b230
xorl %r10d, %r10d
movq (%rdi), %r11
cmpq $0x0, 0x18(%r11,%rax)
js 0xa23ff
movq 0x28(%r9), %rbx
movl 0xc(%r11,%rax), %r14d
movzbl (%rbx,%r14), %ebx
cmpl %r8d, %ebx
je 0xa23ff
movl (%r11,%rax), %ebx
movl 0x8(%r11,%rax), %r11d
testl %ebx, %ebx
jne 0xa23cf
movl (%rdx), %ebp
testl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
je 0xa23c5
andl $0x80000000, %ebp       # imm = 0x80000000
movl %ebp, (%rdx)
cmpl 0x4(%rdx), %r11d
jbe 0xa23cf
movl %r11d, 0x4(%rdx)
cmpq %rsi, %r11
jne 0xa23ff
movl (%rcx), %ebp
movl %ebp, %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
cmpl %ebx, %r14d
jbe 0xa23f5
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
andl $0x80000000, %ebp       # imm = 0x80000000
orl %ebx, %ebp
movl %ebp, (%rcx)
cmpl 0x4(%rcx), %r11d
jbe 0xa23ff
movl %r11d, 0x4(%rcx)
incq %r10
movl 0xc(%rdi), %r11d
addq $0x28, %rax
cmpq %r11, %r10
jb 0xa2388
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: intersection_check(ma_hit_t_alloc*, unsigned long, unsigned int, unsigned int)
int intersection_check(ma_hit_t_alloc* paf, uint64_t rLen, uint32_t interval_s, uint32_t interval_e)
{
    long long j, cov = 0;
    uint32_t qs, qe;

    for (j = 0; j < paf->length; j++)
    {
        qs = Get_qs(paf->buffer[j]);
        qe = Get_qe(paf->buffer[j]);
        ///[interval_s, interval_e) must be at least contained at one of the [qs, qe)
        if(qs<=interval_s && qe>=interval_e)
        {
            cov++;
        }
    }

    return cov;
}

// Assembly:
movl 0xc(%rdi), %eax
testq %rax, %rax
je 0xa296a
movq (%rdi), %rsi
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdi
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %edx, (%rsi,%r8)
ja 0xa2960
cmpl %ecx, 0x8(%rsi,%r8)
sbbq $-0x1, %rax
addq $0x28, %r8
cmpq %r8, %rdi
jne 0xa2951
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: intersection_check_by_base(ma_hit_t_alloc*, unsigned long, unsigned int, unsigned int, char*, char*)
int intersection_check_by_base(ma_hit_t_alloc* paf, uint64_t rLen, uint32_t interval_s, uint32_t interval_e,
char* bq, char* bt)
{
    long long j;
    uint32_t qs, qe;

    for (j = 0; j < paf->length; j++) {
        if(paf->buffer[j].del) continue;

        qs = Get_qs(paf->buffer[j]);
        qe = Get_qe(paf->buffer[j]);
        ///[interval_s, interval_e) must be at least contained at one of the [qs, qe)
        if(qs<=interval_s && qe>=interval_e) {
            if((paf->buffer[j].el) || 
                    (boundary_verify(interval_s, interval_e, &(paf->buffer[j]), bq, bt, &R_INF) == 0)) {
                return 1;
            }
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpl $0x0, 0xc(%rdi)
je 0xa29f0
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r12
xorl %ebx, %ebx
xorl %r14d, %r14d
movl $0x1, %r13d
movq (%r12), %rax
cmpq $0x0, 0x18(%rax,%rbx)
js 0xa29df
leaq (%rax,%rbx), %rdx
cmpl %r15d, (%rdx)
ja 0xa29df
cmpl %ebp, 0x8(%rax,%rbx)
jb 0xa29df
cmpb $0x0, 0x20(%rax,%rbx)
jne 0xa29f3
movl %r15d, %edi
movl %ebp, %esi
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
leaq 0x1e885a(%rip), %r9     # 0x28b230
callq 0xa2251
testl %eax, %eax
je 0xa29f3
incq %r14
movl 0xc(%r12), %eax
addq $0x28, %rbx
cmpq %rax, %r14
jb 0xa299e
xorl %r13d, %r13d
movl %r13d, %eax
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/Overlaps.cpp
// Function: asg_extend(asg_t const*, unsigned int, int, asg64_v*)
int asg_extend(const asg_t *g, uint32_t v, int max_ext, asg64_v *a)
{
	int ret;
	uint64_t lw;
	a->n = 0;
	kv_push(uint64_t, *a, v);
	do {
        /**
		 test (v) and (v^1), 
         if the out-degrees of both (v) and (v^1) are 1, ret == 0
        **/
		ret = asg_is_utg_end(g, v^1, &lw);
        /**
        #define ASG_ET_MERGEABLE 0
        #define ASG_ET_TIP       1
        #define ASG_ET_MULTI_OUT 2
        #define ASG_ET_MULTI_NEI 3
        **/
		if (ret != 0) break;
		kv_push(uint64_t, *a, lw);
		/**
		 ret == 0 means: 
		   v^1 and is the only prefix of (uint32_t)lw, 
		   and (uint32_t)lw is the only prefix of v^1
		**/
		
		v = (uint32_t)lw;
	} while (--max_ext > 0);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
movq $0x0, (%rcx)
cmpq $0x0, 0x8(%rcx)
jne 0xa2f17
movq $0x2, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movl $0x10, %esi
callq 0x2370
movq %rax, 0x10(%rbx)
movl %r12d, %eax
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, (%rbx)
movq %rax, (%rdx,%rcx,8)
movl $0x2, %r13d
movq 0x8(%r14), %rax
movq 0x28(%r14), %rcx
movl %r12d, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, %rdx
shrq $0x20, %rdx
leaq (%rdx,%rdx,2), %rdx
testl %esi, %esi
jle 0xa2f8c
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
leaq (%rax,%rdx,8), %r9
addq $0xc, %r9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
xorl %edi, %edi
xorl %r11d, %r11d
cmpl $0x0, (%r9)
setns %r11b
cmovnsl %r10d, %r8d
addl %r11d, %edi
incq %r10
addq $0x18, %r9
cmpq %r10, %rsi
jne 0xa2f69
movslq %r8d, %rsi
jmp 0xa2f95
xorl %edi, %edi
movq $-0x1, %rsi
testl %edi, %edi
je 0xa2ffb
cmpl $0x1, %edi
jne 0xa3002
leaq (%rax,%rdx,8), %rdx
leaq (%rsi,%rsi,2), %rsi
movq (%rdx,%rsi,8), %r12
shlq $0x20, %r12
movl 0x8(%rdx,%rsi,8), %edx
orq %rdx, %r12
xorq $0x1, %rdx
movq (%rcx,%rdx,8), %rcx
testl %ecx, %ecx
jle 0xa3009
movq %rcx, %rdx
shrq $0x20, %rdx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,8), %rdx
addq $0xc, %rdx
xorl %eax, %eax
movl (%rdx), %esi
notl %esi
shrl $0x1f, %esi
addl %esi, %eax
addq $0x18, %rdx
decq %rcx
jne 0xa2fdc
xorl %ecx, %ecx
cmpl $0x1, %eax
setne %cl
leal (%rcx,%rcx,2), %ebp
jmp 0xa300e
movl $0x1, %ebp
jmp 0xa300e
movl $0x2, %ebp
jmp 0xa300e
movl $0x3, %ebp
testl %ebp, %ebp
jne 0xa305e
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jne 0xa303b
leaq (%rax,%rax), %rsi
testq %rax, %rax
cmoveq %r13, %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x3, %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movq %r12, (%rcx,%rax,8)
leal -0x1(%r15), %eax
cmpl $0x1, %r15d
movl %eax, %r15d
jg 0xa2f32
movl %ebp, %eax
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/Overlaps.cpp
// Function: get_R_to_U(R_to_U*, unsigned int, unsigned int*, unsigned int*)
void get_R_to_U(R_to_U* x, uint32_t rID, uint32_t* uID, uint32_t* is_Unitig)
{
	if(rID >= x->len || (x->index[rID] == (uint32_t)(-1)))
	{
		(*uID) = (uint32_t)-1;
		(*is_Unitig) = (uint32_t)-1;
		return;
	}
    
    (*uID) = x->index[rID] & (uint32_t)(0x7fffffff);
	(*is_Unitig) = (x->index[rID]>>31);
}

// Assembly:
movl %esi, %eax
cmpq %rax, (%rdi)
jbe 0xa3092
movq 0x8(%rdi), %rsi
movl (%rsi,%rax,4), %edi
cmpl $-0x1, %edi
je 0xa3092
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movl %edi, (%rdx)
movl (%rsi,%rax,4), %eax
shrl $0x1f, %eax
jmp 0xa309d
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: prt_specific_overlap(ma_hit_t_alloc*, unsigned long, unsigned long, char const*)
void prt_specific_overlap(ma_hit_t_alloc *src, uint64_t qn, uint64_t tn, const char *cmd)
{
    ma_hit_t *h = NULL; int64_t idx = -1, k;
    if(tn != ((uint64_t)-1)) {
        idx = get_specific_overlap(&(src[qn]), qn, tn); h = &(src[qn].buffer[idx]);
        fprintf(stderr, "%s::idx::%ld[M::%s::] qn::%u, tn::%u, del::%u, bl::%u, ml::%u\n", cmd, idx, __func__, 
        Get_qn(*h), Get_tn(*h), h->del, h->bl, h->ml);
    } else {
        for (k = 0; k < src[qn].length; k++) {
            h = &(src[qn].buffer[k]);
            fprintf(stderr, "%s::idx::%ld[M::%s::] qn::%u, tn::%u, del::%u, bl::%u, ml::%u\n", cmd, idx, __func__, 
            Get_qn(*h), Get_tn(*h), h->del, h->bl, h->ml); 
        }
    }
}

// Assembly:
pushq %rax
movq %rdx, %rax
leaq (%rsi,%rsi,2), %rdx
leaq (%rdi,%rdx,8), %rdx
cmpq $-0x1, %rax
jne 0xa32c0
cmpl $0x0, 0xc(%rdx)
jne 0xa32cd
popq %rax
retq
movq %rsi, %rdi
movq %rax, %rsi
callq 0xfc93
jmp 0xa32be
leaq 0xc(%rdx), %rax
movq %rdx, %rdi
movq %rcx, %rsi
movq %rax, %rdx
callq 0xfd2b
jmp 0xa32be
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: single_edge_length(asg_t*, unsigned int, unsigned int, long long)
long long single_edge_length(asg_t *g, uint32_t begNode, uint32_t endNode, long long edgeLen)
{
    
    uint32_t v = begNode;
    uint32_t nv = asg_arc_n(g, v);
    asg_arc_t *av = asg_arc_a(g, v);
    long long rLen = 0;

    while (rLen < edgeLen && nv == 1)
    {
        rLen++;
        if((av[0].v>>1) == endNode)
        {
            return rLen;
        }

        if(asg_is_single_edge(g, av[0].v, v>>1) != 1)
        {
            return -1;
        }

        v = av[0].v;
        nv = asg_arc_n(g, v);
        av = asg_arc_a(g, v);      
    }

    return -1;   

}

// Assembly:
movq $-0x1, %r8
testq %rcx, %rcx
jle 0xa36c6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %r15
movq 0x28(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
cmpl $0x1, %ecx
jne 0xa36b8
shrq $0x20, %rax
leaq (%rax,%rax,2), %rbx
shlq $0x3, %rbx
addq 0x8(%r15), %rbx
xorl %r12d, %r12d
movl $0x1, %r13d
incq %r12
movl 0x8(%rbx), %eax
movl %eax, %ecx
shrl %ecx
cmpl %edx, %ecx
je 0xa36b5
movq 0x28(%r15), %rcx
xorq $0x1, %rax
movq (%rcx,%rax,8), %rax
xorl %ebp, %ebp
testl %eax, %eax
jle 0xa3667
movq 0x8(%r15), %r9
movq %rax, %rdi
shrq $0x20, %rdi
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
leaq (%rdi,%rdi,2), %rdi
leaq (%r9,%rdi,8), %r9
addq $0x8, %r9
movl (%r9), %edi
xorl %esi, %edi
cmpl $0x2, %edi
cmovbl %r13d, %ebp
addq $0x18, %r9
decq %rcx
jne 0xa3644
testl %ebp, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
jmp 0xa3669
movb $0x1, %cl
testb %cl, %cl
jne 0xa369f
testb %bpl, %bpl
je 0xa36b8
cmpq %r14, %r12
jge 0xa36b8
movl 0x8(%rbx), %esi
movq 0x28(%r15), %rax
movq (%rax,%rsi,8), %rax
movl %eax, %ecx
shrq $0x20, %rax
leaq (%rax,%rax,2), %rbx
shlq $0x3, %rbx
addq 0x8(%r15), %rbx
cmpl $0x1, %ecx
je 0xa3601
jmp 0xa36b8
movl %edx, 0x4(%rsp)
callq 0xfdc4
movl 0x4(%rsp), %edx
movq $-0x1, %r8
jmp 0xa366d
movq %r12, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movq %r8, %rax
retq