LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x468c
movl (%r14), %edi
movq 0x58(%r14), %rsi
callq 0x4662
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 0xce10
movl (%rbx), %ebp
cmpl %ebp, %eax
je 0x1038b
movq 0x20(%rbx), %r15
movl %eax, %eax
xorq $0x1, (%r15,%rax,8)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xce10
cmpl %ebp, %eax
je 0x103aa
movl %eax, %eax
xorb $0x1, (%r15,%rax,8)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x702d(%rip), %rdi      # 0x173bf
leaq 0x77d2(%rip), %rsi      # 0x17b6b
leaq 0x77d1(%rip), %rcx      # 0x17b71
movl $0x12b, %edx            # imm = 0x12B
callq 0x20e0
leaq 0x700e(%rip), %rdi      # 0x173bf
leaq 0x77b3(%rip), %rsi      # 0x17b6b
leaq 0x77b2(%rip), %rcx      # 0x17b71
movl $0x12e, %edx            # imm = 0x12E
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O3/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
cmpq $0x0, (%rdi)
je 0x108a6
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
imulq $0x68, %r15, %r12
movq 0x10(%r14), %rax
leaq (%rax,%r12), %rdi
addq $0x20, %rdi
testl %ebp, %ebp
je 0x10771
callq 0xf257
movq 0x10(%r14), %rax
leaq (%rax,%r12), %rdi
addq $0x38, %rdi
callq 0xf257
jmp 0x10830
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x107cc
xorl %eax, %eax
xorl %edx, %edx
xorl %esi, %esi
movq 0x10(%rdi), %r8
cmpq $-0x2, (%r8,%rax)
je 0x107b7
cmpq $0x0, 0x8(%r8,%rax)
je 0x107b7
movl %esi, %r10d
leal 0x1(%rsi), %r9d
cmpq %r10, %rdx
je 0x107b4
leaq (%r8,%rax), %rcx
movslq %esi, %rsi
shlq $0x4, %rsi
movups (%rcx), %xmm0
movups %xmm0, (%r8,%rsi)
movq (%rdi), %rcx
movl %r9d, %esi
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
ja 0x1077f
movslq %esi, %rcx
movq 0x10(%r14), %rax
jmp 0x107ce
xorl %ecx, %ecx
movq %rcx, (%rdi)
addq %r12, %rax
addq $0x38, %rax
movq (%rax), %rdx
xorl %ecx, %ecx
testq %rdx, %rdx
je 0x1082d
xorl %esi, %esi
xorl %edi, %edi
movq 0x10(%rax), %r8
cmpq $-0x2, (%r8,%rcx)
je 0x1081e
cmpq $0x0, 0x8(%r8,%rcx)
je 0x1081e
movl %edi, %r10d
leal 0x1(%rdi), %r9d
cmpq %r10, %rsi
je 0x1081b
leaq (%r8,%rcx), %rdx
movslq %edi, %rdi
shlq $0x4, %rdi
movups (%rdx), %xmm0
movups %xmm0, (%r8,%rdi)
movq (%rax), %rdx
movl %r9d, %edi
incq %rsi
addq $0x10, %rcx
cmpq %rsi, %rdx
ja 0x107e6
movslq %edi, %rcx
movq %rcx, (%rax)
incq %r15
movq (%r14), %rax
cmpq %r15, %rax
ja 0x10742
testq %rax, %rax
je 0x108a6
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x10(%r14), %r12
imulq $0x68, %r13, %rcx
cmpl $0x0, (%r12,%rcx)
js 0x1089c
addq %rcx, %r12
decq %r15
movq %r15, %rcx
movq %rcx, %r15
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x103c9
leaq 0x1(%r15), %rcx
testl %eax, %eax
je 0x10862
movq %r14, %rdi
movq %r12, %rsi
callq 0x102e2
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x103c9
incq %r15
testl %eax, %eax
je 0x10885
movq (%r14), %rax
incq %r13
cmpq %r13, %rax
ja 0x1084a
jmp 0x108a9
xorl %r15d, %r15d
cmpl $0x3, 0xc9c0(%rip)      # 0x1d270
jge 0x108c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc730(%rip), %rax      # 0x1cff8
movq (%rax), %rdi
leaq 0x73c6(%rip), %rsi      # 0x17c98
leaq 0x73f3(%rip), %rdx      # 0x17ccc
movq %r15, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movq %rdi, %r12
movq (%rdi), %rdi
testq %rdi, %rdi
movl %esi, (%rsp)
je 0x11cc4
xorl %r13d, %r13d
xorl %ebx, %ebx
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %r14d, %r14d
movl %r15d, 0x4(%rsp)
movq 0x10(%r12), %rbp
movl (%rbp,%r13), %edx
testl %edx, %edx
js 0x11c88
cmpq $0x0, 0x20(%rbp,%r13)
je 0x11c37
cmpl %esi, %edx
jge 0x11c88
cmpq $0x0, 0x38(%rbp,%r13)
je 0x11c3b
jmp 0x11c88
cmpl %esi, %edx
jge 0x11c88
cmpl %r15d, 0x4(%rbp,%r13)
jge 0x11c88
cmpq %rcx, %r14
jne 0x11c78
leaq (%rcx,%rcx), %r15
testq %rcx, %rcx
movl $0x2, %eax
cmoveq %rax, %r15
leaq (,%r15,8), %rsi
movq %r8, %rdi
callq 0x21c0
movl (%rsp), %esi
movq (%r12), %rdi
movq %r15, %rcx
movl 0x4(%rsp), %r15d
jmp 0x11c7b
movq %r8, %rax
addq %r13, %rbp
movq %rax, %r8
movq %rbp, (%rax,%r14,8)
incq %r14
incq %rbx
addq $0x68, %r13
cmpq %rbx, %rdi
ja 0x11c13
movq %r14, %rdi
movq %r8, %r13
movq %r8, %rsi
callq 0x10d90
testq %r14, %r14
je 0x11cd0
xorl %ebx, %ebx
movq (%r13,%rbx,8), %rsi
movq %r12, %rdi
callq 0x100b2
incq %rbx
cmpq %rbx, %r14
jne 0x11cad
jmp 0x11cd3
xorl %r13d, %r13d
xorl %edi, %edi
xorl %esi, %esi
callq 0x10d90
xorl %r14d, %r14d
movq %r13, %rdi
callq 0x2040
cmpl $0x3, 0xb58e(%rip)      # 0x1d270
jge 0x11cf6
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb2fb(%rip), %rax      # 0x1cff8
movq (%rax), %rdi
leaq 0x5fd1(%rip), %rsi      # 0x17cd8
leaq 0x5ffd(%rip), %rdx      # 0x17d0b
movq %r14, %rcx
movl (%rsp), %r8d
movl %r15d, %r9d
xorl %eax, %eax
callq 0x2150
jmp 0x11ce4
// File: /workspace/github_c_makefile_star2_O3/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 %edx, %r15d
movq (%rdi), %r9
testq %r9, %r9
movl %esi, 0xc(%rsp)
je 0x11dfe
movq %rdi, %r13
movl %ecx, 0x10(%rsp)
xorl %ebx, %ebx
xorl %r12d, %r12d
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %r14d, %r14d
movl %r15d, 0x14(%rsp)
movq 0x10(%r13), %rbp
movl (%rbp,%rbx), %edx
testl %edx, %edx
sets %dil
cmpl %esi, %edx
setge %dl
orb %dil, %dl
jne 0x11dc1
cmpl %r15d, 0x4(%rbp,%rbx)
jge 0x11dc1
cmpq %rcx, %r14
jne 0x11db1
leaq (%rcx,%rcx), %r15
testq %rcx, %rcx
movl $0x2, %eax
cmoveq %rax, %r15
leaq (,%r15,8), %rsi
movq %r8, %rdi
callq 0x21c0
movl 0xc(%rsp), %esi
movq (%r13), %r9
movq %r15, %rcx
movl 0x14(%rsp), %r15d
jmp 0x11db4
movq %r8, %rax
addq %rbx, %rbp
movq %rax, %r8
movq %rbp, (%rax,%r14,8)
incq %r14
incq %r12
addq $0x68, %rbx
cmpq %r12, %r9
ja 0x11d5b
movq %r14, %rdi
movq %r8, %r12
movq %r8, %rsi
callq 0x10d90
testq %r14, %r14
je 0x11e0a
xorl %ebx, %ebx
movl 0x10(%rsp), %ebp
movq (%r12,%rbx,8), %rsi
movq %r13, %rdi
movl %ebp, %edx
callq 0x101b4
incq %rbx
cmpq %rbx, %r14
jne 0x11de6
jmp 0x11e0d
xorl %r12d, %r12d
xorl %edi, %edi
xorl %esi, %esi
callq 0x10d90
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x2040
cmpl $0x3, 0xb454(%rip)      # 0x1d270
jge 0x11e30
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb1c1(%rip), %rax      # 0x1cff8
movq (%rax), %rdi
leaq 0x5ed8(%rip), %rsi      # 0x17d19
leaq 0x5f11(%rip), %rdx      # 0x17d59
movq %r14, %rcx
movl 0xc(%rsp), %r8d
movl %r15d, %r9d
xorl %eax, %eax
callq 0x2150
jmp 0x11e1e
// File: /workspace/github_c_makefile_star2_O3/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 0x121f5
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 0x121d0
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xebb8
movsd 0x8(%rsp), %xmm1
xorpd %xmm5, %xmm5
movq (%r14), %rax
movsd 0x58f5(%rip), %xmm0     # 0x17b10
mulsd %xmm1, %xmm0
movsd 0x58f1(%rip), %xmm7     # 0x17b18
movb $0x1, %cl
movsd 0x58ef(%rip), %xmm6     # 0x17b20
movsd 0x58ef(%rip), %xmm2     # 0x17b28
movq %rax, %rdi
xorl %edx, %edx
xorl %esi, %esi
decq %rdi
movq %rdi, %r10
testq %r10, %r10
js 0x122dd
movq %r10, %rdi
movq 0x10(%r14), %r8
movl (%rbx,%r10,8), %r9d
imulq $0x68, %r9, %r11
leaq (%r8,%r11), %r9
xorl %r15d, %r15d
cmpq $0x0, 0x20(%r8,%r11)
setne %r15b
leal 0x1(%r15), %r10d
cmpq $0x0, 0x38(%r8,%r11)
cmovel %r15d, %r10d
ucomisd %xmm5, %xmm7
jbe 0x122b5
movl (%r9), %r8d
movl 0x4(%r9), %r9d
subl %r10d, %r8d
xorps %xmm3, %xmm3
cvtsi2sd %r8d, %xmm3
divsd %xmm7, %xmm3
xorps %xmm4, %xmm4
cvtsi2sd %r9d, %xmm4
mulsd %xmm6, %xmm4
addsd %xmm3, %xmm4
leaq -0x1(%rdi), %r10
ucomisd %xmm4, %xmm2
ja 0x12246
jmp 0x122bf
movl (%r9), %r8d
movl 0x4(%r9), %r9d
subl %r10d, %r8d
movslq %r9d, %r9
addq %r9, %rdx
movslq %r8d, %r8
addq %r8, %rsi
xorps %xmm3, %xmm3
cvtsi2sd %rdx, %xmm3
ucomisd %xmm0, %xmm3
jb 0x12240
xorps %xmm7, %xmm7
cvtsi2sd %rsi, %xmm7
xorps %xmm3, %xmm3
cvtsi2sd %rdx, %xmm3
divsd %xmm3, %xmm7
testb $0x1, %cl
movl $0x0, %ecx
jne 0x12239
movsd %xmm7, (%rsp)
cmpl $0x3, 0xaf65(%rip)      # 0x1d270
jge 0x12324
movq %rbx, %rdi
callq 0x2040
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd (%rsp), %xmm0
callq 0x240e
jmp 0x1230d
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rsi, %rbx
movq 0x20(%rsi), %rcx
movq 0x38(%rsi), %rsi
testq %rcx, %rcx
je 0x12527
testq %rsi, %rsi
jne 0x12651
movl (%rbx), %eax
jmp 0x12549
movl (%rbx), %eax
testq %rsi, %rsi
jne 0x1254b
leal (%rdx,%rdx,2), %esi
cmpl %esi, %eax
jge 0x12549
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x100b2
xorl %esi, %esi
leaq 0x20(%rbx), %rdi
movl $0x1, %r11d
leaq 0xc(%rsp), %r10
movb $0x1, %r9b
leaq 0x8(%rsp), %r8
leaq (%r11,%r11,2), %r14
movq (%rdi,%r14,8), %r11
testq %r11, %r11
je 0x12596
leaq (%rdi,%r14,8), %r14
movq 0x10(%r14), %r15
addq $0x8, %r15
xorl %r14d, %r14d
movslq %r14d, %r14
movq (%r15), %r12
cmpq %r14, %r12
cmovael %r12d, %r14d
addq $0x10, %r15
decq %r11
jne 0x1257e
jmp 0x12599
xorl %r14d, %r14d
movl %eax, %r11d
subl %r14d, %r11d
cmpl %edx, %r11d
cmovgel %edx, %r11d
movl %r11d, (%r10)
xorl %r11d, %r11d
movq %r8, %r10
testb $0x1, %r9b
movl $0x0, %r9d
jne 0x12562
testq %rcx, %rcx
jne 0x12614
movl 0xc(%rsp), %edx
testl %edx, %edx
jle 0x125e5
movq 0x58(%rbx), %rsi
xorl %ecx, %ecx
movsbl (%rsi,%rcx), %edi
addl $-0x21, %edi
cmpl %ebp, %edi
jge 0x125e7
incq %rcx
cmpq %rcx, %rdx
jne 0x125ce
movl %edx, %ecx
jmp 0x125e7
xorl %ecx, %ecx
subl %ecx, %eax
movl %eax, (%rbx)
movq 0x50(%rbx), %rdi
movl %ecx, %r14d
leaq (%rdi,%r14), %rsi
movslq %eax, %rdx
callq 0x2200
movq 0x58(%rbx), %rdi
addq %rdi, %r14
movslq (%rbx), %rdx
movq %r14, %rsi
callq 0x2200
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
jne 0x12651
movslq (%rbx), %rax
movslq 0x8(%rsp), %rdx
movq %rax, %rcx
subq %rdx, %rcx
cmpl %ecx, %eax
movl %ecx, %edx
cmovll %eax, %edx
leal 0x1(%rax), %esi
cmpq %rcx, %rax
jle 0x1264d
movq 0x58(%rbx), %rdi
movsbl -0x1(%rdi,%rax), %edi
decq %rax
addl $-0x21, %edi
decl %esi
cmpl %ebp, %edi
jl 0x12631
jmp 0x1264f
movl %edx, %esi
movl %esi, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x126aa
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x1269f
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 0x124fc
incq %r12
addq $0x68, %r15
cmpq %r12, (%r14)
ja 0x1267e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x126f6
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x126dd
movq 0x8(%rbx), %rdi
callq 0x2040
movq 0x20(%rbx), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0xcda7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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 0x12d6d
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 0xd0dd
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 0x12d29
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcd98
movq %rax, 0x28(%r12)
cmpq $0x0, (%rbx)
je 0x12ded
xorl %r13d, %r13d
leaq -0x1(%r15), %rsi
movq %rbx, %rdi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0x12720
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0x12720
incq %r13
addq $0x2, %r15
cmpq (%rbx), %r13
jb 0x12dba
movq %r12, %rdi
callq 0x126cd
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 0x10723
// File: /workspace/github_c_makefile_star2_O3/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 0x133f8
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 0x12e0f
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 0x12e0f
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 0x1335f
jmp 0x133fd
xorl %ecx, %ecx
xorl %r8d, %r8d
leaq 0x9e6c(%rip), %rax      # 0x1d270
cmpl $0x3, (%rax)
jge 0x13425
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 0x10723
movq 0x9bcc(%rip), %rax      # 0x1cff8
movq (%rax), %rdi
leaq 0x4a9a(%rip), %rsi      # 0x17ed0
leaq 0x4ac0(%rip), %rdx      # 0x17efd
xorl %eax, %eax
callq 0x2150
jmp 0x13409
// File: /workspace/github_c_makefile_star2_O3/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 0x138e7
movl %esi, %ebp
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rsi
addq %r14, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x13446
incq %r15
addq $0x68, %r14
cmpq (%rbx), %r15
jb 0x138ca
leaq 0x9982(%rip), %rax      # 0x1d270
cmpl $0x3, (%rax)
jge 0x13909
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10723
callq 0x246a
jmp 0x138f3
// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
cmpl $0x1, %edi
jle 0x1474b
leaq -0x50(%rbp), %rax
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movl %edi, (%rax)
movq %rbx, 0x8(%rax)
movl %edi, %r15d
movq %r15, %r13
shlq $0x4, %r13
movq %rsp, %rcx
movq %rcx, %rdx
subq %r13, %rdx
movq %rdx, %rsp
movq %rdx, 0x10(%rax)
movq %rsp, %r12
leaq 0xf(,%r15,8), %rdx
andq $-0x10, %rdx
subq %rdx, %r12
movq %r12, %rsp
movq %r13, %rdx
negq %rdx
addq %rdx, %rcx
addq $0x8, %rcx
xorl %edx, %edx
movq %rax, -0x8(%rcx)
movq %rdx, (%rcx)
incq %rdx
addq $0x10, %rcx
cmpq %rdx, %r15
jne 0x146f7
xorl %ebx, %ebx
movq %r12, %r14
movq -0x40(%rbp), %rcx
addq %rbx, %rcx
movq %r14, %rdi
xorl %esi, %esi
leaq 0x53(%rip), %rdx        # 0x14775
callq 0x21f0
addq $0x10, %rbx
addq $0x8, %r14
cmpq %rbx, %r13
jne 0x1470f
xorl %ebx, %ebx
movq (%r12,%rbx,8), %rdi
xorl %esi, %esi
callq 0x2270
incq %rbx
cmpq %rbx, %r15
jne 0x14736
jmp 0x14766
testq %rbx, %rbx
jle 0x14766
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *%r15
incq %r12
cmpq %r12, %rbx
jne 0x14753
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x148de
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 0x148fd
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 0x148b7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3673(%rip), %rdi      # 0x17f58
leaq 0x3674(%rip), %rsi      # 0x17f60
leaq 0x3674(%rip), %rcx      # 0x17f67
movl $0x17, %edx
callq 0x20e0
leaq 0x3683(%rip), %rdi      # 0x17f87
leaq 0x3655(%rip), %rsi      # 0x17f60
leaq 0x3655(%rip), %rcx      # 0x17f67
movl $0x1b, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O3/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 0x1498e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
cmpl $0x1f, %ecx
je 0x14978
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x14967
movq 0x18(%r14), %rdi
callq 0x2040
movq 0x10(%r14), %rdi
callq 0x2040
movq 0x20(%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
movl 0x10(%rbx), %ecx
movl $0x1, %eax
shll %cl, %eax
incq %r15
cltq
cmpq %rax, %r15
jl 0x14934
movq 0x8(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14c5b
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 0x14c93
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 0x14d1a
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 0x14d10
testb $0x1, %bpl
jne 0x14cfb
movq 0x18(%rdx), %r14
movl %edi, %r15d
movq (%r14,%r15,8), %r14
shrq $0xe, %r14
cmpq %rax, %r14
je 0x14d10
addl %r11d, %edi
andl %r9d, %edi
incl %r11d
cmpl %r8d, %edi
jne 0x14cc8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x14d33
shrl %cl, %ebx
testb $0x3, %bl
cmovnel %esi, %edi
jmp 0x14d1c
xorl %edi, %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, %edi
je 0x14d33
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_O3/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
cmpq $0x1f, %rcx
jne 0x14e4d
xorl %eax, %eax
retq
movl $0x1, %edx
shlq %cl, %rdx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
xorl %eax, %eax
movq (%rcx,%rsi,8), %rdi
movl 0x4(%rdi), %edi
addq %rdi, %rax
incq %rsi
cmpq %rsi, %rdx
jne 0x14e5d
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpq $0x1f, %rcx
je 0x14f16
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%r15), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movl (%rdi), %r8d
testq %r8, %r8
je 0x14f0e
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 0x14f02
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 0x14ecc
incq %rsi
cmpq %rax, %rsi
jne 0x14eb6
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 0x14f22
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi-lite/rope.c
// Function: rope_init
rope_t *rope_init(int max_nodes, int block_len)
{
	rope_t *rope;
	rope = calloc(1, sizeof(rope_t));
	if (block_len < 32) block_len = 32;
	rope->max_nodes = (max_nodes+ 1)>>1<<1;
	rope->block_len = (block_len + 7) >> 3 << 3;
	rope->node = mp_init(sizeof(rpnode_t) * rope->max_nodes);
	rope->leaf = mp_init(rope->block_len);
	rope->root = mp_alloc(rope->node);
	rope->root->n = 1;
	rope->root->is_bottom = 1;
	rope->root->p = mp_alloc(rope->leaf);
	return rope;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %ebp
movl $0x1, %r13d
movl $0x1, %edi
movl $0x50, %esi
callq 0x2130
cmpl $0x21, %ebx
movl $0x20, %r14d
cmovgel %ebx, %r14d
movq %rax, %rbx
incl %ebp
andl $-0x2, %ebp
movl %ebp, (%rax)
addl $0x7, %r14d
andl $0x7ffffff8, %r14d      # imm = 0x7FFFFFF8
movl %r14d, 0x4(%rax)
shll $0x6, %ebp
movl $0x1, %edi
movl $0x28, %esi
callq 0x2130
movq %rax, %r12
movl %ebp, (%rax)
movl $0x100000, %eax         # imm = 0x100000
xorl %edx, %edx
idivl %ebp
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%r12)
movq %r12, 0x40(%rbx)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2130
movq %rax, %r15
movl %r14d, (%rax)
movl $0x100000, %eax         # imm = 0x100000
xorl %edx, %edx
divl %r14d
movq %rax, 0x10(%rsp)
movl %eax, 0x8(%r15)
movq %r15, 0x48(%rbx)
movq %r13, 0x18(%r12)
movl $0x8, %edi
callq 0x21a0
movq %rax, %r13
movq %rax, 0x20(%r12)
movslq 0xc(%rsp), %rdi
movslq %ebp, %rsi
callq 0x2130
movq %rax, %rbp
movq %rax, (%r13)
movl $0x1, %r13d
movl %r13d, 0x4(%r12)
movq %rax, 0x38(%rbx)
movabsq $-0x7fc0000000000000, %rax # imm = 0x8040000000000000
movq %rax, 0x8(%rbp)
movl $0x1, %eax
movq %rax, 0x18(%r15)
movl $0x8, %edi
callq 0x21a0
movq %rax, %r12
movq %rax, 0x20(%r15)
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2130
movq %rax, (%r12)
movl %r13d, 0x4(%r15)
movq %rax, (%rbp)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi-lite/rope.c
// Function: rope_rank2a
void rope_rank2a(const rope_t *rope, int64_t x, int64_t y, int64_t *cx, int64_t *cy)
{
	rpnode_t *v;
	int64_t rest;
	v = rope_count_to_leaf(rope, x, cx, &rest);
	if (y < x || cy == 0) {
		rle_rank1a((const uint8_t*)v->p, rest, cx, v->c);
	} else if (rest + (y - x) <= v->l) {
		memcpy(cy, cx, 48);
		rle_rank2a((const uint8_t*)v->p, rest, rest + (y - x), cx, cy, v->c);
	} else {
		rle_rank1a((const uint8_t*)v->p, rest, cx, v->c);
		v = rope_count_to_leaf(rope, y, cy, &rest);
		rle_rank1a((const uint8_t*)v->p, rest, cy, v->c);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq 0x38(%rdi), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rdx
callq 0x15a5f
movq %r15, %rdx
subq %r13, %rdx
setge %cl
testq %rbx, %rbx
setne %sil
testb %sil, %cl
jne 0x159bc
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rax
movq $-0x1, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
jmp 0x15a4a
movq 0x8(%rsp), %rsi
addq %rsi, %rdx
movabsq $0x3fffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFF
andq 0x8(%rax), %rcx
cmpq %rcx, %rdx
jbe 0x15a24
movq (%rax), %rdi
addq $0x10, %rax
movq $-0x1, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x16a79
movq 0x38(%r12), %rdi
leaq 0x8(%rsp), %r14
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x15a5f
movq (%rax), %rdi
movq (%r14), %rsi
leaq 0x10(%rax), %r9
movq $-0x1, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
jmp 0x15a4d
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq (%rax), %rdi
addq $0x10, %rax
movq %r14, %rcx
movq %rbx, %r8
movq %rax, %r9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x16a79
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi-lite/rope.c
// Function: rope_count_to_leaf
static rpnode_t *rope_count_to_leaf(const rope_t *rope, int64_t x, int64_t cx[6], int64_t *rest)
{
	rpnode_t *u, *v = 0, *p = rope->root;
	int64_t y = 0;
	int a;

	memset(cx, 0, 48);
	do {
		u = p;
		if (v && x - y > v->l>>1) {
			p += p->n - 1; y += v->l;
			for (a = 0; a != 6; ++a) cx[a] += v->c[a];
			for (; y >= x; --p) {
				y -= p->l;
				for (a = 0; a != 6; ++a) cx[a] -= p->c[a];
			}
			++p;
		} else {
			for (; y + p->l < x; ++p) {
				y += p->l;
				for (a = 0; a != 6; ++a) cx[a] += p->c[a];
			}
		}
		v = p; p = p->p;
	} while (!u->is_bottom);
	*rest = x - y;
	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movabsq $0x3fffffffffffff, %r8  # imm = 0x3FFFFFFFFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdx)
movups %xmm0, 0x10(%rdx)
movups %xmm0, (%rdx)
xorl %eax, %eax
xorl %r9d, %r9d
testq %rax, %rax
je 0x15b1c
movq %rsi, %r11
subq %r9, %r11
movq 0x8(%rax), %r10
andq %r8, %r10
movq %r10, %rbx
shrq %rbx
cmpq %rbx, %r11
jbe 0x15b1c
movq 0x8(%rdi), %rbx
shrq $0x36, %rbx
andl $0x1ff, %ebx            # imm = 0x1FF
movl %ebx, %r11d
shll $0x6, %r11d
addq %rdi, %r11
addq $-0x40, %r11
xorl %r14d, %r14d
movq 0x10(%rax,%r14,8), %r15
addq %r15, (%rdx,%r14,8)
incq %r14
cmpq $0x6, %r14
jne 0x15ac1
addq %r9, %r10
cmpq %rsi, %r10
jl 0x15b10
shll $0x6, %ebx
leaq (%rdi,%rbx), %rax
addq $-0x30, %rax
movq 0x8(%r11), %r9
andq %r8, %r9
xorl %ebx, %ebx
movq (%rax,%rbx,8), %r14
subq %r14, (%rdx,%rbx,8)
incq %rbx
cmpq $0x6, %rbx
jne 0x15aef
subq %r9, %r10
addq $-0x40, %r11
addq $-0x40, %rax
cmpq %rsi, %r10
jge 0x15ae6
addq $0x40, %r11
movq %r11, %rax
movq %r10, %r9
jmp 0x15b5c
movq 0x8(%rdi), %r10
andq %r8, %r10
addq %r9, %r10
movq %rdi, %rax
cmpq %rsi, %r10
jae 0x15b5c
movq %rdi, %rax
movq %r10, %r9
xorl %r10d, %r10d
movq 0x10(%rax,%r10,8), %r11
addq %r11, (%rdx,%r10,8)
incq %r10
cmpq $0x6, %r10
jne 0x15b37
movq 0x48(%rax), %r10
andq %r8, %r10
addq $0x40, %rax
addq %r9, %r10
cmpq %rsi, %r10
jb 0x15b31
cmpq $0x0, 0x8(%rdi)
movq (%rax), %rdi
jns 0x15a81
subq %r9, %rsi
movq %rsi, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi-lite/rope.c
// Function: rope_itr_first
void rope_itr_first(const rope_t *rope, rpitr_t *i)
{
	memset(i, 0, sizeof(rpitr_t));
	i->rope = rope;
	for (i->pa[i->d] = rope->root; !i->pa[i->d]->is_bottom;) // descend to the leftmost leaf
		++i->d, i->pa[i->d] = i->pa[i->d - 1]->p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rdi
movl $0x3c8, %edx            # imm = 0x3C8
xorl %esi, %esi
callq 0x2100
movq %r14, (%rbx)
movq 0x38(%r14), %rax
movq %rax, 0x8(%rbx)
cmpq $0x0, 0x8(%rax)
js 0x15bc1
movl $0x2, %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x3c8(%rbx)
movq (%rax), %rax
movq %rax, (%rbx,%rcx,8)
incq %rcx
cmpq $0x0, 0x8(%rax)
jns 0x15ba7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi-lite/rope.c
// Function: rope_itr_next_block
const uint8_t *rope_itr_next_block(rpitr_t *i)
{
	const uint8_t *ret;
	assert(i->d < ROPE_MAX_DEPTH); // a B+ tree should not be that tall
	if (i->d < 0) return 0;
	ret = (uint8_t*)i->pa[i->d][i->ia[i->d]].p;
	while (i->d >= 0 && ++i->ia[i->d] == i->pa[i->d]->n) i->ia[i->d--] = 0; // backtracking
	if (i->d >= 0)
		while (!i->pa[i->d]->is_bottom) // descend to the leftmost leaf
			++i->d, i->pa[i->d] = i->pa[i->d - 1][i->ia[i->d - 1]].p;
	return ret;
}

// Assembly:
pushq %rax
movslq 0x3c8(%rdi), %rcx
cmpq $0x50, %rcx
jge 0x15c85
testl %ecx, %ecx
js 0x15c4c
movq 0x8(%rdi,%rcx,8), %rax
movslq 0x288(%rdi,%rcx,4), %rdx
shlq $0x6, %rdx
movq (%rax,%rdx), %rax
movl %ecx, %ecx
movl 0x288(%rdi,%rcx,4), %r8d
incl %r8d
movl %r8d, 0x288(%rdi,%rcx,4)
movslq 0x3c8(%rdi), %rcx
movq 0x8(%rdi,%rcx,8), %rdx
movq 0x8(%rdx), %rsi
movq %rsi, %r9
shrq $0x36, %r9
andl $0x1ff, %r9d            # imm = 0x1FF
cmpl %r9d, %r8d
jne 0x15c50
leal -0x1(%rcx), %edx
movl %edx, 0x3c8(%rdi)
movl $0x0, 0x288(%rdi,%rcx,4)
movl 0x3c8(%rdi), %ecx
testl %ecx, %ecx
jns 0x15bf4
jmp 0x15c83
xorl %eax, %eax
jmp 0x15c83
testl %ecx, %ecx
js 0x15c83
testq %rsi, %rsi
js 0x15c83
leal 0x1(%rcx), %esi
movl %esi, 0x3c8(%rdi)
movslq 0x288(%rdi,%rcx,4), %r8
shlq $0x6, %r8
movq (%rdx,%r8), %rdx
movq %rdx, 0x10(%rdi,%rcx,8)
incq %rcx
incl %esi
cmpq $0x0, 0x8(%rdx)
jns 0x15c5c
popq %rcx
retq
leaq 0x2369(%rip), %rdi      # 0x17ff5
leaq 0x1987(%rip), %rsi      # 0x1761a
leaq 0x2371(%rip), %rcx      # 0x1800b
movl $0xd3, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi-lite/rle.c
// Function: rle_count
void rle_count(const uint8_t *block, int64_t cnt[6])
{
	const uint8_t *q = block + 2, *end = q + *(uint16_t*)block;
	while (q < end) {
		int c;
		int64_t l;
		rle_dec1(q, c, l);
		cnt[c] += l;
	}
}

// Assembly:
movzwl (%rdi), %eax
testq %rax, %rax
je 0x1698c
addq %rdi, %rax
addq $0x2, %rax
addq $0x2, %rdi
movzbl (%rdi), %ecx
testb %cl, %cl
js 0x16934
incq %rdi
movl %ecx, %edx
shrl $0x3, %edx
andl $0x7, %ecx
addq %rdx, (%rsi,%rcx,8)
cmpq %rax, %rdi
jb 0x16917
jmp 0x1698c
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x16959
movl %ecx, %edx
andl $0x18, %edx
movzbl 0x1(%rdi), %r8d
andl $0x3f, %r8d
leaq (%r8,%rdx,8), %rdx
addq $0x2, %rdi
jmp 0x16926
movl %ecx, %r8d
shrl $0x2, %r8d
andl $0x4, %r8d
movl %ecx, %edx
shrl $0x3, %edx
andl $0x1, %edx
incq %rdi
xorl $-0x3, %r8d
shlq $0x6, %rdx
movzbl (%rdi), %r9d
andl $0x3f, %r9d
orq %r9, %rdx
incq %rdi
incl %r8d
jne 0x16973
jmp 0x16926
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi-lite/rle.c
// Function: rle_print
void rle_print(const uint8_t *block, int expand)
{
	const uint16_t *p = (const uint16_t*)block;
	const uint8_t *q = block + 2, *end = block + 2 + *p;
	while (q < end) {
		int c;
		int64_t l, x;
		rle_dec1(q, c, l);
		if (expand) for (x = 0; x < l; ++x) putchar("$ACGTN"[c]);
		else printf("%c%ld", "$ACGTN"[c], (long)l);
	}
	putchar('\n');
}

// Assembly:
movzwl (%rdi), %eax
testq %rax, %rax
je 0x16a6f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq (%rdi,%rax), %r13
addq $0x2, %r13
addq $0x2, %r14
leaq 0x9fc(%rip), %r15       # 0x173b8
movzbl (%r14), %eax
testb %al, %al
js 0x16a0a
incq %r14
movl %eax, %r12d
shrl $0x3, %r12d
andl $0x7, %eax
testl %ebx, %ebx
je 0x169ed
testq %r12, %r12
jle 0x16a03
movsbl (%rax,%r15), %ebp
movl %ebp, %edi
callq 0x2050
decq %r12
jne 0x169df
jmp 0x16a03
movsbl (%rax,%r15), %esi
leaq 0x166f(%rip), %rdi      # 0x18068
movq %r12, %rdx
xorl %eax, %eax
callq 0x20c0
cmpq %r13, %r14
jb 0x169bc
jmp 0x16a61
movl %eax, %ecx
andl $-0x20, %ecx
cmpl $0xc0, %ecx
jne 0x16a2e
movl %eax, %ecx
andl $0x18, %ecx
movzbl 0x1(%r14), %edx
andl $0x3f, %edx
leaq (%rdx,%rcx,8), %r12
addq $0x2, %r14
jmp 0x169ce
movl %eax, %ecx
shrl $0x2, %ecx
andl $0x4, %ecx
movl %eax, %r12d
shrl $0x3, %r12d
andl $0x1, %r12d
incq %r14
xorl $-0x3, %ecx
shlq $0x6, %r12
movzbl (%r14), %edx
andl $0x3f, %edx
orq %rdx, %r12
incq %r14
incl %ecx
jne 0x16a47
jmp 0x169ce
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xa, %edi
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort.c
// Function: usage
static void usage(char *pname)
{
    printf("Usage: %s [OPTION] [FILE...]\n", pname);
    puts("Sort files or, if no files on the command line, sort stdin.");
    puts("All files sorted together into one output.");
    puts("");
    puts("  -u, --uniqify     Only print identical lines once");
    puts("  -r, --reverse     Reverse the sense of the comparison");
    puts("  -n, --numer       Sort numerically, then non-numerically");
    puts("  -h, --help        Print this help");
    puts("  -v, --version     Print version information");
    puts("");
    puts("Report bugs to <chbarts@gmail.com>.");
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0xc90(%rip), %rdi       # 0x3154
xorl %eax, %eax
callq 0x1090
leaq 0xca0(%rip), %rdi       # 0x3172
callq 0x1050
leaq 0xcd0(%rip), %rdi       # 0x31ae
callq 0x1050
movl $0xa, %edi
callq 0x1040
leaq 0xce5(%rip), %rdi       # 0x31d9
callq 0x1050
leaq 0xd0d(%rip), %rdi       # 0x320d
callq 0x1050
leaq 0xd39(%rip), %rdi       # 0x3245
callq 0x1050
leaq 0xd68(%rip), %rdi       # 0x3280
callq 0x1050
leaq 0xd80(%rip), %rdi       # 0x32a4
callq 0x1050
movl $0xa, %edi
callq 0x1040
leaq 0xd98(%rip), %rdi       # 0x32d2
popq %rax
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort.c
// Function: version
static void version(void)
{
    puts("sort version 0.5.0");
    puts("Copyright 2014 Chris Barts.");
    puts("sort comes with NO WARRANTY to the extent permitted by law.");
    puts("You may redistribute this software under the terms");
    puts("of the GNU General Public License.");
    puts("For more information, see the file named COPYING");
    puts("in this program's distribution file.");
}

// Assembly:
pushq %rax
leaq 0xdae(%rip), %rdi       # 0x32f6
callq 0x1050
leaq 0xdb5(%rip), %rdi       # 0x3309
callq 0x1050
leaq 0xdc5(%rip), %rdi       # 0x3325
callq 0x1050
leaq 0xdf5(%rip), %rdi       # 0x3361
callq 0x1050
leaq 0xe1c(%rip), %rdi       # 0x3394
callq 0x1050
leaq 0xe33(%rip), %rdi       # 0x33b7
callq 0x1050
leaq 0xe58(%rip), %rdi       # 0x33e8
popq %rax
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort.c
// Function: nduplicate
static int nduplicate(void *orig, void *new)
{
    ll *val;
    tstruct *node = (tstruct *) orig, *node2 = (tstruct *) new;
    aa *ttree;

    aa_to_root(node2->tree);
    val = aa_get_here(node2->tree);
    ttree = node->tree;

    switch (aa_add(node->tree, val, duplicate)) {
    case 0:
        break;
    case 2:                    /* memory error */
        free(node);
        cleanup(node2->tree, false);
        free(node2);
        error(ttree, false);
        break;
    default:                   /* can't happen */
        fprintf(stderr, "can't happen\n");
        free(node);
        cleanup(ttree, false);
        cleanup(node2->tree, false);
        free(node2);
        exit(EXIT_FAILURE);
        break;
    }

    aa_free(node2->tree);
    free(node2);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rdi
callq 0x1bd7
movq 0x8(%rbx), %rdi
callq 0x1acd
movq 0x8(%r15), %r14
leaq -0x64(%rip), %rdx       # 0x268c
movq %r14, %rdi
movq %rax, %rsi
callq 0x1540
testl %eax, %eax
jne 0x2718
movq 0x8(%rbx), %rdi
callq 0x1a83
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x2, %eax
jne 0x2754
movq %r15, %rdi
callq 0x1030
movq 0x8(%rbx), %r15
leaq 0x6c(%rip), %rsi        # 0x279c
movq %r15, %rdi
xorl %edx, %edx
callq 0x196d
movq %r15, %rdi
callq 0x1a83
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
xorl %esi, %esi
callq 0x264f
leaq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x12de
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort.c
// Function: freedatan
static void *freedatan(void *data)
{
    tstruct *node = (tstruct *) data;
    cleanup(node->tree, false);
    free(node);
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x24(%rip), %rsi        # 0x279c
movq %r14, %rdi
xorl %edx, %edx
callq 0x196d
movq %r14, %rdi
callq 0x1a83
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/avik-das[P]seam-carver/seam-carver.c
// Function: compute_energy
unsigned int * compute_energy(const unsigned char *data, int w, int h) {
    unsigned int *energy = malloc(w * h * sizeof(unsigned int));
    if (!energy) {
        fprintf(stderr, "Unable to allocate memory (%d)\n", __LINE__);
        return NULL;
    }

    for (int y = 0; y < h; y++)
    for (int x = 0; x < w; x++) {
        int i = y * w + x;
        energy[i] = energy_at(data, w, h, x, y);
    }

    return energy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rdi, %r14
movl %edx, %eax
movl %esi, 0xc(%rsp)
imull %esi, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1120
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x5612
testl %ebx, %ebx
jle 0x55fe
movl 0xc(%rsp), %r12d
movl %ebx, %eax
movq %rax, 0x20(%rsp)
leaq (,%r12,4), %rax
movq %rax, 0x18(%rsp)
xorl %r13d, %r13d
movq 0x10(%rsp), %rbp
cmpl $0x0, 0xc(%rsp)
jle 0x55ef
xorl %r15d, %r15d
movq %r14, %rdi
movl %r12d, %esi
movl %ebx, %edx
movl %r15d, %ecx
movl %r13d, %r8d
callq 0x548a
movl %eax, (%rbp,%r15,4)
incq %r15
cmpq %r15, %r12
jne 0x55cf
incq %r13
addq 0x18(%rsp), %rbp
cmpq 0x20(%rsp), %r13
jne 0x55c5
movq 0x10(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x11db
jmp 0x55fe