LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: transfor_icoord(long, long, long, long, unsigned char, long, long, int*, int*, int*, int*)
void transfor_icoord(const int64_t iqs, const int64_t iqe, const int64_t irs, const int64_t ire, const uint8_t rev, 
const int64_t qlen, const int64_t rlen, int32_t *r_qs, int32_t *r_qe, int32_t *r_rs, int32_t *r_re)
{
    int64_t qs, qe, rs, re, qtail, rtail;
    qs = iqs; qe = iqe - 1; rs = irs; re = ire - 1;
    if(rev) {
        rs = rlen - ire; re = rlen - irs - 1;
    }
    
    if(qs <= rs) {
        rs -= qs; qs = 0;
    } else {
        qs -= rs; rs = 0;
    }

    qtail = qlen - qe - 1; rtail = rlen - re - 1;
    if(qtail <= rtail) {
        qe = qlen - 1; re += qtail;
    }
    else
    {
        re = rlen - 1; qe += rtail; 
    }

	if(r_qs) (*r_qs) = qs; if(r_qe) (*r_qe) = qe + 1;
	if(r_rs) (*r_rs) = rs; if(r_re) (*r_re) = re + 1;
    if(rev) {
        if(r_rs) (*r_rs) = rlen - re - 1; 
		if(r_re) (*r_re) = rlen - rs;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x28(%rsp), %rax
movq %rax, %r10
subq %rcx, %r10
decq %rcx
movq %rdx, %r14
notq %r14
addq %rax, %r14
testl %r8d, %r8d
cmoveq %rdx, %r10
cmoveq %rcx, %r14
xorl %ebx, %ebx
movq %r10, %rdx
subq %rdi, %rdx
movl $0x0, %ecx
cmovgeq %rdx, %rcx
movq 0x38(%rsp), %r11
movq %r9, %r15
subq %rsi, %r15
movq %r14, %r12
notq %r12
addq %rax, %r12
addq %r15, %r14
leaq -0x1(%rax), %rdx
addq %r12, %rsi
cmpq %r12, %r15
cmovleq %r14, %rdx
movq 0x30(%rsp), %r14
cmovleq %r9, %rsi
testq %r14, %r14
je 0x15d097
movl %edi, %r9d
subl %r10d, %r9d
cmpq %rdi, %r10
cmovll %r9d, %ebx
movl %ebx, (%r14)
movq 0x40(%rsp), %rdi
testq %r11, %r11
je 0x15d0a4
movl %esi, (%r11)
movq 0x48(%rsp), %rsi
testq %rdi, %rdi
je 0x15d0b0
movl %ecx, (%rdi)
testq %rsi, %rsi
je 0x15d0bc
leal 0x1(%rdx), %r9d
movl %r9d, (%rsi)
testb %r8b, %r8b
je 0x15d0d5
testq %rdi, %rdi
je 0x15d0cc
notl %edx
addl %eax, %edx
movl %edx, (%rdi)
testq %rsi, %rsi
je 0x15d0d5
subl %ecx, %eax
movl %eax, (%rsi)
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: transfor_coord(mg_lchain_t*, long, long, int*, int*, int*, int*)
void transfor_coord(mg_lchain_t *ri, const int64_t qlen, const int64_t rlen, 
int32_t *r_qs, int32_t *r_qe, int32_t *r_rs, int32_t *r_re)
{
    int64_t qs, qe, rs, re, qtail, rtail;
    qs = ri->qs; qe = ri->qe - 1; rs = ri->rs; re = ri->re - 1;
    if(ri->v&1) {
        rs = rlen - ri->re; re = rlen - ri->rs - 1;
    }
    
    if(qs <= rs) {
        rs -= qs; qs = 0;
    } else {
        qs -= rs; rs = 0;
    }

    qtail = qlen - qe - 1; rtail = rlen - re - 1;
    if(qtail <= rtail) {
        qe = qlen - 1; re += qtail;
    }
    else
    {
        re = rlen - 1; qe += rtail; 
    }

	if(r_qs) (*r_qs) = qs; if(r_qe) (*r_qe) = qe + 1;
	if(r_rs) (*r_rs) = rs; if(r_re) (*r_re) = re + 1;
    if(ri->v&1) {
        if(r_rs) (*r_rs) = rlen - re - 1; 
		if(r_re) (*r_re) = rlen - rs;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0xc(%rdi), %rax
movslq 0x10(%rdi), %r10
movq %rdx, %r11
subq %r10, %r11
decq %r10
movq %rax, %r15
notq %r15
addq %rdx, %r15
testb $0x1, 0x8(%rdi)
cmoveq %rax, %r11
movslq 0x14(%rdi), %rbx
cmoveq %r10, %r15
movq %r15, %r12
notq %r12
addq %rdx, %r12
xorl %r14d, %r14d
movq %r11, %r10
subq %rbx, %r10
movl $0x0, %eax
cmovgeq %r10, %rax
movslq 0x18(%rdi), %r13
movq %rsi, %rbp
subq %r13, %rbp
addq %rbp, %r15
leaq -0x1(%rdx), %r10
cmpq %r12, %rbp
cmovleq %r15, %r10
leaq (%r13,%r12), %r15
cmovleq %rsi, %r15
testq %rcx, %rcx
je 0x15d161
movl %ebx, %esi
subl %r11d, %esi
cmpq %rbx, %r11
cmovll %esi, %r14d
movl %r14d, (%rcx)
testq %r8, %r8
je 0x15d169
movl %r15d, (%r8)
movq 0x38(%rsp), %rcx
testq %r9, %r9
je 0x15d176
movl %eax, (%r9)
testq %rcx, %rcx
je 0x15d181
leal 0x1(%r10), %esi
movl %esi, (%rcx)
testb $0x1, 0x8(%rdi)
je 0x15d19f
testq %r9, %r9
je 0x15d196
notl %r10d
leal (%rdx,%r10), %esi
movl %esi, (%r9)
testq %rcx, %rcx
je 0x15d19f
subl %eax, %edx
movl %edx, (%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: get_nn_ov(unsigned int, unsigned int, asg_t const*)
int64_t get_nn_ov(const uint32_t v, const uint32_t w, const asg_t *g)
{
	uint32_t i;
	uint32_t nv = asg_arc_n(g, v);
    asg_arc_t *av = asg_arc_a(g, v), *p = NULL;
	for (i = 0; i < nv; i++) {
		if(av[i].del) continue;
		if(av[i].v == w) {
			// o -= av[i].ol;
			p = &(av[i]);
			break;
		}
	}
	return p?p->ol:0;
}

// Assembly:
movq 0x8(%rdx), %rax
movq 0x28(%rdx), %rcx
movl %edi, %edx
movq (%rcx,%rdx,8), %rcx
movl %ecx, %edx
movq %rcx, %rdi
shrq $0x20, %rdi
imulq $0x18, %rdx, %rcx
imulq $0x18, %rdi, %rdx
addq %rax, %rdx
addq $0xc, %rdx
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x15d1ec
movslq (%rdx,%rdi), %rax
testq %rax, %rax
js 0x15d1e6
cmpl %esi, -0x4(%rdx,%rdi)
je 0x15d1ee
addq $0x18, %rdi
jmp 0x15d1d2
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: get_lchain_ovlp(mg_lchain_t*, mg_lchain_t*, asg_t const*, long, ma_ug_t const*)
int64_t get_lchain_ovlp(mg_lchain_t *lp, mg_lchain_t *la, const asg_t *g, const int64_t qlen, const ma_ug_t *ug)
{
	int64_t o = lp->qe - la->qs, oj;
	uint32_t v = la->v^1, w = lp->v^1, i;
	int32_t pqe, aqs;
	if(o <= 0) return 0;
	if(v == w) return o;
	transfor_coord(lp, qlen, ug->u.a[lp->v>>1].len, NULL, &pqe, NULL, NULL);
	transfor_coord(la, qlen, ug->u.a[la->v>>1].len, &aqs, NULL, NULL, NULL);
	uint32_t nv = asg_arc_n(g, v);
    asg_arc_t *av = asg_arc_a(g, v), *p = NULL;
	for (i = 0; i < nv; i++) {
		if(av[i].del) continue;
		if(av[i].v == w) {
			// o -= av[i].ol;
			p = &(av[i]);
			break;
		}
	}
	oj = o;
	if(p) oj = pqe - aqs - p->ol;
	if(o > oj) o = oj;
	if(o < 0) o = 0;
	return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq 0x18(%rdi), %rbx
movslq 0x14(%rsi), %rax
subq %rax, %rbx
testl %ebx, %ebx
jle 0x15d2ec
movq %rsi, %r12
movl 0x8(%rsi), %r14d
movl 0x8(%rdi), %r13d
cmpl %r13d, %r14d
je 0x15d311
movq %rcx, %r15
movq %r14, %rax
xorq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x10(%r8), %rcx
movq %rcx, 0x10(%rsp)
movl %r13d, %eax
shrl %eax
imulq $0x28, %rax, %rax
movq %rdx, 0x18(%rsp)
movl (%rcx,%rax), %edx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rdx
andq $0x0, (%rsp)
xorl %ebp, %ebp
leaq 0xc(%rsp), %r8
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x15d0dd
shrl %r14d
imulq $0x28, %r14, %rax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax), %edx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rdx
andq $0x0, (%rsp)
leaq 0x8(%rsp), %rcx
movq %r12, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x15d0dd
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %eax, %edx
movq %rax, %rsi
shrq $0x20, %rsi
imulq $0x18, %rdx, %rax
imulq $0x18, %rsi, %rdx
addq %rdx, %rcx
addq $0xc, %rcx
cmpq %rbp, %rax
je 0x15d2f0
movl (%rcx,%rbp), %edx
testl %edx, %edx
js 0x15d2e6
movl -0x4(%rcx,%rbp), %esi
xorl %r13d, %esi
cmpl $0x1, %esi
je 0x15d2f5
addq $0x18, %rbp
jmp 0x15d2ce
xorl %ebx, %ebx
jmp 0x15d311
movq %rbx, %rax
jmp 0x15d301
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %edx
subl %edx, %eax
cltq
cmpq %rbx, %rax
cmovlq %rax, %rbx
xorl %eax, %eax
testq %rbx, %rbx
cmovleq %rax, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: get_lchain_gap(mg_lchain_t*, mg_lchain_t*, asg_t const*, long, ma_ug_t const*, int)
int64_t get_lchain_gap(mg_lchain_t *lp, mg_lchain_t *la, const asg_t *g, const int64_t qlen, const ma_ug_t *ug, int32_t double_ol)
{
	int64_t gg = la->qs - lp->qe, ggj;
	uint32_t v = la->v^1, w = lp->v^1, i;
	int32_t aqs, pqe;
	if(double_ol == 0 && gg >= 0) return gg;
	if(v == w) return gg;
	transfor_coord(la, qlen, ug->u.a[la->v>>1].len, &aqs, NULL, NULL, NULL);
	transfor_coord(lp, qlen, ug->u.a[lp->v>>1].len, NULL, &pqe, NULL, NULL);
	uint32_t nv = asg_arc_n(g, v);
    asg_arc_t *av = asg_arc_a(g, v), *p = NULL;;
	for (i = 0; i < nv; i++) {
		if(av[i].del) continue;
		if(av[i].v == w) {
			// gg += av[i].ol;
			p = &(av[i]);
			break;
		}
	}
	ggj = gg;
	if(p) ggj = aqs - pqe + p->ol + (double_ol?p->ol:0);
	// if(gg < ggj) gg = ggj;
	// return gg;
	return ggj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r11
movq %rdx, %r14
movq %rdi, %r12
movl 0x8(%rsi), %eax
movl 0x14(%rsi), %ebp
subl 0x18(%rdi), %ebp
movl 0x8(%rdi), %ecx
testl %r9d, %r9d
sete %dl
testl %ebp, %ebp
setns %dil
andb %dl, %dil
cmpl %ecx, %eax
sete %dl
orb %dil, %dl
jne 0x15d43e
movl %r9d, 0xc(%rsp)
movl %eax, %eax
movl %ecx, %r13d
movl %eax, %ecx
xorl $0x1, %ecx
movq %rcx, 0x20(%rsp)
movq 0x10(%r8), %r15
shrl %eax
imulq $0x28, %rax, %rax
movl (%r15,%rax), %edx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rdx
andq $0x0, (%rsp)
xorl %ebx, %ebx
leaq 0x14(%rsp), %rcx
movq %rsi, %rdi
movq %r11, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
movq %r11, 0x18(%rsp)
callq 0x15d0dd
movl %r13d, %eax
shrl %eax
imulq $0x28, %rax, %rax
movl (%r15,%rax), %edx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rdx
andq $0x0, (%rsp)
leaq 0x10(%rsp), %r8
movq %r12, %rdi
movq 0x18(%rsp), %rsi
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x15d0dd
movq 0x8(%r14), %rcx
movq 0x28(%r14), %rax
movq 0x20(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %eax, %edx
movq %rax, %rsi
shrq $0x20, %rsi
imulq $0x18, %rdx, %rax
imulq $0x18, %rsi, %rdx
addq %rdx, %rcx
addq $0xc, %rcx
cmpq %rbx, %rax
je 0x15d43e
movl (%rcx,%rbx), %edx
testl %edx, %edx
js 0x15d421
movl -0x4(%rcx,%rbx), %esi
xorl %r13d, %esi
cmpl $0x1, %esi
je 0x15d427
addq $0x18, %rbx
jmp 0x15d409
movl 0x14(%rsp), %eax
subl 0x10(%rsp), %eax
addl %edx, %eax
movl 0xc(%rsp), %ecx
testl %ecx, %ecx
cmovel %ecx, %edx
addl %eax, %edx
movl %edx, %ebp
movslq %ebp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: max_ovlp(asg_t const*, unsigned int)
int64_t max_ovlp(const asg_t *g, uint32_t v)
{
	uint32_t i, nv = asg_arc_n(g, v), o = 0;
	asg_arc_t *av = asg_arc_a(g, v);
	for (i = 0; i < nv; i++) {
		if(av[i].del) continue;
		if(o < av[i].ol) o = av[i].ol;
	}
	return o;
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x28(%rdi), %rax
movl %esi, %edx
movq (%rax,%rdx,8), %rax
movl %eax, %edx
movq %rax, %rsi
shrq $0x20, %rsi
imulq $0x18, %rdx, %rax
imulq $0x18, %rsi, %rdx
addq %rdx, %rcx
addq $0xc, %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rax
je 0x15d497
movl (%rcx,%rdx), %edi
cmpl %edi, %esi
movl %edi, %r8d
cmoval %esi, %r8d
testl %edi, %edi
cmovnsl %r8d, %esi
addq $0x18, %rdx
jmp 0x15d47a
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: max_ovlp_src(ug_opt_t const*, unsigned int)
int64_t max_ovlp_src(const ug_opt_t *uopt, uint32_t v)
{
	ma_hit_t_alloc* src = uopt->sources;
    int64_t min_ovlp = uopt->min_ovlp, max_hang = uopt->max_hang;
	uint32_t i, qn, tn, o = 0, x = v>>1; asg_arc_t e;

	for (i = 0; i < src[x].length; i++) {
        qn = Get_qn(src[x].buffer[i]); tn = Get_tn(src[x].buffer[i]);
        if(ma_hit2arc(&(src[x].buffer[i]), Get_READ_LENGTH(R_INF, qn), Get_READ_LENGTH(R_INF, tn), 
														max_hang, asm_opt.max_hang_rate, min_ovlp, &e) < 0) {
			continue;
		}
		if((e.ul>>32) != v) continue;
		if(o < e.ol) o = e.ol;
    }

	return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rax
movl 0x44(%rdi), %ecx
movl %ecx, 0x4(%rsp)
movl 0x40(%rdi), %ebp
movl %esi, %ecx
movq %rcx, 0x8(%rsp)
shrl %esi
imulq $0x18, %rsi, %rcx
leaq (%rax,%rcx), %r12
movl 0xc(%rax,%rcx), %eax
leaq 0xf6d5e(%rip), %rcx     # 0x254230
movq 0x18(%rcx), %r13
leaq 0xf627b(%rip), %rcx     # 0x253758
movss 0x158(%rcx), %xmm0
movss %xmm0, (%rsp)
imulq $0x28, %rax, %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpq %r15, %r14
je 0x15d54f
movq (%r12), %rax
leaq (%rax,%r15), %rdi
movl 0x4(%rax,%r15), %ecx
movl 0xc(%rax,%r15), %eax
movl (%r13,%rcx,8), %esi
movl (%r13,%rax,8), %edx
movl %ebp, %ecx
movss (%rsp), %xmm0
movl 0x4(%rsp), %r8d
leaq 0x10(%rsp), %r9
callq 0x15d560
testl %eax, %eax
js 0x15d549
movq 0x8(%rsp), %rax
cmpl %eax, 0x14(%rsp)
jne 0x15d549
movl 0x1c(%rsp), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
andl %ecx, %eax
cmpl %eax, %ebx
cmovbel %eax, %ebx
addq $0x28, %r15
jmp 0x15d4f3
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: specific_ovlp(ma_ug_t const*, ug_opt_t const*, unsigned int, unsigned int)
int64_t specific_ovlp(const ma_ug_t *ug, const ug_opt_t *uopt, const uint32_t v, const uint32_t w)
{
	if(ug->u.a[v>>1].circ || ug->u.a[w>>1].circ) return 0;
	uint32_t rv, rw, i; int32_t r;
	const ma_hit_t_alloc *x = NULL;
	asg_arc_t t; memset(&t, 0, sizeof(t));
	if(v&1) rv = ug->u.a[v>>1].start^1;
	else rv = ug->u.a[v>>1].end^1;
	if(w&1) rw = ug->u.a[v>>1].end;
	else rw = ug->u.a[v>>1].start;
	x = &(uopt->sources[rv>>1]);
	for (i = 0; i < x->length; i++) {
		if(Get_tn(x->buffer[i]) == (rw>>1)) {
			r = ma_hit2arc(&(x->buffer[i]), uopt->coverage_cut[rv>>1].e - uopt->coverage_cut[rv>>1].s, 
			uopt->coverage_cut[rw>>1].e - uopt->coverage_cut[rw>>1].s, uopt->max_hang, asm_opt.max_hang_rate, uopt->min_ovlp, &t);
			if(r < 0) return 0;
			if((t.ul>>32)!=rv || t.v!=rw) return 0;
			return t.ol;
		}
	}
	return 0;
}

// Assembly:
movq 0x10(%rdi), %rax
movl %edx, %edi
shrl %edi
imulq $0x28, %rdi, %rdi
cmpl $0x0, (%rax,%rdi)
js 0x15d7ed
movl %ecx, %r8d
shrl %r8d
imulq $0x28, %r8, %r8
cmpl $0x0, (%rax,%r8)
js 0x15d7ed
pushq %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
testb $0x1, %dl
leaq 0x4(%rax,%rdi), %r8
leaq 0x8(%rax,%rdi), %rax
movq %r8, %rdx
cmoveq %rax, %rdx
movl (%rdx), %edx
movq %rdx, %rbx
xorq $0x1, %rbx
testb $0x1, %cl
cmoveq %r8, %rax
movl (%rax), %ebp
movq 0x8(%rsi), %rax
shrl %edx
imulq $0x18, %rdx, %rcx
leaq (%rax,%rcx), %r8
movl 0xc(%rax,%rcx), %eax
movl %ebp, %ecx
shrl %ecx
imulq $0x28, %rax, %r10
pushq $-0x28
popq %r11
xorl %eax, %eax
leaq 0x28(%r11), %r9
cmpq %r9, %r10
je 0x15d7f2
movq (%r8), %rdi
cmpl %ecx, 0x34(%rdi,%r11)
movq %r9, %r11
jne 0x15d76b
movq (%rsi), %r8
imulq $0xc, %rdx, %rdx
movl 0x4(%r8,%rdx), %eax
movl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
movl (%r8,%rdx), %edx
andl %r10d, %edx
subl %edx, %eax
imulq $0xc, %rcx, %rcx
movl 0x4(%r8,%rcx), %edx
andl (%r8,%rcx), %r10d
subl %r10d, %edx
movl 0x40(%rsi), %ecx
leaq 0xf5fa2(%rip), %r8      # 0x253758
movss 0x158(%r8), %xmm0
movl 0x44(%rsi), %r8d
addq %r9, %rdi
movq %rsp, %r9
movl %eax, %esi
callq 0x15d560
testl %eax, %eax
js 0x15d7f0
xorl %eax, %eax
cmpl %ebx, 0x4(%rsp)
jne 0x15d7f2
cmpl %ebp, 0x8(%rsp)
jne 0x15d7f2
movl 0xc(%rsp), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x15d7f2
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: compress_lchain(mg_lchain_t*, int, int, ma_ug_t const*, mg128_t const*)
void compress_lchain(mg_lchain_t *lc, int32_t n_lc, int32_t qlen, const ma_ug_t *ug, const mg128_t *a)
{
	int32_t i, k, q_span;
	mg_lchain_t *ri = NULL;
	for (i = 0; i < n_lc; ++i) {
		ri = &lc[i];
		k = ri->off;
		ri->rs = (int32_t)a[k].x + 1 > q_span? (int32_t)a[k].x + 1 - q_span : 0; // for HPC k-mer
        ri->qs = (int32_t)a[k].y + 1 - (a[k].y>>32 & 0xff);
        ri->re = (int32_t)a[k + ri->cnt - 1].x + 1;
        ri->qe = (int32_t)a[k + ri->cnt - 1].y + 1;
	}
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
imulq $0x28, %rsi, %rcx
cmpq %rax, %rcx
je 0x15d8b5
movslq (%rdi,%rax), %rdx
andl $0x0, 0xc(%rdi,%rax)
movq %rdx, %rsi
shlq $0x4, %rsi
movq 0x8(%r8,%rsi), %rsi
movq %rsi, %r9
shrq $0x20, %r9
movzbl %r9b, %r9d
subl %r9d, %esi
incl %esi
movl %esi, 0x14(%rdi,%rax)
movl 0x4(%rdi,%rax), %esi
shlq $0x21, %rsi
sarq $0x21, %rsi
addq %rdx, %rsi
shlq $0x4, %rsi
movl -0x10(%r8,%rsi), %edx
incl %edx
movl %edx, 0x10(%rdi,%rax)
movl -0x8(%r8,%rsi), %edx
incl %edx
movl %edx, 0x18(%rdi,%rax)
addq $0x28, %rax
jmp 0x15d858
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: print_gchain(gc_frag_t*, long const*, mg_lchain_t*, long, ma_ug_t const*, int)
void print_gchain(gc_frag_t *a, const int64_t *p, mg_lchain_t *lc, const int64_t nlc, const ma_ug_t *ug, int32_t qlen)
{
	int64_t k, i;
	gc_frag_t *ai = NULL;
    mg_lchain_t *li = NULL;
	for (k = 0; k < nlc; k++) {
		fprintf(stderr, "\n");
		for (i = k; i >= 0; i = p[i]) {
			ai = &a[i]; li = &lc[ai->i];
			fprintf(stderr, "*\tXXXXXX\tutg%.6d%c\t%c\tqs:%u\tqe:%u\tql:%d\tts:%u\tte:%u\ttl:%u\n", 
					(li->v>>1)+1, "lc"[ug->u.a[li->v>>1].circ], "+-"[li->v&1], li->qs, li->qe, qlen, li->rs, li->re, ug->u.a[li->v>>1].len);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
movq %rcx, 0x8(%rsp)
xorl %ebx, %ebx
cmpq 0x8(%rsp), %rbx
je 0x15d9b7
movq 0xf56e5(%rip), %rax     # 0x252fe0
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x2270
movq %rbx, %r15
jmp 0x15d9a6
movslq 0x4(%rbp,%r15,8), %rax
imulq $0x28, %rax, %rax
movq 0xf56c2(%rip), %rcx     # 0x252fe0
movq (%rcx), %rdi
movl 0x8(%r12,%rax), %esi
movl 0xc(%r12,%rax), %r10d
movl %esi, %ecx
shrl %ecx
imulq $0x28, %rcx, %r8
movl %ecx, %edx
incl %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movl (%rcx,%r8), %r11d
movl %r11d, %ecx
shrl $0x1f, %ecx
leaq 0x88d3a(%rip), %r8      # 0x1e668b
movsbl (%rcx,%r8), %ecx
andl $0x1, %esi
leaq 0x868c3(%rip), %r8      # 0x1e4223
movsbl (%rsi,%r8), %r8d
movl 0x14(%r12,%rax), %r9d
movl 0x18(%r12,%rax), %r14d
movl 0x10(%r12,%rax), %r13d
andl $0x7fffffff, %r11d      # imm = 0x7FFFFFFF
subq $0x8, %rsp
leaq 0x94378(%rip), %rsi     # 0x1f1cfe
xorl %eax, %eax
pushq %r11
pushq %r13
pushq %r10
pushq 0x40(%rsp)
pushq %r14
callq 0x22b0
addq $0x30, %rsp
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %r15
testq %r15, %r15
jns 0x15d90e
incq %rbx
jmp 0x15d8e9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: cal_sc(mg_path_dst_t const*, mg_lchain_t const*, mg_lchain_t const*, mg128_t const*, gc_frag_t const*, int const*, int, int, float)
static inline int32_t cal_sc(const mg_path_dst_t *dj, const mg_lchain_t *li, const mg_lchain_t *lc, const mg128_t *an, const gc_frag_t *a, const int32_t *f,
							 int bw, int ref_bonus, float chn_pen_gap)
{
	const mg_lchain_t *lj;
	int32_t gap, sc;
	float lin_pen, log_pen;
	if (dj->n_path == 0) return INT32_MIN;
	gap = dj->dist - dj->target_dist;
	lj = &lc[a[dj->meta].i];
	if (gap < 0) gap = -gap;
	if (gap > bw) return INT32_MIN;
	if (lj->qe <= li->qs) sc = li->score;
	else sc = (int32_t)((double)(li->qe - lj->qe) / (li->qe - li->qs) * li->score + .499); // dealing with overlap on query
	//sc += dj->mlen; // TODO: is this line the right thing to do?
	if (dj->is_0) sc += ref_bonus;
	lin_pen = chn_pen_gap * (float)gap;
	log_pen = gap >= 2? mg_log2(gap) : 0.0f;
	sc -= (int32_t)(lin_pen + log_pen);
	sc += f[dj->meta];
	return sc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x14(%rdi), %ebp
movl $0x80000000, %eax       # imm = 0x80000000
testl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
je 0x15e68b
movq %r8, %rbx
movl 0x1c(%rdi), %r10d
subl 0x4(%rdi), %r10d
movl %r10d, %r8d
negl %r8d
cmovsl %r10d, %r8d
cmpl %r9d, %r8d
jg 0x15e68b
movapd %xmm0, %xmm2
movl 0x30(%rsp), %eax
movl 0xc(%rdi), %r14d
andl $0x3fffffff, %r14d      # imm = 0x3FFFFFFF
movslq 0x4(%rcx,%r14,8), %rcx
imulq $0x28, %rcx, %rcx
movl 0x18(%rdx,%rcx), %edx
movl 0x14(%rsi), %ecx
cmpl %ecx, %edx
jle 0x15e64a
movl 0x18(%rsi), %edi
movl %edi, %r9d
subl %edx, %r9d
cvtsi2sd %r9d, %xmm0
subl %ecx, %edi
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
cvtsi2sdl 0x1c(%rsi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x819cc(%rip), %xmm1    # 0x1e0010
cvttsd2si %xmm1, %ecx
jmp 0x15e64d
movl 0x1c(%rsi), %ecx
sarl $0x1f, %ebp
andl %eax, %ebp
cvtsi2ss %r8d, %xmm0
addl %ecx, %ebp
mulss %xmm0, %xmm2
xorpd %xmm1, %xmm1
cmpl $0x2, %r8d
jb 0x15e67b
movss %xmm2, 0xc(%rsp)
callq 0x1a1d6e
movss 0xc(%rsp), %xmm2
movaps %xmm0, %xmm1
addss %xmm1, %xmm2
cvttss2si %xmm2, %eax
addl (%rbx,%r14,4), %ebp
subl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: mg_gchain_restore_order(void*, mg_gchains_t*)
void mg_gchain_restore_order(void *km, mg_gchains_t *gcs)
{
	int32_t i, n_a, n_lc;
	mg_llchain_t *lc;
	mg128_t *a;
	KMALLOC(km, lc, gcs->n_lc);
	KMALLOC(km, a, gcs->n_a);
	n_a = n_lc = 0;
	for (i = 0; i < gcs->n_gc; ++i) {
		mg_gchain_t *gc = &gcs->gc[i];
		assert(gc->cnt > 0);
		memcpy(&lc[n_lc], &gcs->lc[gc->off], gc->cnt * sizeof(mg_llchain_t));
		memcpy(&a[n_a], &gcs->a[gcs->lc[gc->off].off], gc->n_anchor * sizeof(mg128_t));
		n_lc += gc->cnt, n_a += gc->n_anchor;
	}
	memcpy(gcs->lc, lc, gcs->n_lc * sizeof(mg_llchain_t));
	memcpy(gcs->a, a, gcs->n_a * sizeof(mg128_t));
	kfree(km, lc); kfree(km, a);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movslq 0xc(%rsi), %rsi
shlq $0x4, %rsi
callq 0x1a39c4
movq %rax, 0x8(%rsp)
movslq 0x10(%r15), %rsi
shlq $0x4, %rsi
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0x1a39c4
movq %rax, (%rsp)
xorl %r13d, %r13d
pushq $0x10
popq %rbp
xorl %ebx, %ebx
xorl %r14d, %r14d
movslq 0x8(%r15), %rax
cmpq %rax, %r13
jge 0x15eb4b
movq 0x18(%r15), %r12
movslq -0x4(%r12,%rbp), %rdx
testq %rdx, %rdx
jle 0x15eba5
movslq %ebx, %rbx
movq %rbx, %rdi
shlq $0x4, %rdi
addq 0x8(%rsp), %rdi
movslq -0x8(%r12,%rbp), %rsi
shlq $0x4, %rsi
addq 0x20(%r15), %rsi
shlq $0x4, %rdx
callq 0x2160
movslq %r14d, %r14
movq %r14, %rdi
shlq $0x4, %rdi
addq (%rsp), %rdi
movq 0x20(%r15), %rax
movslq -0x8(%r12,%rbp), %rcx
shlq $0x4, %rcx
movslq (%rax,%rcx), %rsi
shlq $0x4, %rsi
addq 0x28(%r15), %rsi
movslq (%r12,%rbp), %rdx
shlq $0x4, %rdx
callq 0x2160
addl -0x4(%r12,%rbp), %ebx
addl (%r12,%rbp), %r14d
incq %r13
addq $0x48, %rbp
jmp 0x15eabe
movq 0x20(%r15), %rdi
movslq 0xc(%r15), %rdx
shlq $0x4, %rdx
movq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2160
movq 0x28(%r15), %rdi
movslq 0x10(%r15), %rdx
shlq $0x4, %rdx
movq (%rsp), %r15
movq %r15, %rsi
callq 0x2160
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a38cf
movq %rbx, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a38cf
leaq 0x93315(%rip), %rdi     # 0x1f1ec1
leaq 0x92f70(%rip), %rsi     # 0x1f1b23
leaq 0x93313(%rip), %rcx     # 0x1f1ecd
movl $0x782, %edx            # imm = 0x782
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: mg_gchain_sort_by_score(void*, mg_gchains_t*)
void mg_gchain_sort_by_score(void *km, mg_gchains_t *gcs)
{
	mg128_t *z;
	mg_gchain_t *gc;
	int32_t i;
	KMALLOC(km, z, gcs->n_gc);
	KMALLOC(km, gc, gcs->n_gc);
	for (i = 0; i < gcs->n_gc; ++i)
		z[i].x = (uint64_t)gcs->gc[i].score << 32 | gcs->gc[i].hash, z[i].y = i;
	radix_sort_128x(z, z + gcs->n_gc);
	for (i = gcs->n_gc - 1; i >= 0; --i)
		gc[gcs->n_gc - 1 - i] = gcs->gc[z[i].y];
	memcpy(gcs->gc, gc, gcs->n_gc * sizeof(mg_gchain_t));
	kfree(km, z); kfree(km, gc);
	mg_gchain_restore_order(km, gcs); // this put gcs in the proper order
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rsi
shlq $0x4, %rsi
callq 0x1a39c4
movq %rax, %r15
movslq 0x8(%rbx), %rax
imulq $0x48, %rax, %rsi
movq %r14, %rdi
callq 0x1a39c4
movq %rax, %r12
movslq 0x8(%rbx), %rsi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
leaq 0x8(%r15), %rdx
pushq $0x38
popq %rdi
cmpq %rax, %rcx
je 0x15ec39
movq 0x18(%rbx), %r8
movl -0x24(%r8,%rdi), %r9d
movl (%r8,%rdi), %r8d
shlq $0x20, %r9
orq %r9, %r8
movq %r8, -0x8(%rdx)
movq %rax, (%rdx)
incq %rax
addq $0x10, %rdx
addq $0x48, %rdi
jmp 0x15ec0c
shlq $0x4, %rsi
addq %r15, %rsi
movq %r15, %rdi
callq 0x158af1
movl 0x8(%rbx), %edx
movl %edx, %r8d
negl %r8d
movq %rdx, %rax
shlq $0x4, %rax
leaq (%rax,%r15), %r9
addq $-0x8, %r9
pushq $0x12
popq %rax
testl %edx, %edx
jle 0x15ec8f
imulq $0x48, (%r9), %rsi
addq 0x18(%rbx), %rsi
movl 0x8(%rbx), %ecx
addl %r8d, %ecx
movslq %ecx, %rcx
imulq $0x48, %rcx, %rdi
addq %r12, %rdi
movq %rax, %rcx
rep  movsl (%rsi), %es:(%rdi)
incl %r8d
decl %edx
addq $-0x10, %r9
jmp 0x15ec63
movq 0x18(%rbx), %rdi
movslq 0x8(%rbx), %rax
imulq $0x48, %rax, %rdx
movq %r12, %rsi
callq 0x2160
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a38cf
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a38cf
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x15ea74
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: copy_lchain(mg_llchain_t*, mg_lchain_t const*, int*, mg128_t*, mg128_t const*)
static inline void copy_lchain(mg_llchain_t *q, const mg_lchain_t *p, int32_t *n_a, mg128_t *a_new, const mg128_t *a_old)
{
	q->cnt = p->cnt, q->v = p->v, q->score = p->score;
	memcpy(&a_new[*n_a], &a_old[p->off], q->cnt * sizeof(mg128_t));
	q->off = *n_a;
	(*n_a) += q->cnt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %edx
leal (%rdx,%rdx), %eax
sarl %eax
movl %eax, 0x4(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0x1c(%rsi), %eax
movl %eax, 0xc(%rdi)
movslq (%rbx), %rdi
shlq $0x4, %rdi
addq %rcx, %rdi
movslq (%rsi), %rsi
shlq $0x4, %rsi
addq %r8, %rsi
shlq $0x21, %rdx
sarq $0x21, %rdx
shlq $0x4, %rdx
callq 0x2160
movl (%rbx), %eax
movl %eax, (%r14)
addl 0x4(%r14), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: mg_gchain_flt_sub(float, int, int, int, mg_gchain_t*)
int mg_gchain_flt_sub(float pri_ratio, int min_diff, int best_n, int n, mg_gchain_t *r)
{
	if (pri_ratio > 0.0f && n > 0) {
		int i, k, n_2nd = 0;
		for (i = k = 0; i < n; ++i) {
			int p = r[i].parent;
			if (p == i) { // primary
				r[i].flt = 0, ++k;
			} else if ((r[i].score >= r[p].score * pri_ratio || r[i].score + min_diff >= r[p].score) && n_2nd < best_n) {
				if (!(r[i].qs == r[p].qs && r[i].qe == r[p].qe && r[i].ps == r[p].ps && r[i].pe == r[p].pe)) // not identical hits; TODO: check path as well
					r[i].flt = 0, ++n_2nd, ++k;
				else r[i].flt = 1;
			} else r[i].flt = 1;
		}
		return k;
	}
	return n;
}

// Assembly:
movl %edx, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setbe %dl
testl %eax, %eax
setle %r8b
orb %dl, %r8b
jne 0x15f8cc
pushq %rbp
pushq %r14
pushq %rbx
movl %eax, %edx
leaq 0x44(%rcx), %r8
xorl %r9d, %r9d
xorl %eax, %eax
xorl %r10d, %r10d
cmpq %r9, %rdx
je 0x15f8c8
movl -0x40(%r8), %r11d
cmpq %r11, %r9
jne 0x15f843
andb $-0x2, 0x1(%r8)
jmp 0x15f8ba
movslq %r11d, %r11
movl -0x30(%r8), %ebx
cvtsi2ss %ebx, %xmm1
imulq $0x48, %r11, %r11
movl 0x14(%rcx,%r11), %ebp
cvtsi2ss %ebp, %xmm2
mulss %xmm0, %xmm2
ucomiss %xmm2, %xmm1
setae %r14b
addl %edi, %ebx
cmpl %ebp, %ebx
setge %bl
orb %r14b, %bl
cmpl %esi, %r10d
setl %bpl
andb %bl, %bpl
cmpb $0x1, %bpl
jne 0x15f8ab
addq %rcx, %r11
movl -0x2c(%r8), %ebx
cmpl 0x18(%r11), %ebx
jne 0x15f8b2
movl -0x28(%r8), %ebx
cmpl 0x1c(%r11), %ebx
jne 0x15f8b2
movl -0x20(%r8), %ebx
cmpl 0x24(%r11), %ebx
jne 0x15f8b2
movl -0x1c(%r8), %ebx
cmpl 0x28(%r11), %ebx
jne 0x15f8b2
orb $0x1, 0x1(%r8)
jmp 0x15f8bc
andb $-0x2, 0x1(%r8)
incl %r10d
incl %eax
incq %r9
addq $0x48, %r8
jmp 0x15f82a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: mg_gchain_restore_offset(mg_gchains_t*)
void mg_gchain_restore_offset(mg_gchains_t *gcs)
{
	int32_t i, j, n_a, n_lc;
	for (i = 0, n_a = n_lc = 0; i < gcs->n_gc; ++i) {
		mg_gchain_t *gc = &gcs->gc[i];
		gc->off = n_lc;
		for (j = 0, gc->n_anchor = 0; j < gc->cnt; ++j) {
			mg_llchain_t *lc = &gcs->lc[n_lc + j];
			lc->off = n_a;
			n_a += lc->cnt;
			gc->n_anchor += lc->cnt;
		}
		n_lc += gc->cnt;
	}
	assert(n_lc == gcs->n_lc && n_a == gcs->n_a);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x8(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
xorl %esi, %esi
cmpq %rax, %rcx
je 0x15f940
movq 0x18(%rdi), %r9
imulq $0x48, %rcx, %r10
leaq (%r9,%r10), %r8
movl %esi, 0x8(%r9,%r10)
andl $0x0, 0x10(%r9,%r10)
movl 0xc(%r9,%r10), %r9d
movslq %esi, %r10
xorl %r11d, %r11d
testl %r9d, %r9d
movl $0x0, %ebx
cmovgl %r9d, %ebx
shlq $0x4, %r10
subq $0x1, %rbx
jb 0x15f938
movq 0x20(%rdi), %r14
movl %edx, (%r14,%r10)
movl 0x4(%r14,%r10), %ebp
addl %ebp, %edx
addl %ebp, %r11d
movl %r11d, 0x10(%r8)
addq $0x10, %r10
jmp 0x15f916
addl %r9d, %esi
incq %rcx
jmp 0x15f8df
cmpl 0xc(%rdi), %esi
jne 0x15f94f
cmpl 0x10(%rdi), %edx
jne 0x15f94f
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x926d6(%rip), %rdi     # 0x1f202c
leaq 0x921c6(%rip), %rsi     # 0x1f1b23
leaq 0x926ed(%rip), %rcx     # 0x1f2051
movl $0x875, %edx            # imm = 0x875
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: find_ul_ov_max(int, ul_ov_t const*, unsigned int)
int32_t find_ul_ov_max(int32_t n, const ul_ov_t *a, uint32_t x)
{
    int32_t s = 0, e = n;
    if (n == 0) return -1;
    if (a[n-1].qe < x) return n - 1;
    if (a[0].qe >= x) return -1;
    while (e > s) { // TODO: finish this block
        int32_t m = s + (e - s) / 2;
        if (a[m].qe >= x) e = m;
        else s = m + 1;
    }
    assert(s == e);
    return s;
}

// Assembly:
pushq $-0x1
popq %rax
testl %edi, %edi
je 0x16076e
movl %edx, %ecx
leal -0x1(%rdi), %r8d
movslq %r8d, %rdx
imulq $0x1c, %rdx, %rdx
cmpl %ecx, 0x8(%rsi,%rdx)
jb 0x160775
movl %eax, %r8d
cmpl %ecx, 0x8(%rsi)
jae 0x160775
xorl %r8d, %r8d
pushq $0x2
popq %r9
movl %edi, %eax
subl %r8d, %eax
jle 0x160773
cltd
idivl %r9d
leal (%rax,%r8), %edx
movslq %edx, %rdx
imulq $0x1c, %rdx, %r10
cmpl %ecx, 0x8(%rsi,%r10)
leal 0x1(%rax,%r8), %eax
cmovael %r8d, %eax
cmovbl %edi, %edx
movl %eax, %r8d
movl %edx, %edi
jmp 0x160740
movl %eax, %r8d
jmp 0x160775
jne 0x160779
movl %r8d, %eax
retq
pushq %rax
leaq 0x91a43(%rip), %rdi     # 0x1f21c4
leaq 0x9139b(%rip), %rsi     # 0x1f1b23
leaq 0x91a3c(%rip), %rcx     # 0x1f21cb
movl $0x9c5, %edx            # imm = 0x9C5
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: get_ecov(ul_idx_t const*, ul_ov_t*, ul_ov_t*, long, long, double)
int64_t get_ecov(const ul_idx_t *uref, ul_ov_t *lv, ul_ov_t *lw, int64_t qlen, int64_t bw, double diff_ec_ul)
{
	int64_t dis_q = lv->qe - lw->qe, dis_t = 0, dif, mm;
	uint32_t i, v = ((lv->tn<<1)|lv->rev)^1, w = ((lw->tn<<1)|lw->rev)^1;
	const asg_t *g = uref->ug->g;
	uint32_t nv = asg_arc_n(g, v);
	asg_arc_t *av = asg_arc_a(g, v);
	for (i = 0; i < nv; i++) {
        if(av[i].del || av[i].v != w) continue;
		dis_t = ((uint32_t)av[i].ul);
		dis_t -= (lv->rev?lv->ts:g->seq[v>>1].len-lv->te);
		break;
    }
	
	dif = (dis_q>dis_t? dis_q-dis_t:dis_t-dis_q);
	mm = MAX(dis_q, dis_t); mm *= diff_ec_ul; if(mm < bw) mm = bw;
	// if((v>>1) == 1163 && (w>>1) == 1168) fprintf(stderr, ">>>>>>dis_q:%ld, dis_t:%ld, dif:%ld, mm:%ld\n", dis_q, dis_t, dif, mm);
	if(dif <= mm) return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x8(%rsi), %eax
movl 0xc(%rsi), %r9d
movl 0x8(%rdx), %ecx
movl 0xc(%rdx), %ebx
movl 0x18(%rsi), %r10d
shldl $0x1, %r10d, %r9d
movl %r9d, %r14d
xorl $0x1, %r14d
movl 0x18(%rdx), %r11d
shrdl $0x1f, %ebx, %r11d
movq (%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x8(%rdi), %rbx
movq 0x28(%rdi), %rdx
movq (%rdx,%r14,8), %rdx
movl %edx, %r14d
shrq $0x20, %rdx
imulq $0x18, %r14, %r15
imulq $0x18, %rdx, %r14
leaq (%r14,%rbx), %r13
addq $0xc, %r13
xorl %edx, %edx
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x160841
cmpl $0x0, (%r13,%r12)
js 0x160812
movl -0x4(%r13,%r12), %ebp
xorl %r11d, %ebp
cmpl $0x1, %ebp
je 0x160818
addq $0x18, %r12
jmp 0x1607f8
addq %rbx, %r14
movl (%r12,%r14), %edx
testl %r10d, %r10d
js 0x160839
movq 0x20(%rdi), %r10
shrl %r9d
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
andl (%r10,%r9,8), %edi
subl 0x14(%rsi), %edi
jmp 0x16083c
movl 0x10(%rsi), %edi
movl %edi, %esi
subq %rsi, %rdx
subl %ecx, %eax
movq %rdx, %rcx
subq %rax, %rcx
cmovgq %rdx, %rax
movq %rcx, %rdx
negq %rdx
cmovsq %rcx, %rdx
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
cmpq %r8, %rax
cmovgq %rax, %r8
xorl %eax, %eax
cmpq %r8, %rdx
setle %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: get_het_site(haplotype_evdience_alloc*, unsigned int)
uint64_t get_het_site(haplotype_evdience_alloc *hap, uint32_t oid)
{
	uint64_t k, l, i, occ = 0; SnpStats *s = NULL;
	for (k = 1, l = 0; k <= hap->length; ++k) {  
        if (k == hap->length || hap->list[k].overlapID != hap->list[l].overlapID) {
            if(hap->list[l].overlapID != oid) {
                l = k;
                continue;
            }
            for (i = l; i < k; i++) {
                if(hap->list[i].type!=1) continue; 
                s = &(hap->snp_stat.a[hap->list[i].overlapSite]);
                if(s->score == 1 && (!(s->occ_0 < 2 || s->occ_1 < 2))) {
					occ++;
                }
            }
            l = k;
        }
    }

	return (occ&((uint64_t)0x3FFFFFFF));
}

// Assembly:
pushq %rbx
movl 0x10(%rdi), %ecx
leaq 0x1(%rcx), %rdx
movabsq $0x1, %r8
xorl %r9d, %r9d
xorl %eax, %eax
cmpq %rdx, %r8
je 0x160c14
movq (%rdi), %r10
cmpq %rcx, %r8
jne 0x160ba7
imulq $0x18, %r9, %r11
movl 0x4(%r10,%r11), %r11d
jmp 0x160bbb
imulq $0x18, %r8, %rbx
imulq $0x18, %r9, %r11
movl 0x4(%r10,%r11), %r11d
cmpl %r11d, 0x4(%r10,%rbx)
je 0x160c0c
cmpl %esi, %r11d
jne 0x160c09
imulq $0x18, %r9, %r11
addq %r11, %r10
addq $0xc, %r10
cmpq %r8, %r9
jae 0x160c09
cmpb $0x1, (%r10)
jne 0x160c00
movq 0x218(%rdi), %r11
movl -0x4(%r10), %ebx
imulq $0x28, %rbx, %rbx
cmpl $0x1, 0x1c(%r11,%rbx)
jne 0x160c00
addq %rbx, %r11
cmpl $0x2, 0x8(%r11)
jb 0x160c00
cmpl $0x2, 0xc(%r11)
sbbq $-0x1, %rax
incq %r9
addq $0x18, %r10
jmp 0x160bcb
movq %r8, %r9
incq %r8
jmp 0x160b8b
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: get_het_occ(haplotype_evdience*, long, long, long, utg_ct_t*, long)
int64_t get_het_occ(haplotype_evdience *he_a, int64_t he_n, int64_t c_k, int64_t ylen, utg_ct_t *p, int64_t rev)
{
	int64_t k, occ = 0, ss;
	if(!rev) {
		for (k = c_k; k >= 0; k--) {
			if(he_a[k].cov >= p->s && he_a[k].cov < p->e) {
				occ++;
			} else {
				break;
			}
		}

		for (k = c_k+1; k < he_n; k++) {
			if(he_a[k].cov >= p->s && he_a[k].cov < p->e) {
				occ++;
			} else {
				break;
			}
		}
	} else {
		for (k = c_k; k >= 0; k--) {
			ss = ylen - he_a[k].cov - 1;
			if(ss >= p->s && ss < p->e) {
				occ++;
			} else {
				break;
			}
		}

		for (k = c_k+1; k < he_n; k++) {
			ss = ylen - he_a[k].cov - 1;
			if(ss >= p->s && ss < p->e) {
				occ++;
			} else {
				break;
			}
		}
	}

	assert(occ);
	return occ;
}

// Assembly:
pushq %rbx
testq %r9, %r9
je 0x1614e7
imulq $0x18, %rdx, %r9
leaq (%r9,%rdi), %r10
addq $0x10, %r10
xorl %eax, %eax
movq %rdx, %r11
addq %rax, %r11
js 0x1614aa
movl (%r10), %r11d
notq %r11
addq %rcx, %r11
movl 0x4(%r8), %ebx
cmpq %rbx, %r11
jl 0x1614aa
movl 0x8(%r8), %ebx
cmpq %rbx, %r11
jae 0x1614aa
addq $-0x18, %r10
decq %rax
jmp 0x16147e
addq %r9, %rdi
addq $0x28, %rdi
incq %rdx
negq %rax
cmpq %rsi, %rdx
jge 0x161541
movl (%rdi), %r9d
notq %r9
addq %rcx, %r9
movl 0x4(%r8), %r10d
cmpq %r10, %r9
jl 0x161541
movl 0x8(%r8), %r10d
cmpq %r10, %r9
jae 0x161541
incq %rax
addq $0x18, %rdi
incq %rdx
jmp 0x1614b7
imulq $0x18, %rdx, %rcx
leaq (%rcx,%rdi), %r9
addq $0x10, %r9
xorl %eax, %eax
movq %rdx, %r10
addq %rax, %r10
js 0x161515
movl (%r9), %r10d
cmpl 0x4(%r8), %r10d
jb 0x161515
cmpl 0x8(%r8), %r10d
jae 0x161515
addq $-0x18, %r9
decq %rax
jmp 0x1614f5
addq %rdi, %rcx
addq $0x28, %rcx
incq %rdx
negq %rax
cmpq %rsi, %rdx
jge 0x161541
movl (%rcx), %edi
cmpl 0x4(%r8), %edi
jb 0x161541
cmpl 0x8(%r8), %edi
jae 0x161541
incq %rax
addq $0x18, %rcx
incq %rdx
jmp 0x161522
testq %rax, %rax
je 0x161548
popq %rbx
retq
leaq 0x80f4c(%rip), %rdi     # 0x1e249b
leaq 0x905cd(%rip), %rsi     # 0x1f1b23
leaq 0x90e48(%rip), %rcx     # 0x1f23a5
movl $0xb23, %edx            # imm = 0xB23
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: check_contain_pair(ug_opt_t const*, unsigned int, unsigned int, unsigned int)
uint32_t check_contain_pair(const ug_opt_t *uopt, uint32_t x, uint32_t y, uint32_t check_el)
{
	ma_hit_t_alloc* src = uopt->sources;
	int64_t min_ovlp = uopt->min_ovlp;
	int64_t max_hang = uopt->max_hang;
	uint64_t z, qn, tn; int32_t r = 1; asg_arc_t e;
	for (z = 0; z < src[x].length; z++) {
		if(check_el && (!src[x].buffer[z].el)) continue;
		qn = Get_qn(src[x].buffer[z]); tn = Get_tn(src[x].buffer[z]);
		if(tn != y) continue;
		r = ma_hit2arc(&(src[x].buffer[z]), Get_READ_LENGTH(R_INF, qn), Get_READ_LENGTH(R_INF, tn), max_hang, asm_opt.max_hang_rate, min_ovlp, &e);
		if(r == MA_HT_QCONT || r == MA_HT_TCONT) break;
	}

	if(z < src[x].length) return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movq 0x8(%rdi), %rax
movl 0x44(%rdi), %ecx
movl %ecx, 0xc(%rsp)
movl 0x40(%rdi), %ecx
movl %ecx, 0x8(%rsp)
movl %esi, %ecx
imulq $0x18, %rcx, %rcx
leaq (%rax,%rcx), %r12
movl 0xc(%rax,%rcx), %r13d
leaq 0xf21c0(%rip), %rax     # 0x254230
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0xf16d8(%rip), %rax     # 0x253758
movss 0x158(%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movl %edx, %eax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x1620f6
movq (%r12), %rdi
testl %ebx, %ebx
je 0x1620af
cmpb $0x0, 0x20(%rdi,%r15)
je 0x1620ed
cmpl %r14d, 0xc(%rdi,%r15)
jne 0x1620ed
addq %r15, %rdi
movl 0x4(%rdi), %eax
movq 0x18(%rsp), %rcx
movl (%rcx,%rax,8), %esi
movq 0x10(%rsp), %rax
movl (%rcx,%rax,8), %edx
movl 0x8(%rsp), %ecx
movss 0x4(%rsp), %xmm0
movl 0xc(%rsp), %r8d
leaq 0x20(%rsp), %r9
callq 0x15d560
addl $0x3, %eax
cmpl $0x2, %eax
jb 0x1620f6
incq %rbp
addq $0x28, %r15
jmp 0x16209a
xorl %eax, %eax
cmpq %r13, %rbp
setb %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: debug_contain_ovlps(ul_ov_t*, unsigned long, ug_opt_t const*)
void debug_contain_ovlps(ul_ov_t *a, uint64_t a_n, const ug_opt_t *uopt)
{
	uint64_t k, i, f; ul_ov_t *z = NULL, *w = NULL;
	for (k = 0; k < a_n; k++) {
		z = &(a[k]);
		if(!(z->tn&((uint32_t)(0x80000000)))) continue;
		for (i = 0, f = z->qn; i < a_n; i++) {
			w = &(a[i]);
			if(i == k) continue;
			if(w->tn&((uint32_t)(0x80000000))) continue;
			if(z->qs >= w->qs && z->qe <= w->qe && check_contain_pair(uopt, (z->tn<<1)>>1, w->tn, 1)) {
				f = (uint32_t)-1;
				break;
			}
		}
		if(z->qn != f) fprintf(stderr, "ERROR\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc(%rdi), %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
cmpq %r14, %rbp
je 0x1621d4
imulq $0x1c, %rbp, %r13
cmpl $0x0, 0xc(%r15,%r13)
jns 0x1621aa
addq %r15, %r13
movl (%r13), %eax
movq %rax, 0x8(%rsp)
movq (%rsp), %rbx
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x16219f
cmpq %r12, %rbp
je 0x162196
movl (%rbx), %edx
testl %edx, %edx
js 0x162196
movl 0x4(%r13), %eax
cmpl -0x8(%rbx), %eax
jb 0x162196
movl 0x8(%r13), %eax
cmpl -0x4(%rbx), %eax
ja 0x162196
movl 0xc(%r13), %esi
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl %eax, %esi
movq 0x10(%rsp), %rdi
pushq $0x1
popq %rcx
callq 0x162035
testl %eax, %eax
jne 0x1621af
incq %r12
addq $0x1c, %rbx
jmp 0x162158
movq 0x8(%rsp), %rax
cmpl (%r13), %eax
jne 0x1621b6
incq %rbp
jmp 0x162130
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1621a4
movq 0xf0e23(%rip), %rax     # 0x252fe0
movq (%rax), %rcx
leaq 0x88bbd(%rip), %rdi     # 0x1ead84
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
jmp 0x1621aa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: query_ovlp_src(ug_opt_t const*, unsigned int, unsigned int, long, double, unsigned int*)
ma_hit_t* query_ovlp_src(const ug_opt_t *uopt, uint32_t v, uint32_t w, int64_t o, double diff_ec_ul, uint32_t *ol)
{
	ma_hit_t_alloc* src = uopt->sources;
    int64_t min_ovlp = uopt->min_ovlp;
    int64_t max_hang = uopt->max_hang, d, l, max_l;
    uint64_t z, qn, tn, x = v>>1; int32_t r = 1; asg_arc_t e;
	l = (o>=0?o:-o); //l *= diff_ec_ul;
	if(l <= 0) return NULL;
    for (z = 0; z < src[x].length; z++) {
        qn = Get_qn(src[x].buffer[z]); tn = Get_tn(src[x].buffer[z]);
        if(tn != (w>>1)) continue;
        r = ma_hit2arc(&(src[x].buffer[z]), Get_READ_LENGTH(R_INF, qn), Get_READ_LENGTH(R_INF, tn), max_hang, asm_opt.max_hang_rate, min_ovlp, &e);
        if(r < 0) continue;
		if((e.ul>>32) != v || e.v != w) continue;
		// if(v == 56 && w == 25) fprintf(stderr, "+xxxx, o:%ld, e.ol:%u\n", o, e.ol);
		// if(v == 25 && w == 56) fprintf(stderr, "-xxxx, o:%ld, e.ol:%u\n", o, e.ol);
		d = (o>=e.ol?o-e.ol:e.ol-o);
		max_l = MAX(l, e.ol);
		if(d <= (max_l*diff_ec_ul)) {
			if(ol) (*ol) = e.ol;
			return &(src[x].buffer[z]);
		}
    }
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, 0x30(%rsp)
movq %rcx, %rax
negq %rax
movq %rcx, 0x28(%rsp)
cmovsq %rcx, %rax
movq %rax, 0x20(%rsp)
jae 0x162310
movq %r8, 0x18(%rsp)
movq 0x8(%rdi), %rax
movl 0x44(%rdi), %ecx
movl %ecx, 0x14(%rsp)
movl 0x40(%rdi), %ecx
movl %ecx, 0x10(%rsp)
movl %esi, %ecx
movq %rcx, 0x38(%rsp)
shrl %esi
imulq $0x18, %rsi, %rcx
leaq (%rax,%rcx), %rbx
movl 0xc(%rax,%rcx), %eax
movl %edx, 0x8(%rsp)
movl %edx, %ebp
shrl %ebp
leaq 0xf1fe4(%rip), %rcx     # 0x254230
movq 0x18(%rcx), %r15
leaq 0xf1501(%rip), %rcx     # 0x253758
movss 0x158(%rcx), %xmm0
movss %xmm0, 0xc(%rsp)
imulq $0x28, %rax, %r12
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x162310
movq (%rbx), %r13
cmpl %ebp, 0xc(%r13,%r14)
jne 0x162307
addq %r14, %r13
movl 0x4(%r13), %eax
movl (%r15,%rax,8), %esi
movl (%r15,%rbp,8), %edx
movq %r13, %rdi
movl 0x10(%rsp), %ecx
movss 0xc(%rsp), %xmm0
movl 0x14(%rsp), %r8d
leaq 0x40(%rsp), %r9
callq 0x15d560
testl %eax, %eax
js 0x162307
movq 0x38(%rsp), %rax
cmpl %eax, 0x44(%rsp)
jne 0x162307
movl 0x8(%rsp), %eax
cmpl %eax, 0x48(%rsp)
jne 0x162307
movl 0x4c(%rsp), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, %rcx
subq 0x28(%rsp), %rcx
movq %rcx, %rdx
negq %rdx
cmovsq %rcx, %rdx
movq 0x20(%rsp), %rsi
cmpq %rax, %rsi
movq %rax, %rcx
cmovaq %rsi, %rcx
cvtsi2sd %rdx, %xmm0
cvtsi2sd %rcx, %xmm1
mulsd 0x30(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x162325
addq $0x28, %r14
jmp 0x16226c
xorl %r13d, %r13d
movq %r13, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
je 0x162313
movl %eax, (%rcx)
jmp 0x162313
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/inter.cpp
// Function: debug_infer_read_ovlp(ug_opt_t const*, double, ul_ov_t*, ul_ov_t*, ma_utg_t*, unsigned int, unsigned int, All_reads*, ma_ug_t*)
void debug_infer_read_ovlp(const ug_opt_t *uopt, double diff_ec_ul, ul_ov_t *li, ul_ov_t *lj, ma_utg_t *u, 
uint32_t i_idx, uint32_t j_idx, All_reads *ridx, ma_ug_t *ug)
{
	uint32_t li_v, lj_v; ma_hit_t *t = NULL;
	li_v = (((uint32_t)(li->tn))<<1)|((uint32_t)(li->rev));
	lj_v = (((uint32_t)(lj->tn))<<1)|((uint32_t)(lj->rev));
	if(lj->qe <= li->qs || li_v == lj_v) fprintf(stderr, "ERROR-1\n");
    t = query_ovlp_src(uopt, li_v^1, lj_v^1, infer_rovlp(li, lj, NULL, NULL, ridx, ug), diff_ec_ul, NULL);
	// ((int64_t)(lj->qe))-((int64_t)(li->qs))
	if(!t /**&& (li_v^1) == 648 && (lj_v^1) == 638 && li->qs == 63841**/) {
		fprintf(stderr, "ERROR-2, li_v^1->%u, li->qs->%u, li->qe->%u, lj_v^1->%u, lj->qs->%u, lj->qe->%u, infer_rovlp->%ld\n", 
		li_v^1, li->qs, li->qe, lj_v^1, lj->qs, lj->qe, infer_rovlp(li, lj, NULL, NULL, ridx, ug));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movsd %xmm0, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x68(%rsp), %r13
movl 0xc(%rsi), %eax
movl 0x18(%rsi), %ebx
shrdl $0x1f, %eax, %ebx
movq 0x60(%rsp), %r15
movl 0x8(%rdx), %eax
movl 0xc(%rdx), %ecx
movl 0x18(%rdx), %ebp
shrdl $0x1f, %ecx, %ebp
cmpl 0x4(%rsi), %eax
jbe 0x162450
cmpl %ebp, %ebx
je 0x162450
xorl $0x1, %ebx
xorl $0x1, %ebp
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
movq %r13, %r9
callq 0x3d261
movq 0x8(%rsp), %rdi
movl %ebx, %esi
movl %ebp, %edx
movq %rax, %rcx
movsd 0x10(%rsp), %xmm0
xorl %r8d, %r8d
callq 0x1621e3
testq %rax, %rax
je 0x1623cd
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xf0c0c(%rip), %rax     # 0x252fe0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x4(%r12), %eax
movl %eax, 0x1c(%rsp)
movl 0x8(%r12), %eax
movl %eax, 0x18(%rsp)
movl 0x4(%r14), %eax
movq %rax, 0x10(%rsp)
movl 0x8(%r14), %eax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
movq %r13, %r9
callq 0x3d261
movq %rax, %r10
subq $0x8, %rsp
leaq 0x8ffdc(%rip), %rsi     # 0x1f23ff
movq 0x28(%rsp), %rdi
movl %ebx, %edx
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %r8d
movl %ebp, %r9d
xorl %eax, %eax
pushq %r10
pushq 0x18(%rsp)
pushq 0x28(%rsp)
callq 0x22b0
addq $0x48, %rsp
jmp 0x1623c2
movq 0xf0b89(%rip), %rax     # 0x252fe0
movq (%rax), %rcx
leaq 0x87906(%rip), %rdi     # 0x1e9d67
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
jmp 0x162384