LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: v128_rmdup
static inline void v128_rmdup(ku128_v *r)
{
	int l, cnt;
	uint64_t x;
	if (r->n > 1) ks_introsort(128x, r->n, r->a);
	for (l = cnt = 0; l < r->n; ++l) // jump to the first node to be retained
		if (edge_is_del(r->a[l])) ++cnt;
		else break;
	if (l == r->n) { // no good arcs
		r->n = 0;
		return;
	}
	x = r->a[l].x;
	for (++l; l < r->n; ++l) { // mark duplicated node
		if (edge_is_del(r->a[l]) || r->a[l].x == x)
			edge_mark_del(r->a[l]), ++cnt;
		else x = r->a[l].x;
	}
	if (cnt) v128_clean(r);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq $0x2, %rdi
jb 0xecf1
movq 0x10(%rbx), %rsi
callq 0xd2c7
movq (%rbx), %rax
testq %rax, %rax
je 0xed24
movq 0x10(%rbx), %rdx
addq $0x8, %rdx
xorl %ecx, %ecx
cmpq $-0x2, -0x8(%rdx)
je 0xed10
cmpq $0x0, (%rdx)
jne 0xed1f
incq %rcx
addq $0x10, %rdx
cmpq %rcx, %rax
jne 0xed03
movq %rax, %rcx
leal 0x1(%rcx), %edx
jmp 0xed2b
xorl %ecx, %ecx
movl $0x1, %edx
cmpq %rcx, %rax
jne 0xed37
xorl %ecx, %ecx
jmp 0xede1
cmpq %rdx, %rax
jbe 0xed90
movq 0x10(%rbx), %rdi
movq %rcx, %rsi
shlq $0x4, %rsi
movq (%rdi,%rsi), %rsi
movq %rdx, %r8
shlq $0x4, %r8
addq %r8, %rdi
addq $0x8, %rdi
movq -0x8(%rdi), %r8
cmpq $-0x2, %r8
jne 0xed76
movq $-0x2, -0x8(%rdi)
movq $0x0, (%rdi)
incl %ecx
jmp 0xed84
cmpq $0x0, (%rdi)
je 0xed63
cmpq %rsi, %r8
je 0xed63
movq %r8, %rsi
incq %rdx
addq $0x10, %rdi
cmpq %rdx, %rax
ja 0xed59
testl %ecx, %ecx
je 0xede4
xorl %ecx, %ecx
testq %rax, %rax
je 0xede1
xorl %eax, %eax
xorl %edx, %edx
movq 0x10(%rbx), %rsi
cmpq $-0x2, (%rsi,%rax)
je 0xedd2
cmpq $0x0, 0x8(%rsi,%rax)
je 0xedd2
movl %ecx, %r8d
leal 0x1(%rcx), %edi
cmpq %r8, %rdx
je 0xedd0
leaq (%rsi,%rax), %r8
movslq %ecx, %rcx
shlq $0x4, %rcx
movups (%r8), %xmm0
movups %xmm0, (%rsi,%rcx)
movl %edi, %ecx
incq %rdx
addq $0x10, %rax
cmpq %rdx, (%rbx)
ja 0xed9f
movslq %ecx, %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_g_print
void mag_g_print(const mag_t *g)
{
	int i;
	kstring_t out;
	out.l = out.m = 0; out.s = 0;
	for (i = 0; i < g->v.n; ++i) {
		if (g->v.a[i].len < 0) continue;
		mag_v_write(&g->v.a[i], &out);
		fwrite(out.s, 1, out.l, stdout);
	}
	free(out.s);
	fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, (%rdi)
je 0xf71a
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rsp, %r14
movq 0xd8e2(%rip), %r12      # 0x1cfc0
xorl %r13d, %r13d
movq 0x10(%rbx), %rdi
cmpl $0x0, (%rdi,%r15)
js 0xf70e
addq %r15, %rdi
movq %r14, %rsi
callq 0xede6
movq (%rsp), %rdx
movq 0x10(%rsp), %rdi
movq (%r12), %rcx
movl $0x1, %esi
callq 0x2270
incq %r13
addq $0x68, %r15
cmpq %r13, (%rbx)
ja 0xf6e1
movq 0x10(%rsp), %rdi
callq 0x2040
movq 0xd895(%rip), %rax      # 0x1cfc0
movq (%rax), %rdi
callq 0x21c0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_v_destroy
void mag_v_destroy(magv_t *v)
{
	free(v->nei[0].a); free(v->nei[1].a);
	free(v->seq); free(v->cov);
	memset(v, 0, sizeof(magv_t));
	v->len = -1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x2040
movq 0x48(%rbx), %rdi
callq 0x2040
movq 0x50(%rbx), %rdi
callq 0x2040
movq 0x58(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x60(%rbx)
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_g_destroy
void mag_g_destroy(mag_t *g)
{
	int i;
	kh_destroy(64, g->h);
	for (i = 0; i < g->v.n; ++i)
		mag_v_destroy(&g->v.a[i]);
	free(g->v.a);
	free(g);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xc86b
cmpq $0x0, (%rbx)
je 0xf7c8
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
addq %r14, %rdi
callq 0xf741
incq %r15
addq $0x68, %r14
cmpq %r15, (%rbx)
ja 0xf7b0
movq 0x10(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_v_copy_to_empty
void mag_v_copy_to_empty(magv_t *dst, const magv_t *src) // NB: memory leak if dst is allocated
{
	memcpy(dst, src, sizeof(magv_t));
	dst->max_len = dst->len + 1;
	kroundup32(dst->max_len);
	dst->seq = calloc(dst->max_len, 1); memcpy(dst->seq, src->seq, src->len);
	dst->cov = calloc(dst->max_len, 1); memcpy(dst->cov, src->cov, src->len);
	kv_init(dst->nei[0]); kv_copy(ku128_t, dst->nei[0], src->nei[0]);
	kv_init(dst->nei[1]); kv_copy(ku128_t, dst->nei[1], src->nei[1]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xd, %ecx
rep  movsq (%rsi), %es:(%rdi)
movl (%r14), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %r15d
shrl $0x10, %r15d
orl %eax, %r15d
incl %r15d
movl %r15d, 0x8(%r14)
movl $0x1, %esi
movq %r15, %rdi
callq 0x2130
movq %rax, 0x50(%r14)
movq 0x50(%rbx), %rsi
movslq (%rbx), %r12
movq %rax, %rdi
movq %r12, %rdx
callq 0x2180
movl $0x1, %esi
movq %r15, %rdi
callq 0x2130
movq %rax, 0x58(%r14)
movq 0x58(%rbx), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq $0x0, 0x30(%r14)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xf8c7
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rdi
shrq $0x10, %rdi
orq %rax, %rdi
incq %rdi
movq %rdi, 0x28(%r14)
shlq $0x4, %rdi
callq 0x21b0
movq %rax, 0x30(%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movq 0x30(%r14), %rdi
movq 0x20(%rbx), %rdx
movq 0x30(%rbx), %rsi
shlq $0x4, %rdx
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movq $0x0, 0x48(%r14)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0xf945
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rdi
shrq $0x10, %rdi
orq %rax, %rdi
incq %rdi
movq %rdi, 0x40(%r14)
shlq $0x4, %rdi
callq 0x21b0
movq %rax, 0x48(%r14)
movq 0x38(%rbx), %rax
movq %rax, 0x38(%r14)
movq 0x48(%r14), %rdi
movq 0x38(%rbx), %rdx
movq 0x48(%rbx), %rsi
shlq $0x4, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_eh_add
void mag_eh_add(mag_t *g, uint64_t u, uint64_t v, int ovlp) // add v to u
{
	ku128_v *r;
	ku128_t *q;
	uint64_t idd;
	int i;
	if ((int64_t)u < 0) return;
	idd = tid2idd(g->h, u);
	r = &g->v.a[idd>>1].nei[idd&1];
	for (i = 0; i < r->n; ++i) // no multi-edges
		if (r->a[i].x == v) return;
	kv_pushp(ku128_t, *r, &q);
	q->x = v; q->y = ovlp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0xfa2d
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%rdi), %r12
movq %r12, %rdi
callq 0xc8d4
cmpl (%r12), %eax
je 0xfa39
movq 0x20(%r12), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
imulq $0x68, %rcx, %rcx
addq 0x10(%r15), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %r15
addq $0x20, %r15
movq (%r15), %rax
testq %rax, %rax
je 0xf9e1
movq 0x10(%r15), %rcx
movq %rax, %rdx
cmpq %r14, (%rcx)
je 0xfa2d
addq $0x10, %rcx
decq %rdx
jne 0xf9d3
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
jne 0xfa0f
leaq (%rcx,%rcx), %rax
testq %rcx, %rcx
movl $0x2, %esi
cmovneq %rax, %rsi
movq %rsi, 0x8(%r15)
movq 0x10(%r15), %rdi
shlq $0x4, %rsi
callq 0x21d0
movq %rax, 0x10(%r15)
movq (%r15), %rax
movq 0x10(%r15), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%r15)
shlq $0x4, %rax
movq %r14, (%rcx,%rax)
movslq %ebx, %rdx
movq %rdx, 0x8(%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x797f(%rip), %rdi      # 0x173bf
leaq 0x8094(%rip), %rsi      # 0x17adb
leaq 0x831a(%rip), %rcx      # 0x17d68
movl $0x70, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_eh_markdel
void mag_eh_markdel(mag_t *g, uint64_t u, uint64_t v) // mark deletion of v from u
{
	int i;	
	uint64_t idd;
	if ((int64_t)u < 0) return;
	idd = tid2idd(g->h, u);
	ku128_v *r = &g->v.a[idd>>1].nei[idd&1];
	for (i = 0; i < r->n; ++i)
		if (r->a[i].x == v) edge_mark_del(r->a[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
js 0xfacb
movq %rdx, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r15
movq %r15, %rdi
callq 0xc8d4
cmpl (%r15), %eax
je 0xfad1
movq 0x20(%r15), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
movq %rax, %rcx
shrq %rcx
imulq $0x68, %rcx, %rcx
addq 0x10(%r14), %rcx
andl $0x1, %eax
leaq (%rax,%rax,2), %rdx
movq 0x20(%rcx,%rdx,8), %rax
testq %rax, %rax
je 0xfacb
leaq (%rcx,%rdx,8), %rcx
addq $0x20, %rcx
movq 0x10(%rcx), %rcx
cmpq %rbx, (%rcx)
jne 0xfac2
movq $-0x2, (%rcx)
movq $0x0, 0x8(%rcx)
addq $0x10, %rcx
decq %rax
jne 0xfaae
popq %rbx
popq %r14
popq %r15
retq
leaq 0x78e7(%rip), %rdi      # 0x173bf
leaq 0x7ffc(%rip), %rsi      # 0x17adb
leaq 0x8282(%rip), %rcx      # 0x17d68
movl $0x70, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_v_del
void mag_v_del(mag_t *g, magv_t *p)
{
	int i, j;
	khint_t k;
	if (p->len < 0) return;
	for (i = 0; i < 2; ++i) {
		ku128_v *r = &p->nei[i];
		for (j = 0; j < r->n; ++j)
			if (!edge_is_del(r->a[j]) && r->a[j].x != p->k[0] && r->a[j].x != p->k[1])
				mag_eh_markdel(g, r->a[j].x, p->k[i]);
	}
	for (i = 0; i < 2; ++i) {
		k = kh_get(64, g->h, p->k[i]);
		kh_del(64, g->h, k);
	}
	mag_v_destroy(p);
}

// Assembly:
cmpl $0x0, (%rsi)
js 0xfbbc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
leaq (%r12,%r12,2), %rax
movq (%rsp), %rcx
cmpq $0x0, (%rcx,%rax,8)
je 0xfb70
movq (%rsp), %rcx
leaq (%rcx,%rax,8), %r13
movl $0x8, %ebp
xorl %r15d, %r15d
movq 0x10(%r13), %rax
movq -0x8(%rax,%rbp), %rsi
cmpq $-0x2, %rsi
je 0xfb63
cmpq $0x0, (%rax,%rbp)
je 0xfb63
cmpq 0x10(%rbx), %rsi
je 0xfb63
cmpq 0x18(%rbx), %rsi
je 0xfb63
movq 0x10(%rbx,%r12,8), %rdx
movq %r14, %rdi
callq 0xfa58
incq %r15
addq $0x10, %rbp
cmpq %r15, (%r13)
ja 0xfb34
leaq 0x1(%r12), %rax
testq %r12, %r12
movq %rax, %r12
je 0xfb15
movl $0x2, %r12d
movq 0x20(%r14), %r15
movq (%rbx,%r12,8), %rsi
movq %r15, %rdi
callq 0xc8d4
movq %r15, %rdi
movl %eax, %esi
callq 0xcd36
incq %r12
cmpq $0x3, %r12
je 0xfb83
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf741
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_v_transdel
void mag_v_transdel(mag_t *g, magv_t *p, int min_ovlp)
{
	if (p->nei[0].n && p->nei[1].n) {
		int i, j, ovlp;
		for (i = 0; i < p->nei[0].n; ++i) {
			if (edge_is_del(p->nei[0].a[i]) || p->nei[0].a[i].x == p->k[0] || p->nei[0].a[i].x == p->k[1]) continue; // due to p->p loop
			for (j = 0; j < p->nei[1].n; ++j) {
				if (edge_is_del(p->nei[1].a[j]) || p->nei[1].a[j].x == p->k[0] || p->nei[1].a[j].x == p->k[1]) continue;
				ovlp = (int)(p->nei[0].a[i].y + p->nei[1].a[j].y) - p->len;
				if (ovlp >= min_ovlp) {
					mag_eh_add(g, p->nei[0].a[i].x, p->nei[1].a[j].x, ovlp);
					mag_eh_add(g, p->nei[1].a[j].x, p->nei[0].a[i].x, ovlp);
				}
			}
		}
	}
	mag_v_del(g, p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpq $0x0, 0x20(%rsi)
je 0xfcd2
cmpq $0x0, 0x38(%rbx)
je 0xfcd2
cmpq $0x0, 0x20(%rbx)
je 0xfcd2
movl %edx, %r8d
xorl %r12d, %r12d
movl %edx, 0x14(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x30(%rbx), %rcx
movq %r12, %r13
shlq $0x4, %r13
movq (%rcx,%r13), %rax
cmpq $-0x2, %rax
je 0xfcc5
addq %r13, %rcx
cmpq $0x0, 0x8(%rcx)
je 0xfcc5
cmpq 0x10(%rbx), %rax
je 0xfcc5
cmpq 0x18(%rbx), %rax
je 0xfcc5
cmpq $0x0, 0x38(%rbx)
je 0xfcc5
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0x48(%rbx), %rax
movq (%rax,%rbp), %rdx
cmpq $-0x2, %rdx
je 0xfcb8
movq 0x8(%rax,%rbp), %r15
testq %r15, %r15
je 0xfcb8
cmpq 0x10(%rbx), %rdx
je 0xfcb8
cmpq 0x18(%rbx), %rdx
je 0xfcb8
movq 0x30(%rbx), %rax
addl 0x8(%rax,%r13), %r15d
subl (%rbx), %r15d
cmpl %r8d, %r15d
jl 0xfcb8
addq %r13, %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdi
movl %r15d, %ecx
callq 0xf96d
movq 0x30(%rbx), %rax
movq 0x48(%rbx), %rcx
movq (%rcx,%rbp), %rsi
movq (%rax,%r13), %rdx
movq 0x8(%rsp), %rdi
movl %r15d, %ecx
callq 0xf96d
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %r8d
incq %r14
addq $0x10, %rbp
cmpq %r14, 0x38(%rbx)
ja 0xfc49
incq %r12
cmpq %r12, 0x20(%rbx)
ja 0xfbfe
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfaf0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_v_flip
void mag_v_flip(mag_t *g, magv_t *p)
{
	ku128_v t;
	khint_t k;
	hash64_t *h = (hash64_t*)g->h;

	seq_revcomp6(p->len, (uint8_t*)p->seq);
	seq_reverse(p->len, (uint8_t*)p->cov);
	p->k[0] ^= p->k[1]; p->k[1] ^= p->k[0]; p->k[0] ^= p->k[1];
	t = p->nei[0]; p->nei[0] = p->nei[1]; p->nei[1] = t;
	k = kh_get(64, h, p->k[0]);
	assert(k != kh_end(h));
	kh_val(h, k) ^= 1;
	k = kh_get(64, h, p->k[1]);
	assert(k != kh_end(h));
	kh_val(h, k) ^= 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq 0x20(%rdi), %rbx
movl (%rsi), %edi
movq 0x50(%rsi), %rsi
callq 0x4205
movl (%r14), %edi
movq 0x58(%r14), %rsi
callq 0x41db
movq 0x10(%r14), %rax
movq 0x18(%r14), %rsi
movq %rax, 0x18(%r14)
movq %rsi, 0x10(%r14)
movq 0x30(%r14), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%r14), %xmm0
movaps %xmm0, (%rsp)
movups 0x38(%r14), %xmm0
movups %xmm0, 0x20(%r14)
movq 0x48(%r14), %rax
movq %rax, 0x30(%r14)
movaps (%rsp), %xmm0
movups %xmm0, 0x38(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%r14)
movq %rbx, %rdi
callq 0xc8d4
movl (%rbx), %ebp
cmpl %ebp, %eax
je 0xfd91
movq 0x20(%rbx), %r15
movl %eax, %eax
xorq $0x1, (%r15,%rax,8)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xc8d4
cmpl %ebp, %eax
je 0xfdb0
movl %eax, %eax
xorb $0x1, (%r15,%rax,8)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7627(%rip), %rdi      # 0x173bf
leaq 0x7d3c(%rip), %rsi      # 0x17adb
leaq 0x7d3b(%rip), %rcx      # 0x17ae1
movl $0x12b, %edx            # imm = 0x12B
callq 0x20e0
leaq 0x7608(%rip), %rdi      # 0x173bf
leaq 0x7d1d(%rip), %rsi      # 0x17adb
leaq 0x7d1c(%rip), %rcx      # 0x17ae1
movl $0x12e, %edx            # imm = 0x12E
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_g_merge
void mag_g_merge(mag_t *g, int rmdup, int min_merge_len)
{
	int i;
	uint64_t n = 0;
	for (i = 0; i < g->v.n; ++i) { // remove multiedges; FIXME: should we do that?
		if (rmdup) {
			v128_rmdup(&g->v.a[i].nei[0]);
			v128_rmdup(&g->v.a[i].nei[1]);
		} else {
			v128_clean(&g->v.a[i].nei[0]);
			v128_clean(&g->v.a[i].nei[1]);
		}
	}
	for (i = 0; i < g->v.n; ++i) {
		magv_t *p = &g->v.a[i];
		if (p->len < 0) continue;
		while (mag_vh_merge_try(g, p, min_merge_len) == 0) ++n;
		mag_v_flip(g, p);
		while (mag_vh_merge_try(g, p, min_merge_len) == 0) ++n;
	}
	if (fm_verbose >= 3)
		fprintf(stderr, "[M::%s] unambiguously merged %ld pairs of vertices\n", __func__, (long)n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x10245
movl %esi, %ebp
xorl %r15d, %r15d
testl %ebp, %ebp
je 0x10170
movq 0x10(%r14), %rax
imulq $0x68, %r15, %r12
leaq (%rax,%r12), %rdi
addq $0x20, %rdi
callq 0xecdb
movq 0x10(%r14), %rax
leaq (%rax,%r12), %rdi
addq $0x38, %rdi
callq 0xecdb
jmp 0x10239
movq 0x10(%r14), %rcx
imulq $0x68, %r15, %rax
addq %rax, %rcx
addq $0x20, %rcx
cmpq $0x0, (%rcx)
je 0x101d2
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
movq 0x10(%rcx), %r8
cmpq $-0x2, (%r8,%rdx)
je 0x101c1
cmpq $0x0, 0x8(%r8,%rdx)
je 0x101c1
movl %edi, %r10d
leal 0x1(%rdi), %r9d
cmpq %r10, %rsi
je 0x101be
leaq (%r8,%rdx), %r10
movslq %edi, %rdi
shlq $0x4, %rdi
movups (%r10), %xmm0
movups %xmm0, (%r8,%rdi)
movl %r9d, %edi
incq %rsi
addq $0x10, %rdx
cmpq %rsi, (%rcx)
ja 0x1018b
movslq %edi, %rdx
jmp 0x101d4
xorl %edx, %edx
movq %rdx, (%rcx)
movq 0x10(%r14), %rcx
addq %rcx, %rax
addq $0x38, %rax
cmpq $0x0, (%rax)
je 0x10234
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movq 0x10(%rax), %rdi
cmpq $-0x2, (%rdi,%rcx)
je 0x10223
cmpq $0x0, 0x8(%rdi,%rcx)
je 0x10223
movl %esi, %r9d
leal 0x1(%rsi), %r8d
cmpq %r9, %rdx
je 0x10220
leaq (%rdi,%rcx), %r9
movslq %esi, %rsi
shlq $0x4, %rsi
movups (%r9), %xmm0
movups %xmm0, (%rdi,%rsi)
movl %r8d, %esi
incq %rdx
addq $0x10, %rcx
cmpq %rdx, (%rax)
ja 0x101ee
movslq %esi, %rcx
jmp 0x10236
xorl %ecx, %ecx
movq %rcx, (%rax)
incq %r15
cmpq %r15, (%r14)
ja 0x10141
cmpq $0x0, (%r14)
je 0x102aa
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x10(%r14), %r12
imulq $0x68, %r13, %rax
cmpl $0x0, (%r12,%rax)
js 0x102a0
addq %rax, %r12
decq %r15
movq %r15, %rcx
movq %rcx, %r15
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0xfdcf
leaq 0x1(%r15), %rcx
testl %eax, %eax
je 0x10269
movq %r14, %rdi
movq %r12, %rsi
callq 0xfce8
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0xfdcf
incq %r15
testl %eax, %eax
je 0x1028c
incq %r13
cmpq %r13, (%r14)
ja 0x10251
jmp 0x102ad
xorl %r15d, %r15d
cmpl $0x3, 0xcfbc(%rip)      # 0x1d270
jge 0x102c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xcd2c(%rip), %rax      # 0x1cff8
movq (%rax), %rdi
leaq 0x7932(%rip), %rsi      # 0x17c08
leaq 0x795f(%rip), %rdx      # 0x17c3c
movq %r15, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_g_rm_vext
int mag_g_rm_vext(mag_t *g, int min_len, int min_nsr)
{
	int i;
	kvec_t(magv_p) a = {0,0,0};

	for (i = 0; i < g->v.n; ++i) {
		magv_t *p = &g->v.a[i];
		if (p->len < 0 || (p->nei[0].n > 0 && p->nei[1].n > 0)) continue;
		if (p->len >= min_len || p->nsr >= min_nsr) continue;
		kv_push(magv_p, a, p);
	}
	ks_introsort(vlt1, a.n, a.a);
	for (i = 0; i < a.n; ++i) mag_v_del(g, a.a[i]);
	free(a.a);
	if (fm_verbose >= 3)
		fprintf(stderr, "[M::%s] removed %ld tips (min_len=%d, min_nsr=%d)\n", __func__, a.n, min_len, min_nsr);
	return a.n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rdi, %r15
cmpq $0x0, (%rdi)
movl %esi, (%rsp)
je 0x11670
xorl %r13d, %r13d
xorl %ebx, %ebx
xorl %edx, %edx
xorl %edi, %edi
xorl %r14d, %r14d
movl %r12d, 0x4(%rsp)
movq 0x10(%r15), %rbp
movl (%rbp,%r13), %ecx
testl %ecx, %ecx
js 0x11662
cmpq $0x0, 0x20(%rbp,%r13)
je 0x11615
cmpl %esi, %ecx
jge 0x11662
cmpq $0x0, 0x38(%rbp,%r13)
je 0x11619
jmp 0x11662
cmpl %esi, %ecx
jge 0x11662
cmpl %r12d, 0x4(%rbp,%r13)
jge 0x11662
cmpq %rdi, %r14
jne 0x11652
leaq (%rdi,%rdi), %r12
testq %rdi, %rdi
movl $0x2, %eax
cmoveq %rax, %r12
leaq (,%r12,8), %rsi
movq %rdx, %rdi
callq 0x21d0
movl (%rsp), %esi
movq %r12, %rdi
movl 0x4(%rsp), %r12d
jmp 0x11655
movq %rdx, %rax
addq %r13, %rbp
movq %rax, %rdx
movq %rbp, (%rax,%r14,8)
incq %r14
incq %rbx
addq $0x68, %r13
cmpq %rbx, (%r15)
ja 0x115f2
jmp 0x11675
xorl %r14d, %r14d
xorl %edx, %edx
movq %r14, %rdi
movq %rdx, %r13
movq %rdx, %rsi
callq 0x10791
testq %r14, %r14
je 0x1169f
xorl %ebx, %ebx
movq (%r13,%rbx,8), %rsi
movq %r15, %rdi
callq 0xfaf0
incq %rbx
cmpq %rbx, %r14
jne 0x1168a
movq %r13, %rdi
callq 0x2040
cmpl $0x3, 0xbbc2(%rip)      # 0x1d270
jge 0x116c2
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb92f(%rip), %rax      # 0x1cff8
movq (%rax), %rdi
leaq 0x6575(%rip), %rsi      # 0x17c48
leaq 0x65a1(%rip), %rdx      # 0x17c7b
movq %r14, %rcx
movl (%rsp), %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x2160
jmp 0x116b0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_g_rm_vint
int mag_g_rm_vint(mag_t *g, int min_len, int min_nsr, int min_ovlp)
{
	int i;
	kvec_t(magv_p) a = {0,0,0};

	for (i = 0; i < g->v.n; ++i) {
		magv_t *p = &g->v.a[i];
		if (p->len >= 0 && p->len < min_len && p->nsr < min_nsr)
			kv_push(magv_p, a, p);
	}
	ks_introsort(vlt1, a.n, a.a);
	for (i = 0; i < a.n; ++i) mag_v_transdel(g, a.a[i], min_ovlp);
	free(a.a);
	if (fm_verbose >= 3)
		fprintf(stderr, "[M::%s] removed %ld internal vertices (min_len=%d, min_nsr=%d)\n", __func__, a.n, min_len, min_nsr);
	return a.n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x10(%rsp)
movl %edx, %r13d
movq %rdi, %r12
cmpq $0x0, (%rdi)
movl %esi, 0xc(%rsp)
je 0x11787
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %eax, %eax
xorl %edi, %edi
xorl %r14d, %r14d
movl %r13d, 0x14(%rsp)
movq 0x10(%r12), %r15
movl (%r15,%rbx), %ecx
testl %ecx, %ecx
sets %dl
cmpl %esi, %ecx
setge %cl
orb %dl, %cl
jne 0x11778
cmpl %r13d, 0x4(%r15,%rbx)
jge 0x11778
cmpq %rdi, %r14
jne 0x1176e
leaq (%rdi,%rdi), %r13
testq %rdi, %rdi
movl $0x2, %ecx
cmoveq %rcx, %r13
leaq (,%r13,8), %rsi
movq %rax, %rdi
callq 0x21d0
movl 0xc(%rsp), %esi
movq %r13, %rdi
movl 0x14(%rsp), %r13d
addq %rbx, %r15
movq %r15, (%rax,%r14,8)
incq %r14
incq %rbp
addq $0x68, %rbx
cmpq %rbp, (%r12)
ja 0x1171f
jmp 0x1178c
xorl %r14d, %r14d
xorl %eax, %eax
movq %r14, %rdi
movq %rax, %rsi
movq %rax, %r15
callq 0x10791
testq %r14, %r14
movl 0x10(%rsp), %ebp
je 0x117bb
xorl %ebx, %ebx
movq (%r15,%rbx,8), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xfbbd
incq %rbx
cmpq %rbx, %r14
jne 0x117a5
movq %r15, %rdi
callq 0x2040
cmpl $0x3, 0xbaa6(%rip)      # 0x1d270
jge 0x117de
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb813(%rip), %rax      # 0x1cff8
movq (%rax), %rdi
leaq 0x649a(%rip), %rsi      # 0x17c89
leaq 0x64d3(%rip), %rdx      # 0x17cc9
movq %r14, %rcx
movl 0xc(%rsp), %r8d
movl %r13d, %r9d
xorl %eax, %eax
callq 0x2160
jmp 0x117cc
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_cal_rdist
double mag_cal_rdist(mag_t *g)
{
	magv_v *v = &g->v;
	int j;
	uint64_t *srt;
	double rdist = -1.;
	int64_t i, sum_n_all, sum_n, sum_l;

	srt = calloc(v->n, 8);
	for (i = 0, sum_n_all = 0; i < v->n; ++i) {
		srt[i] = (uint64_t)v->a[i].nsr<<32 | i;
		sum_n_all += v->a[i].nsr;
	}
	ks_introsort_uint64_t(v->n, srt);

	for (j = 0; j < 2; ++j) {
		sum_n = sum_l = 0;
		for (i = v->n - 1; i >= 0; --i) {
			const magv_t *p = &v->a[srt[i]<<32>>32];
			int tmp1, tmp2;
			tmp1 = tmp2 = 0;
			if (p->nei[0].n) ++tmp1, tmp2 += p->nei[0].a[0].y;
			if (p->nei[1].n) ++tmp1, tmp2 += p->nei[1].a[0].y;
			if (tmp1) tmp2 /= tmp1;
			if (rdist > 0.) {
				double A = (p->len - tmp1) / rdist - p->nsr * M_LN2;
				if (A < A_THRES) continue;
			}
			sum_n += p->nsr;
			sum_l += p->len - tmp1;
			if (sum_n >= sum_n_all * 0.5) break;
		}
		rdist = (double)sum_l / sum_n;
	}
	if (fm_verbose >= 3) {
		fprintf(stderr, "[M::%s] average read distance %.3f.\n", __func__, rdist);
		fprintf(stderr, "[M::%s] approximate genome size: %.0f (inaccurate!)\n", __func__, rdist * sum_n_all);
	}

	free(srt);
	return rdist;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %rbx
xorpd %xmm0, %xmm0
testq %r15, %r15
je 0x11b8d
movq 0x10(%r14), %rax
addq $0x4, %rax
xorl %ecx, %ecx
xorl %edx, %edx
movslq (%rax), %rsi
addq %rsi, %rcx
shlq $0x20, %rsi
orq %rdx, %rsi
movq %rsi, (%rbx,%rdx,8)
incq %rdx
addq $0x68, %rax
cmpq %rdx, %r15
jne 0x11b68
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe654
movsd 0x8(%rsp), %xmm1
xorpd %xmm5, %xmm5
movq (%r14), %rax
movsd 0x5ecd(%rip), %xmm0     # 0x17a80
mulsd %xmm1, %xmm0
decq %rax
movsd 0x5ec6(%rip), %xmm7     # 0x17a88
xorl %ecx, %ecx
movsd 0x5ec4(%rip), %xmm6     # 0x17a90
movsd 0x5ec4(%rip), %xmm2     # 0x17a98
movq %rax, %rdi
xorl %edx, %edx
xorl %esi, %esi
testq %rdi, %rdi
js 0x11c72
movq 0x10(%r14), %r10
movl (%rbx,%rdi,8), %r8d
imulq $0x68, %r8, %r11
leaq (%r10,%r11), %r8
xorl %r15d, %r15d
cmpq $0x0, 0x20(%r10,%r11)
setne %r15b
leal 0x1(%r15), %r9d
cmpq $0x0, 0x38(%r10,%r11)
cmovel %r15d, %r9d
ucomisd %xmm5, %xmm7
jbe 0x11c3e
movl (%r8), %r10d
subl %r9d, %r10d
xorps %xmm3, %xmm3
cvtsi2sd %r10d, %xmm3
divsd %xmm7, %xmm3
xorps %xmm4, %xmm4
cvtsi2sdl 0x4(%r8), %xmm4
mulsd %xmm6, %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
ja 0x11c63
movslq 0x4(%r8), %r10
addq %r10, %rdx
movslq (%r8), %r8
movl %r9d, %r9d
subq %r9, %r8
xorps %xmm3, %xmm3
cvtsi2sd %rdx, %xmm3
addq %r8, %rsi
ucomisd %xmm0, %xmm3
setae %r8b
jmp 0x11c66
xorl %r8d, %r8d
decq %rdi
testb %r8b, %r8b
je 0x11bdb
xorps %xmm7, %xmm7
cvtsi2sd %rsi, %xmm7
xorps %xmm3, %xmm3
cvtsi2sd %rdx, %xmm3
divsd %xmm3, %xmm7
leal 0x1(%rcx), %edx
testl %ecx, %ecx
movl %edx, %ecx
je 0x11bd4
movsd %xmm7, (%rsp)
cmpl $0x3, 0xb5d1(%rip)      # 0x1d270
jge 0x11cb8
movq %rbx, %rdi
callq 0x2040
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd (%rsp), %xmm0
callq 0x241e
jmp 0x11ca1
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_g_clean
void mag_g_clean(mag_t *g, const magopt_t *opt)
{
	int j;

	if (g->min_ovlp < opt->min_ovlp) g->min_ovlp = opt->min_ovlp;
	for (j = 2; j <= opt->min_ensr; ++j)
		mag_g_rm_vext(g, opt->min_elen, j);
	mag_g_merge(g, 0, opt->min_merge_len);
	mag_g_rm_edge(g, g->min_ovlp, opt->min_dratio1, opt->min_elen, opt->min_ensr);
	mag_g_merge(g, 1, opt->min_merge_len);
	for (j = 2; j <= opt->min_ensr; ++j)
		mag_g_rm_vext(g, opt->min_elen, j);
	mag_g_merge(g, 0, opt->min_merge_len);
	if ((opt->flag & MAG_F_AGGRESSIVE) || (opt->flag & MAG_F_POPOPEN)) mag_g_pop_open(g, opt->min_elen);
	if (!(opt->flag & MAG_F_NO_SIMPL)) mag_g_simplify_bubble(g, opt->max_bvtx, opt->max_bdist);
	mag_g_pop_simple(g, opt->max_bcov, opt->max_bfrac, opt->min_merge_len, opt->max_bdiff, opt->flag & MAG_F_AGGRESSIVE);
	mag_g_rm_vint(g, opt->min_elen, opt->min_insr, g->min_ovlp);
	mag_g_rm_edge(g, g->min_ovlp, opt->min_dratio1, opt->min_elen, opt->min_ensr);
	mag_g_merge(g, 1, opt->min_merge_len);
	mag_g_rm_vext(g, opt->min_elen, opt->min_ensr);
	mag_g_merge(g, 0, opt->min_merge_len);
	if ((opt->flag & MAG_F_AGGRESSIVE) || (opt->flag & MAG_F_POPOPEN)) mag_g_pop_open(g, opt->min_elen);
	mag_g_rm_vext(g, opt->min_elen, opt->min_ensr);
	mag_g_merge(g, 0, opt->min_merge_len);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
cmpl %eax, 0x1c(%rdi)
jge 0x11d3c
movl %eax, 0x1c(%rbx)
cmpl $0x2, 0xc(%r14)
jl 0x11d5e
movl $0x1, %ebp
incl %ebp
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x115c3
cmpl 0xc(%r14), %ebp
jl 0x11d48
movl 0x20(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10122
movl 0x1c(%rbx), %esi
cvtss2sd 0x2c(%r14), %xmm0
movl 0x8(%r14), %edx
movl 0xc(%r14), %ecx
movq %rbx, %rdi
callq 0x1180a
movl 0x20(%r14), %edx
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10122
cmpl $0x2, 0xc(%r14)
jl 0x11db8
incl %ebp
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x115c3
cmpl 0xc(%r14), %ebp
jl 0x11da2
movl 0x20(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10122
testb $0x60, (%r14)
je 0x11dd8
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x131b1
testb $-0x80, (%r14)
jne 0x11dee
movl 0x14(%r14), %edx
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0x1271b
movss 0x30(%r14), %xmm0
movss 0x34(%r14), %xmm1
movl 0x20(%r14), %esi
movl (%r14), %ecx
movl 0x18(%r14), %edx
andl $0x20, %ecx
movq %rbx, %rdi
callq 0x12c20
movl 0x8(%r14), %esi
movl 0x10(%r14), %edx
movl 0x1c(%rbx), %ecx
movq %rbx, %rdi
callq 0x116ed
movl 0x1c(%rbx), %esi
xorps %xmm0, %xmm0
cvtss2sd 0x2c(%r14), %xmm0
movl 0x8(%r14), %edx
movl 0xc(%r14), %ecx
movq %rbx, %rdi
callq 0x1180a
movl 0x20(%r14), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10122
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0x115c3
movl 0x20(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10122
testb $0x60, (%r14)
je 0x11e80
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x131b1
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0x115c3
movl 0x20(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x10122
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_v_trim_open
void mag_v_trim_open(mag_t *g, magv_t *v, int trim_len, int trim_depth)
{
	int i, j, tl[2];
	if (v->nei[0].n > 0 && v->nei[1].n > 0) return; // no open end; do nothing
	if (v->nei[0].n == 0 && v->nei[1].n == 0 && v->len < trim_len * 3) { // disconnected short vertex
		mag_v_del(g, v);
		return;
	}
	for (j = 0; j < 2; ++j) {
		ku128_v *r = &v->nei[!j];
		int max_ovlp = 0;
		for (i = 0; i < r->n; ++i)
			max_ovlp = max_ovlp > r->a[i].y? max_ovlp : r->a[i].y;
		tl[j] = v->len - max_ovlp < trim_len? v->len - max_ovlp : trim_len;
	}
	if (v->nei[0].n == 0) {
		for (i = 0; i < tl[0] && v->cov[i] - 33 < trim_depth; ++i);
		tl[0] = i;
		v->len -= i;
		memmove(v->seq, v->seq + tl[0], v->len);
		memmove(v->cov, v->cov + tl[0], v->len);
	}
	if (v->nei[1].n == 0) {
		for (i = v->len - 1; i >= v->len - tl[1] && v->cov[i] - 33 < trim_depth; --i);
		tl[1] = v->len - 1 - i;
		v->len -= tl[1];
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rsi, %rbx
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x11ec8
cmpq $0x0, 0x38(%rbx)
jne 0x11ff2
testq %rax, %rax
jne 0x11ee6
cmpq $0x0, 0x38(%rbx)
jne 0x11ee6
leal (%rdx,%rdx,2), %ecx
cmpl %ecx, (%rbx)
jge 0x11ee6
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xfaf0
leaq 0x20(%rbx), %rcx
movl (%rbx), %esi
xorl %edi, %edi
movl %edi, %r8d
xorq $0x1, %r8
leaq (%r8,%r8,2), %r10
movq (%rcx,%r10,8), %r8
movl $0x0, %r9d
testq %r8, %r8
je 0x11f2d
leaq (%rcx,%r10,8), %r9
movq 0x10(%r9), %r10
addq $0x8, %r10
xorl %r9d, %r9d
movslq %r9d, %r9
movq (%r10), %r11
cmpq %r9, %r11
cmovael %r11d, %r9d
addq $0x10, %r10
decq %r8
jne 0x11f17
movl %esi, %r8d
subl %r9d, %r8d
cmpl %edx, %r8d
cmovgel %edx, %r8d
movl %r8d, 0x8(%rsp,%rdi,4)
leaq 0x1(%rdi), %r8
testq %rdi, %rdi
movq %r8, %rdi
je 0x11eee
testq %rax, %rax
jne 0x11fa7
movl 0x8(%rsp), %ecx
testl %ecx, %ecx
jle 0x11f75
movq 0x58(%rbx), %rdx
xorl %eax, %eax
movsbl (%rdx,%rax), %esi
addl $-0x21, %esi
cmpl %ebp, %esi
jge 0x11f77
incq %rax
cmpq %rax, %rcx
jne 0x11f5e
movl %ecx, %eax
jmp 0x11f77
xorl %eax, %eax
movl %eax, 0x8(%rsp)
movslq (%rbx), %rdx
cltq
subq %rax, %rdx
movl %edx, (%rbx)
movq 0x50(%rbx), %rdi
movl %eax, %r14d
leaq (%rdi,%r14), %rsi
callq 0x2210
movq 0x58(%rbx), %rdi
addq %rdi, %r14
movslq (%rbx), %rdx
movq %r14, %rsi
callq 0x2210
cmpq $0x0, 0x38(%rbx)
jne 0x11ff2
movslq (%rbx), %rax
movslq 0xc(%rsp), %rcx
movq %rax, %rdx
subq %rcx, %rdx
cmpl %edx, %eax
movl %edx, %esi
cmovll %eax, %esi
leal 0x1(%rax), %ecx
movq %rax, %rdi
cmpq %rdx, %rdi
jle 0x11fe8
movq 0x58(%rbx), %r8
movsbl -0x1(%r8,%rdi), %r8d
decq %rdi
addl $-0x21, %r8d
decl %ecx
cmpl %ebp, %r8d
jl 0x11fc9
jmp 0x11fea
movl %esi, %ecx
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/mag.c
// Function: mag_g_trim_open
void mag_g_trim_open(mag_t *g, const magopt_t *opt)
{
	int i;
	if (opt->trim_len == 0) return;
	for (i = 0; i < g->v.n; ++i)
		mag_v_trim_open(g, &g->v.a[i], opt->trim_len, opt->trim_depth);
}

// Assembly:
cmpl $0x0, 0x24(%rsi)
je 0x12047
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x1203c
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%r14), %rsi
addq %r15, %rsi
movl 0x24(%rbx), %edx
movl 0x28(%rbx), %ecx
movq %r14, %rdi
callq 0x11ea2
incq %r12
addq $0x68, %r15
cmpq %r12, (%r14)
ja 0x1201b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/bubble.c
// Function: mag_b_destroyaux
void mag_b_destroyaux(mogb_aux_t *b)
{
	int i;
	for (i = 0; i < b->pool.m; ++i)
		free(b->pool.buf[i]);
	free(b->pool.buf); free(b->stack.a);
	kh_destroy(64, b->h);
	free(b);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x12092
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x12079
movq 0x8(%rbx), %rdi
callq 0x2040
movq 0x20(%rbx), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0xc86b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/bubble.c
// Function: backtrace
static void backtrace(mag_t *g, uint64_t end, uint64_t start, hash64_t *h)
{
	while (end>>32 != start) {
		int ret;
		kh_put(64, h, end>>33, &ret);
		end = tiptr(&g->v.a[end>>33])->v[(end>>32^1)&1][end&1];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
shrq $0x20, %r15
cmpq %rdx, %r15
je 0x1270c
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r12
movq %rbp, %r13
shrq $0x21, %r13
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x4(%rsp), %rdx
callq 0xcba8
movq 0x10(%r12), %rax
imulq $0x68, %r13, %rcx
notl %r15d
andl $0x1, %r15d
shll $0x4, %r15d
addq 0x60(%rax,%rcx), %r15
andl $0x1, %ebp
movq 0x30(%r15,%rbp,8), %rbp
movq %rbp, %r15
shrq $0x20, %r15
cmpq %r14, %r15
jne 0x126c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/bubble.c
// Function: mag_g_simplify_bubble
void mag_g_simplify_bubble(mag_t *g, int max_vtx, int max_dist)
{
	int64_t i;
	mogb_aux_t *a;
	a = mag_b_initaux();
	for (i = 0; i < g->v.n; ++i) {
		mag_vh_simplify_bubble(g, i<<1|0, max_vtx, max_dist, a);
		mag_vh_simplify_bubble(g, i<<1|1, max_vtx, max_dist, a);
	}
	mag_b_destroyaux(a);
	mag_g_merge(g, 0, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl $0x1, %r15d
movl $0x1, %edi
movl $0x30, %esi
callq 0x2130
movq %rax, %r12
callq 0xc85c
movq %rax, 0x28(%r12)
cmpq $0x0, (%rbx)
je 0x1278c
xorl %r13d, %r13d
leaq -0x1(%r15), %rsi
movq %rbx, %rdi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0x120bc
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0x120bc
incq %r13
addq $0x2, %r15
cmpq (%rbx), %r13
jb 0x12759
movq %r12, %rdi
callq 0x12069
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10122
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/bubble.c
// Function: mag_g_pop_simple
void mag_g_pop_simple(mag_t *g, float max_cov, float max_frac, int min_merge_len, int max_bdiff, int aggressive)
{
	int64_t i, n_examined = 0, n_popped = 0;
	int ret;

	for (i = 0; i < g->v.n; ++i) {
		ret = mag_vh_pop_simple(g, i<<1|0, max_cov, max_frac, max_bdiff, aggressive);
		if (ret >= 1) ++n_examined;
		if (ret >= 2) ++n_popped;
		ret = mag_vh_pop_simple(g, i<<1|1, max_cov, max_frac, max_bdiff, aggressive);
		if (ret >= 1) ++n_examined;
		if (ret >= 2) ++n_popped;
	}
	if (fm_verbose >= 3)
		fprintf(stderr, "[M::%s] examined %ld bubbles and popped %ld\n", __func__, (long)n_examined, (long)n_popped);
	mag_g_merge(g, 0, min_merge_len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, 0x14(%rsp)
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x12d02
movl $0x1, %r12d
xorl %eax, %eax
movl %ecx, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
xorl %edx, %edx
xorl %r13d, %r13d
movss %xmm1, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rbx, 0x20(%rsp)
movl 0x1c(%rsp), %ebp
movq %rdx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq -0x1(%r12), %rsi
movq %rbx, %rdi
movss 0xc(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movl 0x18(%rsp), %ebx
movl %ebx, %edx
movl %ebp, %ecx
callq 0x127ae
xorl %r14d, %r14d
testl %eax, %eax
setg %r14b
xorl %r15d, %r15d
cmpl $0x2, %eax
setge %r15b
movq 0x20(%rsp), %rdi
movq %r12, %rsi
movss 0xc(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movl %ebx, %edx
movl %ebp, %ecx
callq 0x127ae
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
addq 0x28(%rsp), %rcx
addq %r14, %rcx
movq 0x20(%rsp), %rbx
xorl %r8d, %r8d
cmpl $0x2, %eax
setge %r8b
addq 0x30(%rsp), %r8
addq %r15, %r8
incq %r13
addq $0x2, %r12
movq %r8, %rax
movq %rcx, %rdx
cmpq (%rbx), %r13
jb 0x12c69
jmp 0x12d07
xorl %ecx, %ecx
xorl %r8d, %r8d
leaq 0xa562(%rip), %rax      # 0x1d270
cmpl $0x3, (%rax)
jge 0x12d2f
movq %rbx, %rdi
xorl %esi, %esi
movl 0x14(%rsp), %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10122
movq 0xa2c2(%rip), %rax      # 0x1cff8
movq (%rax), %rdi
leaq 0x50c8(%rip), %rsi      # 0x17e08
leaq 0x50ee(%rip), %rdx      # 0x17e35
xorl %eax, %eax
callq 0x2160
jmp 0x12d13
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/bubble.c
// Function: mag_g_pop_open
void mag_g_pop_open(mag_t *g, int min_elen)
{
	int64_t i;
	for (i = 0; i < g->v.n; ++i)
		mag_v_pop_open(g, &g->v.a[i], min_elen);
	if (fm_verbose >= 3)
		fprintf(stderr, "[M:%s] popped open bubbles\n", __func__);
	mag_g_merge(g, 0, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x131e6
movl %esi, %ebp
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rsi
addq %r14, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x12d50
incq %r15
addq $0x68, %r14
cmpq (%rbx), %r15
jb 0x131c9
leaq 0xa083(%rip), %rax      # 0x1d270
cmpl $0x3, (%rax)
jge 0x13208
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10122
callq 0x247a
jmp 0x131f2
nop
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/kthread.c
// Function: kt_for
void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n)
{
	if (n_threads > 1) {
		int i;
		kt_for_t t;
		pthread_t *tid;
		t.func = func, t.data = data, t.n_threads = n_threads, t.n = n;
		t.w = (ktf_worker_t*)alloca(n_threads * sizeof(ktf_worker_t));
		tid = (pthread_t*)alloca(n_threads * sizeof(pthread_t));
		for (i = 0; i < n_threads; ++i)
			t.w[i].t = &t, t.w[i].i = i;
		for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktf_worker, &t.w[i]);
		for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
	} else {
		long j;
		for (j = 0; j < n; ++j) func(data, j, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
cmpl $0x1, %edi
jle 0x1403b
leaq -0x58(%rbp), %rax
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movl %edi, (%rax)
movq %r14, 0x8(%rax)
movl %edi, -0x2c(%rbp)
movl %edi, %ecx
movq %rcx, %r13
shlq $0x4, %r13
movq %rsp, %rdx
movq %rdx, %rsi
subq %r13, %rsi
movq %rsi, %rsp
movq %rsi, 0x10(%rax)
movq %rsp, %r12
leaq 0xf(,%rcx,8), %rsi
andq $-0x10, %rsi
subq %rsi, %r12
movq %r12, %rsp
movq %r13, %rsi
negq %rsi
addq %rsi, %rdx
addq $0x8, %rdx
xorl %esi, %esi
movq %rax, -0x8(%rdx)
movq %rsi, (%rdx)
incq %rsi
addq $0x10, %rdx
cmpq %rsi, %rcx
jne 0x13fd5
xorl %ebx, %ebx
leaq 0x73(%rip), %r14        # 0x14064
movq %r12, %r15
movq -0x48(%rbp), %rcx
addq %rbx, %rcx
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2200
addq $0x10, %rbx
addq $0x8, %r15
cmpq %rbx, %r13
jne 0x13ff4
movl -0x2c(%rbp), %eax
cmpl $0x2, %eax
movl $0x1, %ebx
cmovgel %eax, %ebx
xorl %r14d, %r14d
movq (%r12,%r14,8), %rdi
xorl %esi, %esi
callq 0x2280
incq %r14
cmpq %r14, %rbx
jne 0x14026
jmp 0x14055
testq %r14, %r14
jle 0x14055
xorl %ebx, %ebx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *%r12
incq %rbx
cmpq %rbx, %r14
jne 0x14042
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_init
bfc_ch_t *bfc_ch_init(int k, int l_pre)
{
	bfc_ch_t *ch;
	int i;
	assert(k <= 63);
	if (k * 2 - l_pre > BFC_CH_KEYBITS)
		l_pre = k * 2 - BFC_CH_KEYBITS;
	if (l_pre > BFC_CH_MAXPRE) l_pre = BFC_CH_MAXPRE;
	assert(k - l_pre < BFC_CH_KEYBITS);
	ch = calloc(1, sizeof(bfc_ch_t));
	ch->k = k, ch->l_pre = l_pre;
	ch->h = calloc(1<<ch->l_pre, sizeof(void*));
	for (i = 0; i < 1<<ch->l_pre; ++i)
		ch->h[i] = kh_init(cnt);
	return ch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x40, %edi
jge 0x141ca
movl %edi, %r14d
leal (%r14,%r14), %eax
subl %esi, %eax
cmpl $0x33, %eax
leal -0x32(%r14,%r14), %eax
cmovll %esi, %eax
cmpl $0x14, %eax
movl $0x14, %ebp
cmovll %eax, %ebp
movl %edi, %eax
subl %ebp, %eax
cmpl $0x32, %eax
jge 0x141e9
movl $0x1, %edi
movl $0x18, %esi
callq 0x2130
movq %rax, %rbx
movl %r14d, (%rax)
movl %ebp, 0x10(%rax)
movl $0x1, %r14d
movl %ebp, %ecx
shll %cl, %r14d
movl $0x8, %esi
movq %r14, %rdi
callq 0x2130
movq %rax, %r15
movq %rax, 0x8(%rbx)
xorl %r12d, %r12d
movl $0x1, %edi
movl $0x28, %esi
callq 0x2130
movq %rax, (%r15,%r12,8)
incq %r12
cmpq %r12, %r14
jne 0x141a3
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cbf(%rip), %rdi      # 0x17e90
leaq 0x3cc0(%rip), %rsi      # 0x17e98
leaq 0x3cc0(%rip), %rcx      # 0x17e9f
movl $0x17, %edx
callq 0x20e0
leaq 0x3ccf(%rip), %rdi      # 0x17ebf
leaq 0x3ca1(%rip), %rsi      # 0x17e98
leaq 0x3ca1(%rip), %rcx      # 0x17e9f
movl $0x1b, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_destroy
void bfc_ch_destroy(bfc_ch_t *ch)
{
	int i;
	if (ch == 0) return;
	for (i = 0; i < 1<<ch->l_pre; ++i)
		kh_destroy(cnt, ch->h[i]);
	free(ch->h); free(ch);
}

// Assembly:
testq %rdi, %rdi
je 0x14278
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1f, 0x10(%rdi)
je 0x14262
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x1424e
movq 0x18(%r14), %rdi
callq 0x2040
movq 0x10(%r14), %rdi
callq 0x2040
movq 0x20(%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
movb 0x10(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
incq %r15
cltq
cmpq %rax, %r15
jl 0x1421e
movq 0x8(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_get
static inline cnthash_t *get_subhash(const bfc_ch_t *ch, const uint64_t x[2], uint64_t *key)
{
	if (ch->k <= 32) {
		int t = ch->k * 2 - ch->l_pre;
		uint64_t z = x[0] << ch->k | x[1];
		*key = (z & ((1ULL<<t) - 1)) << 14 | 1;
		return ch->h[z>>t];
	} else {
		int t = ch->k - ch->l_pre;
		int shift = t + ch->k < BFC_CH_KEYBITS? ch->k : BFC_CH_KEYBITS - t;
		*key = ((x[0] & ((1ULL<<t) - 1)) << shift ^ x[1]) << 14 | 1;
		return ch->h[x[0]>>t];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq (%rdi), %rax
cmpq $0x20, %rax
jg 0x14541
leal (%rax,%rax), %edx
subl 0x10(%rdi), %edx
movq (%rsi), %r9
movl %eax, %ecx
shlq %cl, %r9
movq $-0x1, %r8
movl %edx, %ecx
shlq %cl, %r8
orq 0x8(%rsi), %r9
notq %r8
andq %r9, %r8
jmp 0x14579
movl %eax, %edx
subl 0x10(%rdi), %edx
leal (%rdx,%rax), %r10d
movb $0x32, %r11b
movq $-0x1, %r8
movl %edx, %ecx
shlq %cl, %r8
subb %dl, %r11b
movq (%rsi), %r9
notq %r8
andq %r9, %r8
cmpl $0x32, %r10d
movzbl %r11b, %ecx
cmovll %eax, %ecx
shlq %cl, %r8
xorq 0x8(%rsi), %r8
movl %edx, %ecx
shrq %cl, %r9
shlq $0x3, %r9
addq 0x8(%rdi), %r9
movq (%r9), %rdx
movl (%rdx), %esi
testl %esi, %esi
je 0x145fd
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %r8, %rax
leal -0x1(%rsi), %r9d
andl %r9d, %r8d
movq 0x10(%rdx), %r10
movl $0x1, %r11d
movl %r8d, %edi
movl %edi, %ecx
shrl $0x4, %ecx
movl (%r10,%rcx,4), %ebx
leal (%rdi,%rdi), %ecx
andl $0x1e, %ecx
movl %ebx, %ebp
shrl %cl, %ebp
testb $0x2, %bpl
jne 0x145f3
testb $0x1, %bpl
jne 0x145e1
movq 0x18(%rdx), %r14
movl %edi, %r15d
movq (%r14,%r15,8), %r14
shrq $0xe, %r14
cmpq %rax, %r14
je 0x145f3
addl %r11d, %edi
andl %r9d, %edi
incl %r11d
cmpl %r8d, %edi
jne 0x145ae
movl %esi, %edi
jmp 0x145ff
shrl %cl, %ebx
testb $0x3, %bl
cmovnel %esi, %edi
jmp 0x145ff
xorl %edi, %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, %edi
je 0x14616
movq 0x18(%rdx), %rcx
movl %edi, %edx
movl $0x3fff, %eax           # imm = 0x3FFF
andl (%rcx,%rdx,8), %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_count
uint64_t bfc_ch_count(const bfc_ch_t *ch)
{
	int i;
	uint64_t cnt = 0;
	for (i = 0; i < 1<<ch->l_pre; ++i)
		cnt += kh_size(ch->h[i]);
	return cnt;
}

// Assembly:
movl 0x10(%rdi), %ecx
cmpl $0x1f, %ecx
jne 0x1472f
xorl %eax, %eax
retq
movl $0x1, %edx
shll %cl, %edx
movl $0x1, %eax
movq 0x8(%rdi), %rcx
cmpl $0x2, %edx
cmovll %eax, %edx
xorl %esi, %esi
xorl %eax, %eax
movq (%rcx,%rsi,8), %rdi
movl 0x4(%rdi), %edi
addq %rdi, %rax
incq %rsi
cmpq %rsi, %rdx
jne 0x14749
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_hist
int bfc_ch_hist(const bfc_ch_t *ch, uint64_t cnt[256], uint64_t high[64])
{
	int i, max_i = -1;
	uint64_t max;
	memset(cnt, 0, 256 * 8);
	memset(high, 0, 64 * 8);
	for (i = 0; i < 1<<ch->l_pre; ++i) {
		khint_t k;
		cnthash_t *h = ch->h[i];
		for (k = 0; k != kh_end(h); ++k)
			if (kh_exist(h, k))
				++cnt[kh_key(h, k) & 0xff], ++high[kh_key(h, k)>>8 & 0x3f];
	}
	for (i = 3, max = 0; i < 256; ++i)
		if (cnt[i] > max)
			max = cnt[i], max_i = i;
	return max_i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl $0x800, %edx            # imm = 0x800
movq %rsi, %rdi
xorl %esi, %esi
callq 0x2100
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
xorl %esi, %esi
callq 0x2100
movl 0x10(%r15), %ecx
cmpl $0x1f, %ecx
je 0x1480b
movl $0x1, %esi
movl $0x1, %eax
shll %cl, %eax
movq 0x8(%r15), %rdx
cmpl $0x2, %eax
cmovll %esi, %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movl (%rdi), %r8d
testq %r8, %r8
je 0x14803
movq 0x10(%rdi), %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
movl %r11d, %ecx
shrl $0x4, %ecx
movl (%r9,%rcx,4), %ebp
movl %r10d, %ecx
andb $0x1e, %cl
shrl %cl, %ebp
testb $0x3, %bpl
jne 0x147f7
movq 0x18(%rdi), %rcx
movzbl (%rcx,%r11,8), %r15d
incq (%rbx,%r15,8)
movl (%rcx,%r11,8), %ecx
shrl $0x5, %ecx
andl $0x1f8, %ecx            # imm = 0x1F8
incq (%r14,%rcx)
incq %r11
addl $0x2, %r10d
cmpq %r11, %r8
jne 0x147c1
incq %rsi
cmpq %rax, %rsi
jne 0x147ab
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x3, %ecx
xorl %edx, %edx
movq (%rbx,%rcx,8), %rsi
cmpq %rdx, %rsi
cmoval %ecx, %eax
cmovaq %rsi, %rdx
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x14817
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq