LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: bubble_identify_worker(void*, long, int)
static void bubble_identify_worker(void *_data, long eid, int tid)
{
    bub_label_t *buf = (bub_label_t*)_data;
    buf_s_t *b = &(buf->b[tid]);
    uint32_t v = eid, i;
    asg_t *g = buf->g;
    if(g->seq[v>>1].del) return;
    if(asg_arc_n(g, v) < 2 || get_real_length(g, v, NULL) < 2) return;

    if(g->seq_vis[v] != 1 && asg_bub_pop1_label(g, v, buf->bub_dist, b))
    {
        //beg is v, end is b.S.a[0]
        //note b.b include end, does not include beg
        for (i = 0; i < b->b.n; i++)
        {
            if(b->b.a[i]==v || b->b.a[i]==b->S.a[0]) continue;
            g->seq_vis[b->b.a[i]] = 1;
            g->seq_vis[b->b.a[i]^1] = 1;
        }
        g->seq_vis[v] = 1;
        g->seq_vis[b->S.a[0]^1] = 1;
    }

    if(buf->check_cross == 1 && g->seq_vis[v] == 0 && check_if_cross(g, v))
    {
        g->seq_vis[v] = 2;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rbx
movq 0x20(%rbx), %rax
movl %r14d, %ecx
shrl %ecx
cmpl $0x0, (%rax,%rcx,8)
js 0xa817d
movq 0x28(%rbx), %rax
movl %r14d, %r13d
movq (%rax,%r13,8), %rax
testl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
je 0xa817d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
andq %rax, %rcx
je 0xa817d
movq %rdi, %r15
movslq %edx, %rdx
leaq (%rdx,%rdx,4), %r12
shlq $0x4, %r12
addq (%rdi), %r12
movq 0x8(%rbx), %rdx
shrq $0x20, %rax
leaq (%rax,%rax,2), %rax
leaq (%rdx,%rax,8), %rax
addq $0xc, %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
xorl %esi, %esi
movl (%rax,%rdx), %edi
notl %edi
shrl $0x1f, %edi
addl %edi, %esi
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0xa80a3
cmpl $0x2, %esi
jl 0xa817d
movq 0x30(%rbx), %rax
cmpb $0x1, (%rax,%r13)
je 0xa8153
movq 0x20(%r15), %rdx
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rcx
callq 0xe5e6d
testq %rax, %rax
je 0xa8153
movq 0x20(%r12), %rdx
testq %rdx, %rdx
je 0xa8137
movl $0x1, %eax
xorl %esi, %esi
movb $0x1, %cl
movq 0x30(%r12), %rdi
movl (%rdi,%rsi,4), %edi
cmpl %r14d, %edi
je 0xa812e
movq 0x18(%r12), %r8
cmpl (%r8), %edi
je 0xa812e
movq 0x30(%rbx), %rdx
movb %cl, (%rdx,%rdi)
movq 0x30(%rbx), %rdx
movq 0x30(%r12), %rdi
movl (%rdi,%rsi,4), %esi
xorq $0x1, %rsi
movb %cl, (%rdx,%rsi)
movq 0x20(%r12), %rdx
movl %eax, %esi
incl %eax
cmpq %rsi, %rdx
ja 0xa80f8
movq 0x30(%rbx), %rax
movb $0x1, %cl
movb %cl, (%rax,%r13)
movq 0x30(%rbx), %rax
movq 0x18(%r12), %rdx
movl (%rdx), %edx
xorq $0x1, %rdx
movb %cl, (%rax,%rdx)
cmpl $0x1, 0x18(%r15)
jne 0xa817d
movq 0x30(%rbx), %rax
cmpb $0x0, (%rax,%r13)
jne 0xa817d
movq %rbx, %rdi
movl %r14d, %esi
callq 0xa78a4
testl %eax, %eax
je 0xa817d
movq 0x30(%rbx), %rax
movb $0x2, (%rax,%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/./Overlaps.h
// Function: asg_seq_del(asg_t*, unsigned int)
static inline void asg_seq_del(asg_t *g, uint32_t s)
{
	uint32_t k;
	g->seq[s].del = 1;
	for (k = 0; k < 2; ++k) {
		uint32_t i, v = s<<1 | k;
		uint32_t nv = asg_arc_n(g, v);
		asg_arc_t *av = asg_arc_a(g, v);
		for (i = 0; i < nv; ++i) {
			av[i].del = 1;
			asg_arc_del(g, av[i].v^1, v^1, 1);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movl %esi, %ecx
orl $0x80000000, (%rax,%rcx,8) # imm = 0x80000000
addl %esi, %esi
movb $0x1, %al
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
orq %rsi, %rcx
movq 0x28(%rdi), %r8
movq (%r8,%rcx,8), %r9
testl %r9d, %r9d
je 0xa904b
movq %r9, %r8
shrq $0x20, %r8
leaq (%r8,%r8,2), %r8
shlq $0x3, %r8
addq 0x8(%rdi), %r8
movl %r9d, %r9d
xorl %r10d, %r10d
leaq (%r10,%r10,2), %r11
orb $-0x80, 0xf(%r8,%r11,8)
movl 0x8(%r8,%r11,8), %r11d
xorq $0x1, %r11
movq 0x28(%rdi), %rbx
movq (%rbx,%r11,8), %rbx
movq %rbx, %r11
andq %rdx, %r11
je 0xa9043
movq 0x8(%rdi), %r14
shrq $0x20, %rbx
shlq $0x3, %r11
leaq (%r11,%r11,2), %r11
leaq (%rbx,%rbx,2), %rbx
leaq (%r14,%rbx,8), %rbx
addq $0xc, %rbx
xorl %r14d, %r14d
movl -0x4(%rbx,%r14), %ebp
xorl %ecx, %ebp
cmpl $0x1, %ebp
jne 0xa903a
orb $-0x80, 0x3(%rbx,%r14)
addq $0x18, %r14
cmpq %r14, %r11
jne 0xa9028
incq %r10
cmpq %r9, %r10
jne 0xa8fe6
movl $0x1, %ecx
testb $0x1, %al
movl $0x0, %eax
jne 0xa8fbd
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_arc_del_single_node_directly(asg_t*, long long, ma_hit_t_alloc*)
int asg_arc_del_single_node_directly(asg_t *g, long long longLen_thres, ma_hit_t_alloc* sources)
{
    double startTime = Get_T();
    ///the reason is that each read has two direction (query->target, target->query)
	uint32_t v, n_vtx = g->n_seq * 2, n_reduced = 0;
    for (v = 0; v < n_vtx; ++v) 
    {
        uint32_t nv = asg_arc_n(g, v);
        if (g->seq[v>>1].del)
        {
            continue;
        } 

        if(nv != 2)
        {
            continue;
        }

        n_reduced += test_single_node_bubble_directly(g, v, longLen_thres, sources);
    }


    if (n_reduced) {
		asg_cleanup(g);
		asg_symm(g);
	}

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

    return n_reduced;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2f3fc
movl 0x14(%rbx), %eax
addl %eax, %eax
je 0xa9613
movl %eax, %r13d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x20(%rbx), %rax
movl %r12d, %ecx
shrl %ecx
cmpl $0x0, (%rax,%rcx,8)
js 0xa95e9
movq 0x28(%rbx), %rax
cmpl $0x2, (%rax,%r12,8)
jne 0xa95e9
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0xa9062
addl %eax, %ebp
incq %r12
cmpq %r12, %r13
jne 0xa95bc
testl %ebp, %ebp
je 0xa9613
movq %rbx, %rdi
callq 0xa0a7d
movq %rbx, %rdi
callq 0xa0ab6
movq %rbx, %rdi
callq 0xa0b79
orb $-0x80, 0x17(%rbx)
jmp 0xa9615
xorl %ebp, %ebp
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_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_arc_del_cross_bubble(asg_t*, long long)
int asg_arc_del_cross_bubble(asg_t *g, long long max_dist)
{
    double startTime = Get_T();
    ///the reason is that each read has two direction (query->target, target->query)
	uint32_t v, n_vtx = g->n_seq * 2, n_reduced = 0;
    buf_t b;
	if (!g->is_symm) asg_symm(g);
	memset(&b, 0, sizeof(buf_t));
	///set information for each node
	b.a = (binfo_t*)calloc(n_vtx, sizeof(binfo_t));
    for (v = 0; v < n_vtx; ++v) 
    {
        uint32_t nv = asg_arc_n(g, v);
        if (g->seq[v>>1].del)
        {
            continue;
        } 

        if(nv < 2)
        {
            continue;
        }

        ///if this is a bubble
        if(asg_bub_finder_with_del_advance(g, v, max_dist, &b) == 1)
        {
            n_reduced += test_cross(g, b.b.a, b.b.n, v, b.S.a[0]);
        }
    
    }

    free(b.a); free(b.S.a); free(b.T.a); free(b.b.a); free(b.e.a);

    if (n_reduced) {        
		asg_cleanup(g);
		asg_symm(g);
	}

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

    return n_reduced;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2f3fc
movl 0x14(%rbx), %eax
leal (%rax,%rax), %ebp
testl %eax, %eax
js 0xa9bed
movq %rbx, %rdi
callq 0xa0ab6
movq %rbx, %rdi
callq 0xa0b79
orb $-0x80, 0x17(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsp)
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
movl %ebp, %r15d
movl $0x1c, %esi
movq %r15, %rdi
callq 0x2120
movq %rax, (%rsp)
testl %ebp, %ebp
je 0xa9ca2
xorl %r12d, %r12d
movq %rsp, %r13
xorl %ebp, %ebp
movq 0x20(%rbx), %rax
movl %r12d, %ecx
shrl %ecx
cmpl $0x0, (%rax,%rcx,8)
js 0xa9c80
movq 0x28(%rbx), %rax
testl $0xfffffffe, (%rax,%r12,8) # imm = 0xFFFFFFFE
je 0xa9c80
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
movq %r13, %rcx
callq 0xa74af
cmpq $0x1, %rax
jne 0xa9c80
movq 0x48(%rsp), %rsi
movl 0x38(%rsp), %edx
movq 0x18(%rsp), %rax
movl (%rax), %r8d
movq %rbx, %rdi
movl %r12d, %ecx
callq 0xa9626
addl %eax, %ebp
incq %r12
cmpq %r12, %r15
jne 0xa9c2e
movq (%rsp), %rax
movq 0x18(%rsp), %r13
movq 0x30(%rsp), %r12
movq 0x48(%rsp), %r15
movq 0x60(%rsp), %r14
jmp 0xa9cb0
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rax, %rdi
callq 0x2220
movq %r13, %rdi
callq 0x2220
movq %r12, %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2220
testl %ebp, %ebp
je 0xa9cf8
movq %rbx, %rdi
callq 0xa0a7d
movq %rbx, %rdi
callq 0xa0ab6
movq %rbx, %rdi
callq 0xa0b79
orb $-0x80, 0x17(%rbx)
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: if_long_tip_length(asg_t*, ma_ug_t*, unsigned int, unsigned int*, long long, long long, float, long long)
uint32_t if_long_tip_length(asg_t *sg, ma_ug_t *ug, uint32_t begNode, uint32_t* untigLen, 
long long minLongUntig, long long maxShortUntig, float ShortUntigRate, long long mainLen)
{
    long long nodeLen, baseLen, max_stop_nodeLen, max_stop_baseLen;
    uint32_t Len, endNode;
    if(untigLen == NULL)
    {
        if(get_unitig(sg, ug, begNode, &endNode, &nodeLen, &baseLen, 
                                        &max_stop_nodeLen, &max_stop_baseLen, 1, NULL) == LOOP)
        {
            ///the length of LOOP is infinite
            return 1;
        }
        Len = nodeLen;
    }
    else
    {
        Len = (*untigLen);
    }
    
    
    if(Len == 0) return 0;
    if(Len < (ShortUntigRate*mainLen)) return 0;
    if(Len >= maxShortUntig) return 1;
    if(Len >= minLongUntig && Len >= (ShortUntigRate*mainLen)) return 1;
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %rbx
testq %rcx, %rcx
je 0xab295
movl (%rcx), %ecx
jmp 0xab2da
movss %xmm0, 0xc(%rsp)
leaq 0x20(%rsp), %rax
leaq 0x28(%rsp), %r10
leaq 0x1c(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x30(%rsp), %r9
pushq $0x0
pushq $0x1
pushq %rax
pushq %r10
callq 0x1053a7
addq $0x20, %rsp
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x7, %ecx
je 0xab312
movl 0x10(%rsp), %ecx
movss 0xc(%rsp), %xmm0
xorl %eax, %eax
testl %ecx, %ecx
je 0xab312
movl %ecx, %ecx
cvtsi2ss %rcx, %xmm2
cvtsi2ssq 0x50(%rsp), %xmm1
mulss %xmm0, %xmm1
ucomiss %xmm2, %xmm1
ja 0xab312
movl $0x1, %eax
cmpq %r14, %rcx
jge 0xab312
cmpq %rbx, %rcx
setge %al
ucomiss %xmm1, %xmm2
setae %cl
andb %al, %cl
movzbl %cl, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_topocut_aux(asg_t*, unsigned int, int)
int asg_topocut_aux(asg_t *g, uint32_t v, int max_ext)
{
	int32_t n_ext;
	for (n_ext = 1; n_ext < max_ext && v != (uint32_t)-1; ++n_ext) {
		if (asg_check_unambi1(g, v^1) == (uint32_t)-1) {
			--n_ext;
			break;
		}
		v = asg_check_unambi1(g, v);
	}
    
	return n_ext;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, %edx
setl %al
cmpl $-0x1, %esi
sete %cl
movl $0x1, %r14d
orb %al, %cl
jne 0xab7c8
movl %edx, %ebx
movl %esi, %ebp
movq 0x8(%rdi), %r15
movq 0x28(%rdi), %r12
xorl %r14d, %r14d
movl %ebp, %edx
xorl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0xab7d4
cmpl $-0x1, %eax
je 0xab7c8
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xab7d4
movl %eax, %ebp
leal 0x1(%r14), %eax
cmpl $-0x1, %ebp
je 0xab7c3
addl $0x2, %r14d
cmpl %ebx, %r14d
movl %eax, %r14d
jl 0xab78a
incl %eax
movl %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_check_unambi1(asg_t*, unsigned int)
static uint32_t asg_check_unambi1(asg_t *g, uint32_t v)
{
	asg_arc_t *av = asg_arc_a(g, v);
	uint32_t i, nv = asg_arc_n(g, v);
	uint32_t k = nv, kv;
	for (i = 0, kv = 0; i < nv; ++i)
		if (!av[i].del) ++kv, k = i;
	if (kv != 1) return (uint32_t)-1;
	return av[k].v;
}

// Assembly:
movl %edx, %eax
movq (%rsi,%rax,8), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0xab82f
movq %rcx, %rdx
shrq $0x20, %rdx
leaq (%rdx,%rdx,2), %r8
leaq (%rdi,%r8,8), %rdx
movl %ecx, %esi
leaq (%rdi,%r8,8), %rdi
addq $0xc, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpl $0x0, (%rdi)
setns %r10b
cmovnsl %r8d, %ecx
addl %r10d, %r9d
incq %r8
addq $0x18, %rdi
cmpq %r8, %rsi
jne 0xab802
cmpl $0x1, %r9d
jne 0xab82f
movl %ecx, %eax
leaq (%rax,%rax,2), %rax
movl 0x8(%rdx,%rax,8), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_topocut_aux_pg(asg_t*, unsigned int, int, unsigned int*)
int asg_topocut_aux_pg(asg_t *g, uint32_t v, int max_ext, uint32_t *rv)
{
    int32_t n_ext; (*rv) = (uint32_t)-1;
    for (n_ext = 1; n_ext < max_ext && v != (uint32_t)-1; ++n_ext) {
        if (asg_check_unambi1(g, v^1) == (uint32_t)-1) {
            --n_ext; (*rv) = v^1;/// asg_arc_n(g, v) >= 2
            break;
        }
        v = asg_check_unambi1(g, v);
    }
    
    return n_ext;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
cmpl $0x2, %edx
setl %al
cmpl $-0x1, %esi
sete %dl
movl $0x1, %r15d
orb %al, %dl
jne 0xab8b6
movl %esi, %ebx
movq %rcx, (%rsp)
movq 0x8(%rdi), %r12
movq 0x28(%rdi), %r13
xorl %r15d, %r15d
movl %ebx, %r14d
xorl $0x1, %r14d
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0xab7d4
cmpl $-0x1, %eax
je 0xab8af
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0xab7d4
movl %eax, %ebx
leal 0x1(%r15), %eax
cmpl $-0x1, %ebx
je 0xab8a8
addl $0x2, %r15d
cmpl %ebp, %r15d
movl %eax, %r15d
jl 0xab86a
incl %eax
movl %eax, %r15d
jmp 0xab8b6
movq (%rsp), %rax
movl %r14d, (%rax)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: count_edges_v_w(asg_t*, unsigned int, unsigned int)
int64_t count_edges_v_w(asg_t *g, uint32_t v, uint32_t w)
{
    asg_arc_t* av = asg_arc_a(g, v); uint32_t nv = asg_arc_n(g, v), i, occ = 0;
    for (i = 0; i < nv; i++) {
        if(av[i].del) continue;
        if(av[i].v == w) occ++;
    }
    return occ;
}

// Assembly:
movq 0x28(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rcx
xorl %eax, %eax
testl %ecx, %ecx
je 0xb0fb1
movq 0x8(%rdi), %rsi
movq %rcx, %rdi
shrq $0x20, %rdi
movl %ecx, %r8d
leaq (%rdi,%rdi,2), %rcx
leaq (%rsi,%rcx,8), %rcx
addq $0xc, %rcx
shlq $0x3, %r8
leaq (%r8,%r8,2), %rsi
xorl %edi, %edi
cmpl $0x0, (%rcx,%rdi)
js 0xb0fa6
xorl %r8d, %r8d
cmpl %edx, -0x4(%rcx,%rdi)
sete %r8b
addl %r8d, %eax
addq $0x18, %rdi
cmpq %rdi, %rsi
jne 0xb0f92
movl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: update_ug_ou(ma_ug_t*, asg_t*)
void update_ug_ou(ma_ug_t *ug, asg_t *sg)
{
    uint32_t k, i, uv, uw, rv, rw, nv; asg_arc_t *ue, *av;
    for (k = 0; k < ug->g->n_arc; k++) {
        ue = &(ug->g->arc[k]); ue->ou = 0;
        uv = ue->ul>>32; uw = ue->v;
        if(uv&1) rv = ug->u.a[uv>>1].start^1;
        else rv = ug->u.a[uv>>1].end^1;

        if(uw&1) rw = ug->u.a[uw>>1].end;
        else rw = ug->u.a[uw>>1].start;

        av = asg_arc_a(sg, rv);
        nv = asg_arc_n(sg, rv);
        for (i = 0; i < nv; i++) {
            if(av[i].v == rw) break;
        }
        assert(i < nv);
        ue->ou = av[i].ou;
    }

    // asg_arc_t *e; uint32_t v, w;
    // for (k = 0; k < sg->n_arc; k++) {
    //     e = &(sg->arc[k]);
    //     v = e->v^1; w = (e->ul>>32)^1;
    //     av = asg_arc_a(sg, v); nv = asg_arc_n(sg, v);
    //     for (i = 0; i < nv; i++) {
    //         if(av[i].v == w) break;
    //     }
    //     if(i >= nv || av[i].ou != e->ou) fprintf(stderr, "[M::%s::asymmetry]\n", __func__);
    // }

    // for (k = 0; k < ug->g->n_arc; k++) {
    //     e = &(ug->g->arc[k]);
    //     v = e->v^1; w = (e->ul>>32)^1;
    //     av = asg_arc_a(ug->g, v); nv = asg_arc_n(ug->g, v);
    //     for (i = 0; i < nv; i++) {
    //         if(av[i].v == w) break;
    //     }
    //     if(i >= nv || av[i].ou != e->ou) fprintf(stderr, "[M::%s::asymmetry]\n", __func__);
    // }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rdx
testl $0x7fffffff, 0x4(%rdx)  # imm = 0x7FFFFFFF
je 0xb10a8
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq 0x8(%rdx), %r8
leaq (%rax,%rax,2), %r9
movzwl 0x10(%r8,%r9,8), %edx
andl $0xc000, %edx           # imm = 0xC000
movw %dx, 0x10(%r8,%r9,8)
movq (%r8,%r9,8), %r11
xorl %ebx, %ebx
btq $0x20, %r11
setae %bl
movq 0x10(%rdi), %r10
shrq $0x21, %r11
leaq (%r11,%r11,4), %r11
leaq (%r10,%r11,8), %r11
movl 0x4(%r11,%rbx,4), %r11d
xorq $0x1, %r11
movq 0x28(%rsi), %rbx
movq (%rbx,%r11,8), %rbx
movq %rbx, %r11
andq %rcx, %r11
je 0xb10ae
leaq (%r8,%r9,8), %r8
movl 0x8(%r8), %r9d
movl %r9d, %r14d
shrl %r14d
leaq (%r14,%r14,4), %r14
leaq (%r10,%r14,8), %r10
andl $0x1, %r9d
movl 0x4(%r10,%r9,4), %r10d
movq 0x8(%rsi), %r9
shrq $0x20, %rbx
leaq (%rbx,%rbx,2), %rbx
leaq (%r9,%rbx,8), %r14
addq $0x10, %r14
shlq $0x3, %r11
leaq (%r11,%r11,2), %r15
xorl %r11d, %r11d
cmpl %r10d, -0x8(%r14,%r11)
je 0xb1074
addq $0x18, %r11
cmpq %r11, %r15
jne 0xb1062
jmp 0xb10ae
leaq (%r9,%rbx,8), %r9
movzwl 0x10(%r11,%r9), %r9d
andl $0x3fff, %r9d           # imm = 0x3FFF
orl %r9d, %edx
movw %dx, 0x10(%r8)
incq %rax
movq 0x18(%rdi), %rdx
movl 0x4(%rdx), %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
cmpq %r8, %rax
jb 0xb0fcf
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1851e9(%rip), %rdi    # 0x23629e
leaq 0x184dd5(%rip), %rsi    # 0x235e91
leaq 0x1851e2(%rip), %rcx    # 0x2362a5
movl $0x2207, %edx           # imm = 0x2207
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_overlapLen(unsigned int, ma_hit_t_alloc*, unsigned int*, unsigned int*)
void get_overlapLen(uint32_t rId, ma_hit_t_alloc* sources, uint32_t* exactLen, uint32_t* inexactLen)
{
    (*exactLen) = (*inexactLen) = 0;
    ma_hit_t_alloc* x = &(sources[rId]);
    ma_hit_t *h = NULL;
    uint32_t i, len;
    for (i = 0; i < x->length; i++)
    {
        h = &(x->buffer[i]);
        len = Get_qe((*h)) - Get_qs((*h));
        if(h->el == 1)
        {
            (*exactLen) += len;
        }
        else
        {
            (*inexactLen) += len;
        }
    }
}

// Assembly:
xorl %r8d, %r8d
movl %r8d, (%rcx)
movl %r8d, (%rdx)
movl %edi, %eax
leaq (%rax,%rax,2), %rax
cmpl %r8d, 0xc(%rsi,%rax,8)
je 0xb3482
leaq (%rsi,%rax,8), %rax
movq (%rax), %rsi
xorl %edi, %edi
movl 0x8(%rsi), %r8d
subl (%rsi), %r8d
cmpb $0x1, 0x20(%rsi)
movq %rcx, %r9
cmoveq %rdx, %r9
addl %r8d, (%r9)
incq %rdi
movl 0xc(%rax), %r8d
addq $0x28, %rsi
cmpq %r8, %rdi
jb 0xb345d
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_edge_from_source(ma_hit_t_alloc*, ma_sub_t*, R_to_U*, int, int, unsigned int, unsigned int, asg_arc_t*)
uint32_t get_edge_from_source(ma_hit_t_alloc* sources, ma_sub_t *coverage_cut, 
R_to_U* ruIndex, int max_hang, int min_ovlp, uint32_t query, uint32_t target, asg_arc_t* t)
{
    uint32_t qn = query>>1, i;
    int32_t r;
    ma_hit_t *h = NULL;
    ma_sub_t *sq = NULL;
    ma_sub_t *st = NULL;
    ma_hit_t_alloc* x = &(sources[qn]);
    for (i = 0; i < x->length; i++)
    {
        h = &(x->buffer[i]);
        sq = &(coverage_cut[Get_qn(*h)]);
        st = &(coverage_cut[Get_tn(*h)]);
    
        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, skip
        if(r < 0) continue;

        if((t->ul>>32) != query) continue;
        if(t->v != target) continue;
        
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movl %r9d, %eax
shrl %eax
leaq (%rax,%rax,2), %rax
cmpl $0x0, 0xc(%rdi,%rax,8)
je 0xb3eb9
movq %rsi, %r14
movq 0x58(%rsp), %r15
leaq (%rdi,%rax,8), %r13
movl %r9d, %eax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movq (%r13), %rax
leaq (%rax,%r12), %rdi
movl 0x4(%rax,%r12), %ecx
movl 0xc(%rax,%r12), %eax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rax,2), %rax
movl 0x4(%r14,%rcx,4), %esi
movl (%r14,%rcx,4), %ecx
andl %ebx, %ecx
subl %ecx, %esi
movl 0x4(%r14,%rax,4), %edx
movl (%r14,%rax,4), %eax
andl %ebx, %eax
subl %eax, %edx
leaq 0x1e18e1(%rip), %rax    # 0x295758
movss 0x158(%rax), %xmm0
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %r8d
movq %r15, %r9
callq 0xa1d8c
testl %eax, %eax
js 0xb3ea9
movq 0x10(%rsp), %rax
cmpl %eax, 0x4(%r15)
jne 0xb3ea9
movl 0x50(%rsp), %eax
cmpl %eax, 0x8(%r15)
je 0xb3eca
incq %rbp
movl 0xc(%r13), %eax
addq $0x28, %r12
cmpq %rax, %rbp
jb 0xb3e3c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0xb3ebb
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: detect_exact_ovec(ma_utg_t*, asg_t*, ma_hit_t_alloc*, ma_sub_t*, kvec_asg_arc_t_warp*, int, int, unsigned int, unsigned int)
uint32_t detect_exact_ovec(ma_utg_t* collection, asg_t* read_g, ma_hit_t_alloc* sources, 
ma_sub_t *coverage_cut, kvec_asg_arc_t_warp* edge, int max_hang, int min_ovlp,
uint32_t src, uint32_t dest_idx)
{
    asg_arc_t *t = NULL, i_t;
    uint32_t i, k, dest;
    for (i = dest_idx; i < collection->n; i++)
    {
        t = NULL;
        dest = (uint64_t)(collection->a[i])>>32;
        if(get_edge_from_source(sources, coverage_cut, NULL, max_hang, min_ovlp, src, dest, &i_t) == 0)
        {
            for (k = 0; k < edge->a.n; k++)
            {
                if(edge->a.a[k].del) continue;
                if((edge->a.a[k].ul>>32) == src && edge->a.a[k].v == dest)
                {
                    t = &(edge->a.a[k]);
                    break;
                }
            }
        }
        else
        {
            t = &i_t;
        }

        if(t == NULL) return (uint32_t)-1;
        if(t->el != 1) continue;
        return i;
    }

    return (uint32_t)-1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0xc(%rsp)
movq %rcx, 0x18(%rsp)
movl 0x80(%rsp), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, 0x10(%rdi)
jbe 0xb4a7a
movq %rdx, %r12
movq %rdi, %r13
movq %r8, 0x10(%rsp)
movl 0x78(%rsp), %r14d
movl %ecx, %ebx
movq 0x18(%r13), %rax
movl 0x4(%rax,%rbx,8), %ebp
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %ecx
movl 0x70(%rsp), %r8d
movl 0x78(%rsp), %r9d
leaq 0x20(%rsp), %r15
pushq %r15
pushq %rbp
callq 0xb3df3
addq $0x10, %rsp
testl %eax, %eax
je 0xb4a39
cmpb $0x1, 0x12(%r15)
je 0xb4a89
incq %rbx
movl 0x10(%r13), %eax
cmpq %rax, %rbx
jb 0xb49f1
jmp 0xb4a75
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0xb4a75
movq 0x10(%rcx), %rcx
movl $0x1, %edx
xorl %esi, %esi
leaq (%rsi,%rsi,2), %rsi
cmpl $0x0, 0xc(%rcx,%rsi,8)
js 0xb4a6c
leaq (%rcx,%rsi,8), %r15
cmpl %r14d, 0x4(%r15)
jne 0xb4a6c
cmpl %ebp, 0x8(%r15)
je 0xb4a24
movl %edx, %esi
incl %edx
cmpq %rsi, %rax
ja 0xb4a51
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %eax
jmp 0xb4a7a
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_specific_edge(ma_hit_t_alloc*, ma_sub_t*, R_to_U*, kvec_asg_arc_t_warp*, asg_t*, int, int, unsigned int, unsigned int, asg_arc_t*)
void get_specific_edge(ma_hit_t_alloc* sources, ma_sub_t *coverage_cut, 
R_to_U* ruIndex, kvec_asg_arc_t_warp* edge, asg_t* read_g, int max_hang, 
int min_ovlp, uint32_t query, uint32_t target, asg_arc_t* t)
{
    uint32_t nv, k;
    (*t).ul = (uint64_t)-1; (*t).v = (uint32_t)-1;
    if(read_g)
    {
        asg_arc_t* av = asg_arc_a(read_g, query);
        nv = asg_arc_n(read_g, query);
        for (k = 0; k < nv; k++)
        {
            if(av[k].del) continue;
            if(av[k].v == target) 
            {
                (*t) = av[k];
                break;
            }
        }
    }

    if((*t).ul == (uint64_t)-1)
    {
        if(get_edge_from_source(sources, coverage_cut, NULL, max_hang, min_ovlp, query, target, t)==0)
        {
            (*t).ul = (uint64_t)-1;
        }
    }
    
    if((*t).ul == (uint64_t)-1)
    {
        for (k = 0; k < edge->a.n; k++)
        {
            if(edge->a.a[k].del) continue;
            if((edge->a.a[k].ul>>32) == query && edge->a.a[k].v == target)
            {
                (*t) = edge->a.a[k];
                break;
            }
        }
        if(k == edge->a.n) fprintf(stderr, "ERROR\n");
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x48(%rsp), %r14
movl 0x40(%rsp), %r15d
movl 0x38(%rsp), %eax
movq $-0x1, (%r14)
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
movl %eax, %r12d
testq %r8, %r8
je 0xb4b05
movq 0x28(%r8), %rcx
movq (%rcx,%r12,8), %rdx
testl %edx, %edx
je 0xb4b05
movq 0x8(%r8), %rcx
movq %rdx, %r8
shrq $0x20, %r8
movl %edx, %r11d
leaq (%r8,%r8,2), %rdx
leaq (%rcx,%rdx,8), %r10
addq $0xc, %r10
shlq $0x3, %r11
leaq (%r11,%r11,2), %r11
xorl %r8d, %r8d
cmpl $0x0, (%r10,%r8)
js 0xb4afc
cmpl %r15d, -0x4(%r10,%r8)
je 0xb4b69
addq $0x18, %r8
cmpq %r8, %r11
jne 0xb4aee
movl 0x30(%rsp), %r8d
movl %r9d, %ecx
movl %eax, %r9d
pushq %r14
pushq %r15
callq 0xb3df3
addq $0x10, %rsp
testl %eax, %eax
je 0xb4b29
cmpq $-0x1, (%r14)
jne 0xb4ba1
jmp 0xb4b30
movq $-0x1, (%r14)
movq (%rbx), %rax
testq %rax, %rax
je 0xb4bad
movq 0x10(%rbx), %rdx
movl $0x1, %esi
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdi
cmpl $0x0, 0xc(%rdx,%rdi,8)
js 0xb4b5e
leaq (%rdx,%rdi,8), %rdi
cmpl %r12d, 0x4(%rdi)
jne 0xb4b5e
cmpl %r15d, 0x8(%rdi)
je 0xb4b8a
movl %esi, %ecx
incl %esi
cmpq %rcx, %rax
ja 0xb4b43
jmp 0xb4b9c
leaq (%rcx,%rdx,8), %rcx
movups (%r8,%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x10(%r8,%rcx), %rcx
movq %rcx, 0x10(%r14)
cmpq $-0x1, (%r14)
jne 0xb4ba1
jmp 0xb4b05
movq 0x10(%rdi), %rax
movq %rax, 0x10(%r14)
movups (%rdi), %xmm0
movups %xmm0, (%r14)
movq (%rbx), %rax
cmpq %rcx, %rax
je 0xb4bad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x101e1
jmp 0xb4ba1
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: cal_circle_ov(ma_ug_t const*, unsigned int, unsigned int, asg_t*)
uint32_t cal_circle_ov(const ma_ug_t *ug, uint32_t uid, uint32_t rev, asg_t *sg)
{
    uint32_t v, w, vx, wx, k;
    v = w = (uid<<1)+(!!rev);
    vx = (v&1?((ug->u.a[v>>1].a[0]>>32)^1):(ug->u.a[v>>1].a[ug->u.a[v>>1].n-1]>>32));
    wx = (w&1?((ug->u.a[w>>1].a[ug->u.a[w>>1].n-1]>>32)^1):(ug->u.a[w>>1].a[0]>>32));
    v = vx; w = wx;

    if(sg) {
        asg_arc_t *av; uint32_t nv;
        av = asg_arc_a(sg, vx); nv = asg_arc_n(sg, vx);
        for (k = 0; k < nv; k++) {
            if(av[k].v == wx) return av[k].ol;
        }
    }
    return 0;
}

// Assembly:
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq 0x10(%rdi), %rax
testl %edx, %edx
je 0xb77b7
leaq (%rsi,%rsi,4), %rdx
movq 0x18(%rax,%rdx,8), %rdi
movl 0x4(%rdi), %esi
xorq $0x1, %rsi
movl 0x10(%rax,%rdx,8), %eax
decl %eax
movl 0x4(%rdi,%rax,8), %edx
xorq $0x1, %rdx
jmp 0xb77cd
leaq (%rsi,%rsi,4), %rdx
movq 0x18(%rax,%rdx,8), %rdi
movl 0x10(%rax,%rdx,8), %eax
decl %eax
movl 0x4(%rdi,%rax,8), %esi
movl 0x4(%rdi), %edx
xorl %eax, %eax
testq %rcx, %rcx
je 0xb7822
movq 0x28(%rcx), %rdi
movq (%rdi,%rsi,8), %rsi
testl %esi, %esi
je 0xb7822
movq 0x8(%rcx), %rax
movq %rsi, %rcx
shrq $0x20, %rcx
movl %esi, %esi
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
addq $0xc, %rdi
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %r8
xorl %esi, %esi
cmpl %edx, -0x4(%rdi,%rsi)
je 0xb7815
addq $0x18, %rsi
cmpq %rsi, %r8
jne 0xb7803
xorl %eax, %eax
retq
leaq (%rax,%rcx,8), %rcx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl 0xc(%rsi,%rcx), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: reset_weak_ovlp(ma_hit_t_alloc*, unsigned int, unsigned int)
uint32_t reset_weak_ovlp(ma_hit_t_alloc *sc, uint32_t src, uint32_t dst)
{
    ma_hit_t_alloc *x = &(sc[src]); uint32_t k, tn; int32_t idx;
    for (k = 0; k < x->length; k++) {
        if((x->buffer[k].bl&((uint32_t)0x40000000))) continue;
        if((x->buffer[k].del)) continue;
        tn = Get_tn(x->buffer[k]);
        if((Get_ts(x->buffer[k]) == 0) && (Get_te(x->buffer[k]) == Get_READ_LENGTH(R_INF, tn))) {
            idx = get_specific_overlap(&(sc[tn]), tn, dst);
            if((idx >= 0) && (!(sc[tn].buffer[idx].del)) && (!(sc[tn].buffer[idx].bl&((uint32_t)0x40000000)))) {
                return 1;
            }
        }
    }
    return 0;
}

// Assembly:
movl %esi, %eax
leaq (%rax,%rax,2), %rcx
movl 0xc(%rdi,%rcx,8), %eax
testq %rax, %rax
je 0xb86ac
pushq %r15
pushq %r14
pushq %rbx
leaq (%rdi,%rcx,8), %rsi
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
movq (%rsi), %rsi
leaq 0x1ddc08(%rip), %r8     # 0x296230
movq 0x18(%r8), %r8
xorl %r9d, %r9d
leaq (%r9,%r9,4), %r10
cmpq %rcx, 0x18(%rsi,%r10,8)
jae 0xb869c
leaq (%rsi,%r10,8), %r11
cmpl $0x0, 0x10(%r11)
jne 0xb869c
movl 0xc(%r11), %r10d
movl 0x14(%r11), %r11d
cmpq %r11, (%r8,%r10,8)
jne 0xb869c
leaq (%r10,%r10,2), %r11
movl 0xc(%rdi,%r11,8), %r14d
testq %r14, %r14
je 0xb869c
leaq (%rdi,%r11,8), %r11
movq (%r11), %r11
movq %r11, %r15
xorl %ebx, %ebx
cmpl %edx, 0xc(%r15)
jne 0xb8679
cmpl 0x4(%r15), %r10d
je 0xb8687
incq %rbx
addq $0x28, %r15
cmpq %rbx, %r14
jne 0xb866d
jmp 0xb869c
testl %ebx, %ebx
js 0xb869c
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
leaq (%rbx,%rbx,4), %r10
cmpq %rcx, 0x18(%r11,%r10,8)
jb 0xb86af
incq %r9
cmpq %rax, %r9
jne 0xb862f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
movl $0x1, %eax
jmp 0xb86a6
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: push_cov_interval_direct(kvec_t_u64_warp*, long long, long long, long long, unsigned long)
uint32_t push_cov_interval_direct(kvec_t_u64_warp* a, long long x_beg, long long x_end, long long utg_len, uint64_t is_circle)
{
    if(x_beg <= x_end && x_beg >= 0 && x_end >= 0 && x_beg < utg_len && x_end < utg_len)
    {
        uint64_t key;
        key = x_beg; key <<= 1; key |= (!is_circle); key <<= 1; key|=1;
        kv_push(uint64_t, a->a, key);
        key = x_end + 1; key <<= 1; key |= (!is_circle); key <<= 1; 
        kv_push(uint64_t, a->a, key);
        return 1;
    }
    return 0;
}

// Assembly:
xorl %eax, %eax
cmpq %rcx, %rdx
jge 0xb9318
cmpq %rcx, %rsi
jge 0xb9318
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
cmpq %rdx, %rsi
jg 0xb930d
movq %r14, %rcx
orq %rsi, %rcx
js 0xb930d
movq %rdi, %rbx
xorl %r15d, %r15d
testq %r8, %r8
sete %r15b
shlq $0x2, %rsi
leaq (%rsi,%r15,2), %r12
incq %r12
movq (%rdi), %rcx
cmpq 0x8(%rdi), %rcx
jne 0xb92b3
leaq (%rcx,%rcx), %rax
testq %rcx, %rcx
movl $0x2, %esi
cmovneq %rax, %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x3, %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movq (%rbx), %rcx
jmp 0xb92b7
movq 0x10(%rbx), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movq %r12, (%rax,%rcx,8)
addl %r15d, %r15d
leaq (%r15,%r14,4), %r14
addq $0x4, %r14
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jne 0xb92fd
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
movl $0x2, %esi
cmovneq %rdx, %rsi
movq %rsi, 0x8(%rbx)
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x2370
movq %rax, 0x10(%rbx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movq %r14, (%rax,%rcx,8)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: push_cov_interval_advance(kvec_t_u64_warp*, long long, long long, long long, unsigned int)
uint32_t push_cov_interval_advance(kvec_t_u64_warp* a, long long x_beg, long long x_end, long long utg_len, uint32_t is_circle)
{
    if(x_beg > x_end) return 0;
    
    if(push_cov_interval_direct(a, x_beg, x_end, utg_len, 0)) return 1;
    

    if(x_beg < 0 && x_end < 0)
    {
        x_beg = utg_len + x_beg;
        x_end = utg_len + x_end;
        return push_cov_interval_direct(a, x_beg, x_end, utg_len, 0);
    }

    if(x_beg >= utg_len && x_end >= utg_len)
    {
        x_beg = x_beg - utg_len;
        x_end = x_end - utg_len;
        return push_cov_interval_direct(a, x_beg, x_end, utg_len, 0);
    }

    if(x_beg < 0 && x_end >= 0)
    {
        x_beg = utg_len + x_beg;
        if(push_cov_interval_direct(a, x_beg, utg_len - 1, utg_len, is_circle) || 
             push_cov_interval_direct(a, 0, x_end, utg_len, is_circle))
        {
            return 1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
cmpq %rdx, %rsi
jg 0xb934b
movl %r8d, %r13d
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %r8d, %r8d
callq 0xb9234
movl $0x1, %ebp
testl %eax, %eax
je 0xb935c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r12, %r14
js 0xb93b3
movq %r12, %rsi
subq %rbx, %rsi
jge 0xb93c1
testq %r12, %r12
setns %al
testq %r14, %r14
sets %cl
orb %al, %cl
jne 0xb93af
addq %rbx, %r12
leaq -0x1(%rbx), %rdx
movl %r13d, %r13d
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
movq %r13, %r8
callq 0xb9234
testl %eax, %eax
jne 0xb934b
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0xb9234
testl %eax, %eax
jne 0xb934b
xorl %ebp, %ebp
jmp 0xb934b
addq %rbx, %r12
addq %rbx, %r14
movq %r15, %rdi
movq %r12, %rsi
jmp 0xb93c7
subq %rbx, %r14
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb9234
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: debug_r_contig_pos(ma_utg_t*, unsigned int, All_reads*)
void debug_r_contig_pos(ma_utg_t *u, uint32_t tn, All_reads *RNF)
{
    uint32_t c_beg, c_end, l, k;
    for (k = l = 0; k < u->n; k++)
    {
        c_beg = l;
        c_end = c_beg + Get_READ_LENGTH((*RNF), (u->a[k]>>33));
        l += (uint32_t)u->a[k];
        if((u->a[k]>>33) == tn)
        {
            fprintf(stderr, "#####c_beg: %u, c_end: %u\n", c_beg, c_end);
            break;
        }
    }
}

// Assembly:
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0xb95c8
movq 0x18(%rdi), %rdi
movl %esi, %esi
xorl %r8d, %r8d
xorl %eax, %eax
movq (%rdi,%r8,8), %r9
movq %r9, %r10
shrq $0x21, %r10
cmpl %esi, %r10d
je 0xb95c9
addl %r9d, %eax
incq %r8
cmpq %r8, %rcx
jne 0xb95ad
retq
movq 0x18(%rdx), %rcx
movl (%rcx,%rsi,8), %ecx
addl %eax, %ecx
movq 0x1dba07(%rip), %rdx    # 0x294fe0
movq (%rdx), %rdi
leaq 0x17d201(%rip), %rsi    # 0x2367e4
movl %eax, %edx
xorl %eax, %eax
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_overlap_contig_dir(unsigned int, unsigned int, ma_hit_t*, All_reads*, long long, unsigned int, unsigned int)
uint32_t get_overlap_contig_dir(uint32_t v, uint32_t tn, ma_hit_t *h, All_reads *RNF, long long ctg_beg,
uint32_t p_beg, uint32_t p_end)
{
    long long qs, qe, ts, te, c_beg, c_end;

    qs = Get_qs((*h)); qe = Get_qe((*h)) - 1;
    ts = Get_ts((*h)); te = Get_te((*h)) - 1;
    if(h->rev)
    {
        ts = (long long)(Get_READ_LENGTH((*RNF), tn)) - ((long long)(Get_te((*h))) - 1) - 1;
        te = (long long)(Get_READ_LENGTH((*RNF), tn)) - (long long)(Get_ts((*h))) - 1;
    }
    ts = qs - ts;
    te = qe + ((long long)(Get_READ_LENGTH((*RNF), tn)) - te - 1);
    c_beg = ts; c_end = te;

    if(v&1)
    {
        ts = (long long)(Get_READ_LENGTH((*RNF), v>>1)) - ts - 1;
        te = (long long)(Get_READ_LENGTH((*RNF), v>>1)) - te - 1;
        c_beg = te; c_end = ts;
    }

    c_end++;
    c_beg += ctg_beg; c_end += ctg_beg;

    if((p_beg != p_end && c_beg <= p_beg && c_end >= p_end) || 
                    (p_beg == p_end && c_beg < p_beg && c_end > p_end))
    {
        return 2;
    }

    if(c_beg < p_beg) return 0;
    if(c_end > p_end) return 1;

    return 2;

}

// Assembly:
pushq %rbx
movl (%rdx), %r10d
movl 0x8(%rdx), %r11d
decl %r11d
movl 0x10(%rdx), %ebx
movl 0x14(%rdx), %eax
testb $-0x80, 0x1b(%rdx)
jne 0xb9611
decl %eax
movq 0x18(%rcx), %rdx
movl %esi, %ecx
movq (%rdx,%rcx,8), %rcx
jmp 0xb962d
movq 0x18(%rcx), %rdx
movl %esi, %ecx
movq (%rdx,%rcx,8), %rcx
movq %rcx, %rsi
subq %rax, %rsi
notq %rbx
movq %rbx, %rax
addq %rcx, %rax
movq %rsi, %rbx
addq %rcx, %r11
subq %rbx, %r10
movl 0x10(%rsp), %ecx
notq %rax
addq %r11, %rax
testb $0x1, %dil
je 0xb965e
shrl %edi
movq (%rdx,%rdi,8), %rdx
notq %r10
movq %r10, %rsi
addq %rdx, %rsi
notq %rax
addq %rdx, %rax
movq %rax, %r10
movq %rsi, %rax
addq %r8, %r10
leaq (%r8,%rax), %rsi
incq %rsi
movl %r9d, %edx
movl %ecx, %edi
movl $0x2, %eax
cmpl %ecx, %r9d
je 0xb9681
cmpq %rdx, %r10
jg 0xb9681
cmpq %rdi, %rsi
jge 0xb96a2
cmpl %ecx, %r9d
jne 0xb9690
cmpq %rdx, %r10
jge 0xb9690
cmpq %rdi, %rsi
jg 0xb96a2
xorl %ecx, %ecx
cmpq %rdi, %rsi
setle %cl
incl %ecx
xorl %eax, %eax
cmpq %rdx, %r10
cmovgel %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: push_sub_unitig(ma_ug_t*, ma_utg_t*, asg_t*, kvec_asg_arc_t_warp*, unsigned int, unsigned int)
void push_sub_unitig(ma_ug_t *n_ug, ma_utg_t *src_u, asg_t *read_g, kvec_asg_arc_t_warp* edge, 
uint32_t beg_idx, uint32_t occ)
{
    uint32_t i;
    uint64_t totalLen;
    ma_utg_t* p = NULL;
    kv_pushp(ma_utg_t, n_ug->u, &p);
    p->s = NULL;
    p->n = occ;
    p->circ = 0;
    if(beg_idx == 0 && occ == src_u->n) p->circ = src_u->circ;
    p->m = p->n;
    p->a = (uint64_t*)malloc(8 * p->m);
    for (i = 0; i < occ; i++) p->a[i] = src_u->a[beg_idx+i];
    fill_unitig(p->a, occ, read_g, edge, p->circ, &totalLen);
    p->len = totalLen;
    if(!p->circ)
    {
        p->start = p->a[0]>>32;
        p->end = (p->a[p->n-1]>>32)^1;
    }
    else
    {
        p->start = p->end = UINT32_MAX;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r14d
movl %r8d, %ebp
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rcx
cmpq 0x8(%rdi), %rcx
movq %rdx, 0x8(%rsp)
jne 0xbaf6c
leaq (%rcx,%rcx), %rax
testq %rcx, %rcx
movl $0x2, %ecx
cmovneq %rax, %rcx
movq %rcx, 0x8(%r13)
movq 0x10(%r13), %rdi
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rsi
callq 0x2370
movq %rax, 0x10(%r13)
movq (%r13), %rcx
jmp 0xbaf70
movq 0x10(%r13), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, (%r13)
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rbx
movq $0x0, 0x20(%rbx)
movl %r14d, 0x10(%rbx)
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
andl (%rbx), %r13d
movl %r13d, (%rbx)
testl %ebp, %ebp
jne 0xbafb2
cmpl %r14d, 0x10(%r12)
jne 0xbafb2
movl $0x80000000, %eax       # imm = 0x80000000
andl (%r12), %eax
orl %eax, %r13d
movl %r13d, (%rbx)
movl %r14d, 0xc(%rbx)
leal (,%r14,8), %edi
callq 0x2280
movq %rax, 0x18(%rbx)
testl %r14d, %r14d
je 0xbafec
movq 0x18(%r12), %rcx
movl %r14d, %edx
movl %ebp, %esi
xorl %edi, %edi
leal (%rsi,%rdi), %r8d
movq (%rcx,%r8,8), %r8
movq %r8, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0xbafd8
shrl $0x1f, %r13d
leaq 0x10(%rsp), %r12
movq %rax, %rdi
movl %r14d, %esi
movq 0x8(%rsp), %rdx
movq %r15, %rcx
movl %r13d, %r8d
movq %r12, %r9
callq 0x113fe2
movl (%rbx), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
andl (%r12), %ecx
movl %eax, %edx
andl $0x80000000, %edx       # imm = 0x80000000
orl %ecx, %edx
movl %edx, (%rbx)
testl %eax, %eax
js 0xbb03e
movq 0x18(%rbx), %rcx
movl 0x4(%rcx), %eax
movl 0x10(%rbx), %edx
decl %edx
movl 0x4(%rcx,%rdx,8), %ecx
xorl $0x1, %ecx
jmp 0xbb048
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: renew_utg(ma_ug_t**, asg_t*, kvec_asg_arc_t_warp*)
void renew_utg(ma_ug_t **ug, asg_t* read_g, kvec_asg_arc_t_warp* edge)
{
    ma_ug_t* high_level_ug = NULL;
    asg_t* nsg = (*ug)->g;
    uint32_t i;
    ma_utg_t *u;
    high_level_ug = ma_ug_gen(nsg);
    for (i = 0; i < high_level_ug->u.n; i++)
    {
        high_level_ug->g->seq[i].c = PRIMARY_LABLE;
        u = &(high_level_ug->u.a[i]);
        if(u->m == 0) continue;
        merge_unitig_content(u, (*ug), read_g, edge);
        high_level_ug->g->seq[i].len = u->len;
    }
    ma_ug_destroy((*ug));
    (*ug) = high_level_ug;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq (%rdi), %rax
movq 0x18(%rax), %rdi
callq 0xb10cd
movq %rax, 0x8(%rsp)
movq (%rax), %rbp
testq %rbp, %rbp
je 0xbb84b
movq 0x8(%rsp), %rax
movq 0x10(%rax), %r12
movq 0x18(%rax), %r14
movl $0x1, %r15d
xorl %ebx, %ebx
movq 0x20(%r14), %rax
movb $0x0, 0x4(%rax,%rbx,8)
leaq (%rbx,%rbx,4), %rax
cmpl $0x0, 0xc(%r12,%rax,8)
je 0xbb840
leaq (%r12,%rax,8), %r13
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq %r13, %rdi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0xcd6fd
movl (%r13), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
andl %ecx, %eax
movq 0x20(%r14), %rcx
movl (%rcx,%rbx,8), %edx
movl $0x80000000, %esi       # imm = 0x80000000
andl %esi, %edx
orl %eax, %edx
movl %edx, (%rcx,%rbx,8)
movl %r15d, %ebx
incl %r15d
cmpq %rbx, %rbp
ja 0xbb7ef
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
callq 0xa0761
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_num_trio_flag(ma_ug_t*, unsigned int, unsigned int)
uint32_t get_num_trio_flag(ma_ug_t *ug, uint32_t v, uint32_t flag)
{
    if(flag == (uint32_t)-1) return 0;
    ma_utg_t* u = NULL;
    asg_t* nsg = ug->g;
    uint32_t k, rId, flag_occ = 0;
    if (nsg->seq[v].del) return 0;
    u = &(ug->u.a[v]);
    if(u->m == 0) return 0;
    for (k = 0; k < u->n; k++)
    {
        rId = u->a[k]>>33;
        if(R_INF.trio_flag[rId] == flag) flag_occ++;
    }

    return flag_occ;
}

// Assembly:
xorl %eax, %eax
cmpl $-0x1, %edx
je 0xbc79a
movq 0x18(%rdi), %rcx
movq 0x20(%rcx), %r8
movl %esi, %ecx
cmpl $0x0, (%r8,%rcx,8)
js 0xbc79a
movq 0x10(%rdi), %rsi
leaq (%rcx,%rcx,4), %rcx
cmpl $0x0, 0xc(%rsi,%rcx,8)
je 0xbc79a
leaq (%rsi,%rcx,8), %rsi
movl 0x10(%rsi), %ecx
testq %rcx, %rcx
je 0xbc79a
movq 0x18(%rsi), %rsi
leaq 0x1d9ac1(%rip), %rax    # 0x296230
movq 0x28(%rax), %rdi
xorl %r8d, %r8d
xorl %eax, %eax
movq (%rsi,%r8,8), %r9
shrq $0x21, %r9
movzbl (%rdi,%r9), %r9d
xorl %r10d, %r10d
cmpl %edx, %r9d
sete %r10b
addl %r10d, %eax
incq %r8
cmpq %r8, %rcx
jne 0xbc778
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: set_r_het_flag(ma_ug_t*, asg_t*, ma_sub_t*, ma_hit_t_alloc*, R_to_U*, unsigned char*)
void set_r_het_flag(ma_ug_t *ug, asg_t *sg, ma_sub_t* coverage_cut, ma_hit_t_alloc* sources, R_to_U* ruIndex, uint8_t* is_r_het)
{
    uint64_t m, dip_thre_max, dip_thres;
    uint8_t* primary_flag = (uint8_t*)calloc(sg->n_seq, sizeof(uint8_t));

    if(asm_opt.hom_global_coverage_set)
    {
        dip_thre_max = asm_opt.hom_global_coverage;
    }
    else
    {
        dip_thre_max = ((double)asm_opt.hom_global_coverage)/((double)HOM_PEAK_RATE);
    }
    // dip_thre_max *= 0.75;
    dip_thre_max = (double)(dip_thre_max) - (((double)(dip_thre_max)*0.5)/asm_opt.polyploidy);

    // fprintf(stderr, "dip_thre_max: %lu\n", dip_thre_max);
            
    for (m = 0; m < ug->g->n_seq; m++)
    {
        dip_thres = dip_thre_max;
        ///if(ug->u.a[m].n <= dip_thre_max) dip_thres = dip_thre_max * 1.1;
        set_ug_coverage_aggressive(ug, m, sg, coverage_cut, sources, ruIndex, primary_flag, is_r_het, dip_thres);
    }
    free(primary_flag); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl 0x14(%rsi), %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movl $0x1, %esi
callq 0x2120
leaq 0x1d64e9(%rip), %rcx    # 0x295758
movslq 0x144(%rcx), %rsi
cvtsi2sd %esi, %xmm1
divsd 0x176ade(%rip), %xmm1   # 0x235d60
cvttsd2si %xmm1, %rdi
movsd 0x172079(%rip), %xmm0   # 0x231308
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %r8
movq %rdi, %rdx
sarq $0x3f, %rdx
andq %r8, %rdx
orq %rdi, %rdx
cmpl $0x0, 0x148(%rcx)
cmovneq %rsi, %rdx
movq %rax, %rbx
movq 0x18(%rbp), %rax
testl $0x7fffffff, 0x14(%rax) # imm = 0x7FFFFFFF
je 0xbf35d
movq %rdx, %xmm1
punpckldq 0x171faf(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x171fb7(%rip), %xmm1   # 0x231290
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
movsd 0x176a83(%rip), %xmm1   # 0x235d70
mulsd %xmm2, %xmm1
cvtsi2sdl 0x1bc(%rcx), %xmm3
divsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %r15
sarq $0x3f, %rcx
andq %rcx, %r15
orq %rax, %r15
xorl %r14d, %r14d
subq $0x8, %rsp
movq %rbp, %rdi
movl %r14d, %esi
movq %r13, %rdx
movq %r12, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
pushq %r15
pushq 0x20(%rsp)
pushq %rbx
callq 0xbee1b
addq $0x20, %rsp
incq %r14
movq 0x18(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r14
jb 0xbf31f
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: init_hc_links(hc_links*, unsigned long, trans_chain*)
void init_hc_links(hc_links* link, uint64_t ug_num, trans_chain* t_ch)
{
    kv_malloc(link->a, ug_num); link->a.n = ug_num;
    kv_malloc(link->enzymes, ug_num); link->enzymes.n = ug_num;
    uint64_t i;
    for (i = 0; i < link->a.n; i++)
    {
        kv_init(link->a.a[i].e);
        kv_init(link->a.a[i].f);
    }

    if(t_ch)
    {
        kv_u_trans_t *ta = &(t_ch->k_trans);
        uint64_t d = RC_1;
        for (i = 0; i < ta->n; i++)
        {
            if(ta->a[i].f == RC_2) continue;
            push_hc_edge(&(link->a.a[ta->a[i].qn]), ta->a[i].tn, 1, 1, &d);
            push_hc_edge(&(link->a.a[ta->a[i].tn]), ta->a[i].qn, 1, 1, &d);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, 0x8(%rdi)
movq %rsi, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r15
movq %r15, %rdi
callq 0x2280
movq %rax, %r12
movq %rax, 0x10(%r14)
movq %r13, (%r14)
movq %r13, 0x20(%r14)
leaq (,%r13,8), %rdi
callq 0x2280
movq %rax, 0x28(%r14)
movq %r13, 0x18(%r14)
testq %r13, %r13
je 0xbf771
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20e0
testq %rbx, %rbx
je 0xbf827
movq $0x1, 0x8(%rsp)
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0xbf827
movl $0x14, %r12d
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
movq 0x148(%rbx), %rcx
movb 0x14(%rcx,%r12), %dl
andb $0x3f, %dl
cmpb $0x2, %dl
je 0xbf817
movl -0xc(%rcx,%r12), %eax
movl (%rcx,%r12), %esi
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq 0x10(%r14), %rdi
movsd 0x171b3e(%rip), %xmm0   # 0x231310
movl $0x1, %edx
movq %r15, %rcx
callq 0x1416e0
movq 0x148(%rbx), %rax
movl -0xc(%rax,%r12), %esi
movl (%rax,%r12), %eax
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq 0x10(%r14), %rdi
movsd 0x171b0d(%rip), %xmm0   # 0x231310
movl $0x1, %edx
movq %r15, %rcx
callq 0x1416e0
movq 0x138(%rbx), %rax
incq %r13
addq $0x30, %r12
cmpq %rax, %r13
jb 0xbf7a1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq