LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r15
xorl %r13d, %r13d
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %ecx, %ecx
xorl %r12d, %r12d
movl %edx, 0x4(%rsp)
movl %esi, (%rsp)
cmpq %rbx, (%r15)
jbe 0xf4e6
movq 0x10(%r15), %rbp
movl (%rbp,%r13), %eax
testl %eax, %eax
js 0xf4dd
cmpq $0x0, 0x20(%rbp,%r13)
je 0xf498
cmpl %esi, %eax
jge 0xf4dd
cmpq $0x0, 0x38(%rbp,%r13)
je 0xf49c
jmp 0xf4dd
cmpl %esi, %eax
jge 0xf4dd
cmpl %edx, 0x4(%rbp,%r13)
jge 0xf4dd
cmpq %rcx, %r14
jne 0xf4d3
movq %r12, %rdi
leaq (%r14,%r14), %r12
testq %r14, %r14
pushq $0x2
popq %rax
cmoveq %rax, %r12
leaq (,%r12,8), %rsi
callq 0x21c0
movq %r12, %rcx
movl (%rsp), %esi
movl 0x4(%rsp), %edx
movq %rax, %r12
addq %r13, %rbp
movq %rbp, (%r12,%r14,8)
incq %r14
incq %rbx
addq $0x68, %r13
jmp 0xf470
movq %r14, %rdi
movq %r12, %rsi
callq 0xe716
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0xf509
movq (%r12,%rbx,8), %rsi
movq %r15, %rdi
callq 0xdbb0
incq %rbx
jmp 0xf4f3
movq %r12, %rdi
callq 0x2040
cmpl $0x3, 0xbd58(%rip)      # 0x1b270
jge 0xf52c
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xbac5(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x574b(%rip), %rsi      # 0x14c88
leaq 0x5777(%rip), %rdx      # 0x14cbb
movq %r14, %rcx
movl (%rsp), %r8d
movl 0x4(%rsp), %r9d
xorl %eax, %eax
callq 0x2150
jmp 0xf51a
// File: /workspace/github_c_makefile_star2_O2/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, 0x14(%rsp)
movq %rdi, %r12
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %edi, %edi
xorl %r13d, %r13d
movl %edx, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq %rbp, (%r12)
jbe 0xf5eb
movq 0x10(%r12), %r15
movl (%r15,%rbx), %eax
testl %eax, %eax
sets %cl
cmpl %esi, %eax
setge %al
orb %cl, %al
jne 0xf5e2
cmpl %edx, 0x4(%r15,%rbx)
jge 0xf5e2
cmpq %rdi, %r14
jne 0xf5d7
movq %r13, %rdi
leaq (%r14,%r14), %r13
testq %r14, %r14
pushq $0x2
popq %rax
cmoveq %rax, %r13
leaq (,%r13,8), %rsi
callq 0x21c0
movq %r13, %rdi
movl 0xc(%rsp), %esi
movl 0x10(%rsp), %edx
movq %rax, %r13
addq %rbx, %r15
movq %r15, (%r13,%r14,8)
incq %r14
incq %rbp
addq $0x68, %rbx
jmp 0xf582
movq %r14, %rdi
movq %r13, %rsi
callq 0xe716
xorl %ebx, %ebx
movl 0x14(%rsp), %ebp
cmpq %rbx, %r14
je 0xf615
movq (%r13,%rbx,8), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xdc6d
incq %rbx
jmp 0xf5fc
movq %r13, %rdi
callq 0x2040
cmpl $0x3, 0xbc4c(%rip)      # 0x1b270
jge 0xf638
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb9b9(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x5680(%rip), %rsi      # 0x14cc9
leaq 0x56b9(%rip), %rdx      # 0x14d09
movq %r14, %rcx
movl 0xc(%rsp), %r8d
movl 0x10(%rsp), %r9d
xorl %eax, %eax
callq 0x2150
jmp 0xf626
// File: /workspace/github_c_makefile_star2_O2/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 0xfb43
movl %eax, 0x1c(%rbx)
pushq $0x2
popq %rbp
cmpl 0xc(%r14), %ebp
jg 0xfb5e
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0xf44e
incl %ebp
jmp 0xfb46
movl 0x20(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1ca
movl 0x1c(%rbx), %esi
cvtss2sd 0x2c(%r14), %xmm0
movl 0x8(%r14), %edx
movl 0xc(%r14), %ecx
movq %rbx, %rdi
callq 0xf666
movl 0x20(%r14), %edx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xe1ca
pushq $0x2
popq %rbp
cmpl 0xc(%r14), %ebp
jg 0xfbaf
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0xf44e
incl %ebp
jmp 0xfb97
movl 0x20(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1ca
movl (%r14), %ecx
testb $0x60, %cl
je 0xfbd4
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x10e53
movl (%r14), %ecx
testb %cl, %cl
js 0xfbeb
movl 0x14(%r14), %edx
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0x10486
movl (%r14), %ecx
movss 0x30(%r14), %xmm0
movss 0x34(%r14), %xmm1
movl 0x18(%r14), %edx
movl 0x20(%r14), %esi
andl $0x20, %ecx
movq %rbx, %rdi
callq 0x10953
movl 0x8(%r14), %esi
movl 0x10(%r14), %edx
movl 0x1c(%rbx), %ecx
movq %rbx, %rdi
callq 0xf559
movl 0x1c(%rbx), %esi
cvtss2sd 0x2c(%r14), %xmm0
movl 0x8(%r14), %edx
movl 0xc(%r14), %ecx
movq %rbx, %rdi
callq 0xf666
movl 0x20(%r14), %edx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xe1ca
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0xf44e
movl 0x20(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1ca
testb $0x60, (%r14)
je 0xfc75
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x10e53
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0xf44e
movl 0x20(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xe1ca
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %rbx
movq 0x20(%rsi), %rcx
movq 0x38(%rsi), %rsi
testq %rcx, %rcx
je 0xfcc1
testq %rsi, %rsi
jne 0xfde3
movl (%rbx), %eax
jmp 0xfce5
movl (%rbx), %eax
testq %rsi, %rsi
jne 0xfce7
leal (%rdx,%rdx,2), %esi
cmpl %esi, %eax
jge 0xfce5
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdbb0
xorl %esi, %esi
leaq 0x20(%rbx), %rdi
xorl %r8d, %r8d
pushq $0x8
popq %r9
cmpq $0x2, %r8
je 0xfd49
movl %r8d, %r10d
xorq $0x1, %r10
imulq $0x18, %r10, %r11
leaq (%rdi,%r11), %r10
movq (%rdi,%r11), %r11
xorl %r15d, %r15d
movq %r9, %r14
subq $0x1, %r11
jb 0xfd33
movslq %r15d, %r12
movq 0x10(%r10), %r13
movq (%r13,%r14), %r13
cmpq %r12, %r13
cmovbl %r15d, %r13d
addq $0x10, %r14
movl %r13d, %r15d
jmp 0xfd11
movl %eax, %r10d
subl %r15d, %r10d
cmpl %edx, %r10d
cmovgel %edx, %r10d
movl %r10d, (%rsp,%r8,4)
incq %r8
jmp 0xfcf2
testq %rcx, %rcx
jne 0xfda6
movl (%rsp), %ecx
xorl %r14d, %r14d
testl %ecx, %ecx
cmovlel %r14d, %ecx
cmpq %r14, %rcx
je 0xfd74
movq 0x58(%rbx), %rdx
movsbl (%rdx,%r14), %edx
addl $-0x21, %edx
cmpl %ebp, %edx
jge 0xfd79
incq %r14
jmp 0xfd5a
movq %rcx, %r14
jmp 0xfd7c
movl %r14d, %ecx
subl %ecx, %eax
movl %eax, (%rbx)
movq 0x50(%rbx), %rdi
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 0xfde3
movslq (%rbx), %rax
movslq 0x4(%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 0xfddf
movq 0x58(%rbx), %rdi
movsbl -0x1(%rdi,%rax), %edi
decq %rax
addl $-0x21, %edi
decl %esi
cmpl %ebp, %edi
jl 0xfdc3
jmp 0xfde1
movl %edx, %esi
movl %esi, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfe3a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r12, (%r14)
jbe 0xfe2f
movq 0x10(%r14), %rsi
addq %r15, %rsi
movl 0x24(%rbx), %edx
movl 0x28(%rbx), %ecx
movq %r14, %rdi
callq 0xfc97
incq %r12
addq $0x68, %r15
jmp 0xfe0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movslq 0x4(%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jge 0xfe7e
movq (%rdi,%r14,8), %rdi
callq 0x2040
incq %r14
jmp 0xfe63
callq 0x2040
movq 0x20(%rbx), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0xafbb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bubble.c
// Function: tip_alloc
static inline trinfo_t *tip_alloc(tipool_t *pool, uint32_t id)
{ // allocate an object from the memory pool
	trinfo_t *p;
	if (pool->n == pool->m) {
		int i, new_m = pool->m? pool->m<<1 : 256;
		pool->buf = realloc(pool->buf, new_m * sizeof(void*));
		for (i = pool->m; i < new_m; ++i)
			pool->buf[i] = malloc(sizeof(trinfo_t));
		pool->m = new_m;
	}
	p = pool->buf[pool->n++];
	*p = g_trinull;
	p->id = id;
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
jne 0x103e5
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x100, %ebp            # imm = 0x100
cmovnel %ecx, %ebp
movq 0x8(%r14), %rdi
movslq %ebp, %r12
leaq (,%r12,8), %rsi
callq 0x21c0
movq %rax, 0x8(%r14)
movslq 0x4(%r14), %r13
pushq $0x50
popq %r15
cmpq %r12, %r13
jge 0x103de
movq %r15, %rdi
callq 0x21a0
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x103c4
movl %ebp, 0x4(%r14)
movl (%r14), %eax
movq 0x8(%r14), %rcx
leal 0x1(%rax), %edx
movl %edx, (%r14)
cltq
movq (%rcx,%rax,8), %rax
leaq 0x49fc(%rip), %rsi      # 0x14df8
pushq $0xa
popq %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl %ebx, %ecx
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq %r13, %r15
shrq $0x20, %r15
cmpq %r14, %r15
je 0x10477
movq %r13, %rbp
shrq $0x21, %rbp
movq %rbx, %rdi
movq %rbp, %rsi
leaq 0x4(%rsp), %rdx
callq 0xb2d5
movq 0x10(%r12), %rax
imulq $0x68, %rbp, %rcx
notl %r15d
andl $0x1, %r15d
shll $0x4, %r15d
addq 0x60(%rax,%rcx), %r15
andl $0x1, %r13d
movq 0x30(%r15,%r13,8), %r13
jmp 0x10430
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r15
xorl %r13d, %r13d
callq 0xfe3c
movq %rax, %r12
cmpq (%rbx), %r13
jae 0x104dd
leaq -0x1(%r15), %rsi
movq %rbx, %rdi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0xfea4
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0xfea4
incq %r13
addq $0x2, %r15
jmp 0x104a8
movq %r12, %rdi
callq 0xfe59
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 0xe1ca
// File: /workspace/github_c_makefile_star2_O2/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 %ecx, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdi, %r14
pushq $0x1
popq %rbp
xorl %eax, %eax
xorl %edx, %edx
xorl %ebx, %ebx
movq %rdi, 0x20(%rsp)
movl 0x18(%rsp), %r12d
movl 0x1c(%rsp), %r15d
cmpq (%r14), %rax
jae 0x10a2d
leaq -0x1(%rbp), %rsi
movq %r14, %rdi
movss 0xc(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movq %rdx, 0x30(%rsp)
movl %r12d, %edx
movl %r15d, %ecx
movq %rax, 0x28(%rsp)
callq 0x104ff
xorl %r14d, %r14d
testl %eax, %eax
setg %r14b
xorl %r13d, %r13d
cmpl $0x2, %eax
setge %r13b
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
movss 0xc(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movl %r12d, %edx
movl %r15d, %ecx
callq 0x104ff
movq 0x30(%rsp), %rdx
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
addq %rcx, %rdx
addq %r14, %rdx
movq 0x20(%rsp), %r14
xorl %ecx, %ecx
cmpl $0x2, %eax
movq 0x28(%rsp), %rax
setge %cl
addq %rcx, %rbx
addq %r13, %rbx
incq %rax
addq $0x2, %rbp
jmp 0x10994
leaq 0xa83c(%rip), %rax      # 0x1b270
cmpl $0x3, (%rax)
jge 0x10a55
movq %r14, %rdi
xorl %esi, %esi
movl 0x14(%rsp), %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe1ca
movq 0xa59c(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x43e2(%rip), %rsi      # 0x14e48
movq %rdx, %rcx
leaq 0x4405(%rip), %rdx      # 0x14e75
movq %rbx, %r8
xorl %eax, %eax
callq 0x2150
jmp 0x10a39
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq (%rbx), %r15
jae 0x10e84
movq 0x10(%rbx), %rsi
addq %r14, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x10a7c
incq %r15
addq $0x68, %r14
jmp 0x10e65
leaq 0xa3e5(%rip), %rax      # 0x1b270
cmpl $0x3, (%rax)
jge 0x10ea6
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe1ca
movq 0xa14b(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x3fcf(%rip), %rsi      # 0x14e86
leaq 0x3fe4(%rip), %rdx      # 0x14ea2
xorl %eax, %eax
callq 0x2150
jmp 0x10e90
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x11bf8
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
cmpq %rdx, %r15
je 0x11c17
movq %rax, -0x8(%rcx)
movq %rdx, (%rcx)
incq %rdx
addq $0x10, %rcx
jmp 0x11be3
xorl %r12d, %r12d
testq %rbx, %rbx
cmovleq %r12, %rbx
cmpq %r12, %rbx
je 0x11c5a
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *%r15
incq %r12
jmp 0x11c02
xorl %ebx, %ebx
movq %r12, %r14
cmpq %rbx, %r13
je 0x11c43
movq -0x40(%rbp), %rcx
addq %rbx, %rcx
movq %r14, %rdi
xorl %esi, %esi
leaq 0x35(%rip), %rdx        # 0x11c69
callq 0x21f0
addq $0x10, %rbx
addq $0x8, %r14
jmp 0x11c1c
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x11c5a
movq (%r12,%rbx,8), %rdi
xorl %esi, %esi
callq 0x2270
incq %rbx
jmp 0x11c45
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x40, %edi
jge 0x11dc1
movl %edi, %r15d
leal (%r15,%r15), %eax
subl %esi, %eax
cmpl $0x33, %eax
leal -0x32(%r15,%r15), %eax
cmovll %esi, %eax
cmpl $0x14, %eax
pushq $0x14
popq %rbp
cmovll %eax, %ebp
movl %edi, %eax
subl %ebp, %eax
cmpl $0x32, %eax
jge 0x11dda
pushq $0x1
popq %rbx
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x2130
movq %rax, %r14
movl %r15d, (%rax)
movl %ebp, 0x10(%rax)
pushq $0x1
popq %r15
movl %ebp, %ecx
shll %cl, %r15d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x2130
movq %rax, %r12
movq %rax, 0x8(%r14)
xorl %ebp, %ebp
pushq $0x28
popq %r13
cmpq %rbp, %r15
je 0x11daf
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2130
movq %rax, (%r12,%rbp,8)
incq %rbp
jmp 0x11d96
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3108(%rip), %rdi      # 0x14ed0
leaq 0x3109(%rip), %rsi      # 0x14ed8
leaq 0x3109(%rip), %rcx      # 0x14edf
pushq $0x17
jmp 0x11df1
leaq 0x311e(%rip), %rdi      # 0x14eff
leaq 0x30f0(%rip), %rsi      # 0x14ed8
leaq 0x30f0(%rip), %rcx      # 0x14edf
pushq $0x1b
popq %rdx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/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 0x11e66
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movb 0x10(%rbx), %cl
movl %ebp, %eax
shll %cl, %eax
cltq
movq 0x8(%rbx), %rdi
cmpq %rax, %r15
jge 0x11e4f
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x11e4a
movq 0x18(%r14), %rdi
callq 0x2040
movq 0x10(%r14), %rdi
callq 0x2040
movq 0x20(%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
incq %r15
jmp 0x11e0c
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/htab.c
// Function: get_subhash
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:
movslq (%rdi), %rax
cmpq $0x20, %rax
jg 0x1209f
leal (%rax,%rax), %r8d
subl 0x10(%rdi), %r8d
movq (%rsi), %r9
movl %eax, %ecx
shlq %cl, %r9
orq 0x8(%rsi), %r9
pushq $-0x1
popq %rax
movl %r8d, %ecx
shlq %cl, %rax
notq %rax
andq %r9, %rax
shlq $0xe, %rax
incq %rax
shrq %cl, %r9
movq %rax, (%rdx)
jmp 0x120e5
movl %eax, %r8d
subl 0x10(%rdi), %r8d
leal (%r8,%rax), %r9d
movb $0x32, %r10b
pushq $-0x1
popq %r11
movl %r8d, %ecx
shlq %cl, %r11
subb %r8b, %r10b
notq %r11
andq (%rsi), %r11
cmpl $0x32, %r9d
movzbl %r10b, %ecx
cmovll %eax, %ecx
shlq %cl, %r11
xorq 0x8(%rsi), %r11
shlq $0xe, %r11
incq %r11
movq %r11, (%rdx)
movq (%rsi), %r9
movl %r8d, %ecx
shrq %cl, %r9
shlq $0x3, %r9
addq 0x8(%rdi), %r9
movq (%r9), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_get
int bfc_ch_get(const bfc_ch_t *ch, const uint64_t x[2])
{
	uint64_t key;
	cnthash_t *h;
	khint_t itr;
	h = get_subhash(ch, x, &key);
	itr = kh_get(cnt, h, key);
	return itr == kh_end(h)? -1 : kh_key(h, itr) & 0x3fff;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rdx
callq 0x12064
movq %rax, %rdx
movl (%rax), %esi
pushq $-0x1
popq %rax
testl %esi, %esi
je 0x12176
movq (%rsp), %r8
leal -0x1(%rsi), %r9d
shrq $0xe, %r8
movl %r8d, %r10d
andl %r9d, %r10d
movq 0x10(%rdx), %r11
pushq $0x1
popq %rbx
movl %r10d, %edi
movl %edi, %ecx
shrl $0x4, %ecx
movl (%r11,%rcx,4), %ebp
leal (%rdi,%rdi), %ecx
andl $0x1e, %ecx
movl %ebp, %r14d
shrl %cl, %r14d
testb $0x2, %r14b
jne 0x1216b
testb $0x1, %r14b
jne 0x1215d
movq 0x18(%rdx), %r14
movl %edi, %r15d
movq (%r14,%r15,8), %r14
shrq $0xe, %r14
cmpq %r8, %r14
je 0x1216b
addl %ebx, %edi
andl %r9d, %edi
incl %ebx
cmpl %r10d, %edi
jne 0x12128
jmp 0x1218a
shrl %cl, %ebp
testb $0x3, %bpl
cmovnel %esi, %edi
jmp 0x12178
xorl %edi, %edi
cmpl %esi, %edi
je 0x1218a
movq 0x18(%rdx), %rcx
movl %edi, %edx
movl $0x3fff, %eax           # imm = 0x3FFF
andl (%rcx,%rdx,8), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb 0x10(%rdi), %cl
pushq $0x1
popq %rdx
shll %cl, %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0x1224c
movq 0x8(%rdi), %rsi
movq (%rsi,%rcx,8), %rsi
movl 0x4(%rsi), %esi
addq %rsi, %rax
incq %rcx
jmp 0x12234
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
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
movb 0x10(%r15), %cl
pushq $0x1
popq %rax
shll %cl, %eax
testl %eax, %eax
cmovlel %r12d, %eax
cmpq %rax, %r12
je 0x122ef
movq 0x8(%r15), %rcx
movq (%rcx,%r12,8), %rdx
movl (%rdx), %esi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x122ea
movq 0x10(%rdx), %rcx
movl %r8d, %r9d
shrl $0x4, %r9d
movl (%rcx,%r9,4), %r9d
movl %edi, %ecx
andb $0x1e, %cl
shrl %cl, %r9d
testb $0x3, %r9b
jne 0x122e2
movq 0x18(%rdx), %rcx
movzbl (%rcx,%r8,8), %r9d
incq (%rbx,%r9,8)
movl (%rcx,%r8,8), %ecx
shrl $0x5, %ecx
andl $0x1f8, %ecx            # imm = 0x1F8
incq (%r14,%rcx)
incq %r8
addl $0x2, %edi
jmp 0x122a2
incq %r12
jmp 0x1228e
pushq $-0x1
popq %rax
pushq $0x3
popq %rcx
xorl %edx, %edx
cmpq $0x100, %rcx            # imm = 0x100
je 0x12313
movq (%rbx,%rcx,8), %rsi
cmpq %rdx, %rsi
cmoval %ecx, %eax
cmovaq %rsi, %rdx
incq %rcx
jmp 0x122f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
callq 0x2130
cmpl $0x21, %ebx
pushq $0x20
popq %r14
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 %ebp, %edi
callq 0x125e5
movq %rax, %r15
movq %rax, 0x40(%rbx)
movl %r14d, %edi
callq 0x125e5
movq %rax, %r14
movq %rax, 0x48(%rbx)
movq %r15, %rdi
callq 0x12611
movq %rax, %r15
movq %rax, 0x38(%rbx)
movabsq $0x3fffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFF
andq 0x8(%r15), %rax
movabsq $-0x7fc0000000000000, %rcx # imm = 0x8040000000000000
orq %rax, %rcx
movq %rcx, 0x8(%r15)
movq %r14, %rdi
callq 0x12611
movq %rax, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rope.c
// Function: mp_init
static mempool_t *mp_init(int size)
{
	mempool_t *mp;
	mp = calloc(1, sizeof(mempool_t));
	mp->size = size;
	mp->i = mp->n_elems = MP_CHUNK_SIZE / size;
	mp->top = -1;
	return mp;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x2130
movq %rax, %rcx
movl %ebx, (%rax)
movl $0x100000, %eax         # imm = 0x100000
xorl %edx, %edx
idivl %ebx
movl %eax, 0x8(%rcx)
movl %eax, 0x4(%rcx)
orq $-0x1, 0x10(%rcx)
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rope.c
// Function: mp_alloc
static inline void *mp_alloc(mempool_t *mp)
{
	if (mp->i == mp->n_elems) {
		if (++mp->top == mp->max) {
			mp->max = mp->max? mp->max<<1 : 1;
			mp->mem = realloc(mp->mem, sizeof(void*) * mp->max);
		}
		mp->mem[mp->top] = calloc(mp->n_elems, mp->size);
		mp->i = 0;
	}
	return mp->mem[mp->top] + (mp->i++) * mp->size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %ecx
movq 0x10(%rdi), %r15
cmpl 0x8(%rdi), %ecx
jne 0x12663
incq %r15
movq %r15, 0x10(%rbx)
cmpq 0x18(%rbx), %r15
jne 0x12667
leaq (%r15,%r15), %rax
testq %r15, %r15
pushq $0x1
popq %rsi
cmovneq %rax, %rsi
movq %rsi, 0x18(%rbx)
movq 0x20(%rbx), %rdi
shlq $0x3, %rsi
callq 0x21c0
movq %rax, %r14
movq %rax, 0x20(%rbx)
movl 0x8(%rbx), %ecx
movq 0x10(%rbx), %r15
jmp 0x1266b
movl (%rbx), %ebp
jmp 0x1267e
movq 0x20(%rbx), %r14
movslq %ecx, %rdi
movl (%rbx), %ebp
movslq %ebp, %rsi
callq 0x2130
movq %rax, (%r14,%r15,8)
xorl %ecx, %ecx
movq 0x20(%rbx), %rdx
imull %ecx, %ebp
incl %ecx
movslq %ebp, %rax
addq (%rdx,%r15,8), %rax
movl %ecx, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x8(%rsp), %rcx
movq %r14, %rdx
callq 0x12d4d
movq %r15, %rdx
subq %r13, %rdx
setge %cl
testq %rbx, %rbx
setne %sil
testb %sil, %cl
jne 0x12cb0
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rax
pushq $-0x1
popq %rdx
movq %r14, %rcx
xorl %r8d, %r8d
jmp 0x12d38
movq 0x8(%rsp), %rsi
addq %rsi, %rdx
movabsq $0x3fffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFF
andq 0x8(%rax), %rcx
cmpq %rcx, %rdx
jbe 0x12d12
movq (%rax), %rdi
addq $0x10, %rax
pushq $-0x1
popq %r13
movq %r13, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x1371a
leaq 0x8(%rsp), %r14
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x12d4d
movq (%rax), %rdi
movq (%r14), %rsi
leaq 0x10(%rax), %r9
movq %r13, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
jmp 0x12d3b
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 0x1371a
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x38(%rdi), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdx)
movups %xmm0, 0x10(%rdx)
movups %xmm0, (%rdx)
xorl %eax, %eax
xorl %r9d, %r9d
testq %rax, %rax
je 0x12dc3
movq %rsi, %r10
subq %r9, %r10
movq 0x8(%rax), %r11
andq %r8, %r11
movq %r11, %rbx
shrq %rbx
cmpq %rbx, %r10
jbe 0x12dc3
movq 0x8(%rdi), %rbx
shrq $0x36, %rbx
andl $0x1ff, %ebx            # imm = 0x1FF
movl %ebx, %r10d
shll $0x6, %r10d
addq %rdi, %r10
addq $-0x40, %r10
xorl %r14d, %r14d
cmpq $0x6, %r14
je 0x12df5
movq 0x10(%rax,%r14,8), %r15
addq %r15, (%rdx,%r14,8)
incq %r14
jmp 0x12daf
movq %rdi, %rax
movq 0x8(%rax), %r10
andq %r8, %r10
addq %r9, %r10
cmpq %rsi, %r10
jae 0x12e38
xorl %r9d, %r9d
cmpq $0x6, %r9
je 0x12dec
movq 0x10(%rax,%r9,8), %r11
addq %r11, (%rdx,%r9,8)
incq %r9
jmp 0x12dd8
addq $0x40, %rax
movq %r10, %r9
jmp 0x12dc6
addq %r11, %r9
shll $0x6, %ebx
leaq (%rdi,%rbx), %rax
addq $-0x30, %rax
cmpq %rsi, %r9
jl 0x12e31
movq 0x8(%r10), %r11
andq %r8, %r11
xorl %ebx, %ebx
cmpq $0x6, %rbx
je 0x12e24
movq (%rax,%rbx,8), %r14
subq %r14, (%rdx,%rbx,8)
incq %rbx
jmp 0x12e11
subq %r11, %r9
addq $-0x40, %r10
addq $-0x40, %rax
jmp 0x12e03
addq $0x40, %r10
movq %r10, %rax
cmpq $0x0, 0x8(%rdi)
movq (%rax), %rdi
jns 0x12d73
subq %r9, %rsi
movq %rsi, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x2
popq %rcx
cmpq $0x0, 0x8(%rax)
js 0x12e96
leal -0x1(%rcx), %edx
movl %edx, 0x3c8(%rbx)
movq (%rax), %rax
movq %rax, (%rbx,%rcx,8)
incq %rcx
jmp 0x12e7a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12f5d
testl %ecx, %ecx
js 0x12f22
movq 0x8(%rdi,%rcx,8), %rax
movslq 0x288(%rdi,%rcx,4), %rdx
shlq $0x6, %rdx
movq (%rax,%rdx), %rax
testl %ecx, %ecx
js 0x12f5b
movl %ecx, %ecx
movl 0x288(%rdi,%rcx,4), %r8d
incl %r8d
movl %r8d, 0x288(%rdi,%rcx,4)
movslq 0x3c8(%rdi), %rdx
movq 0x8(%rdi,%rdx,8), %rcx
movq 0x8(%rcx), %rsi
movq %rsi, %r9
shrq $0x36, %r9
andl $0x1ff, %r9d            # imm = 0x1FF
cmpl %r9d, %r8d
jne 0x12f26
leal -0x1(%rdx), %ecx
movl %ecx, 0x3c8(%rdi)
andl $0x0, 0x288(%rdi,%rdx,4)
movl 0x3c8(%rdi), %ecx
jmp 0x12ec9
xorl %eax, %eax
jmp 0x12f5b
testl %edx, %edx
js 0x12f5b
leal 0x1(%rdx), %r8d
testq %rsi, %rsi
js 0x12f5b
movl %r8d, 0x3c8(%rdi)
movslq 0x288(%rdi,%rdx,4), %rsi
shlq $0x6, %rsi
movq (%rcx,%rsi), %rcx
movq %rcx, 0x10(%rdi,%rdx,8)
incq %rdx
movq 0x8(%rcx), %rsi
incl %r8d
jmp 0x12f2e
popq %rcx
retq
leaq 0x2009(%rip), %rdi      # 0x14f6d
leaq 0x1690(%rip), %rsi      # 0x145fb
leaq 0x2011(%rip), %rcx      # 0x14f83
movl $0xd3, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/./rle.h
// Function: rle_enc1
static inline int rle_enc1(uint8_t *p, int c, int64_t l)
{
	if (l < 1LL<<4) {
		*p = l << 3 | c;
		return 1;
	} else if (l < 1LL<<8) {
		*p = 0xC0 | l >> 6 << 3 | c;
		p[1] = 0x80 | (l & 0x3f);
		return 2;
	} else if (l < 1LL<<19) {
		*p = 0xE0 | l >> 18 << 3 | c;
		p[1] = 0x80 | (l >> 12 & 0x3f);
		p[2] = 0x80 | (l >> 6 & 0x3f);
		p[3] = 0x80 | (l & 0x3f);
		return 4;
	} else {
		int i, shift = 36;
		*p = 0xF0 | l >> 42 << 3 | c;
		for (i = 1; i < 8; ++i, shift -= 6)
			p[i] = 0x80 | (l>>shift & 0x3f);
		return 8;
	}
}

// Assembly:
cmpq $0xf, %rdx
jg 0x13482
shll $0x3, %edx
orl %esi, %edx
movb %dl, (%rdi)
pushq $0x1
jmp 0x134a4
cmpq $0xff, %rdx
ja 0x134a6
movl %edx, %eax
shrl $0x3, %eax
andl $0x18, %eax
orl %esi, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x1(%rdi)
pushq $0x2
popq %rax
retq
movl %esi, %eax
cmpq $0x7ffff, %rdx          # imm = 0x7FFFF
ja 0x134e4
movl %edx, %ecx
shrl $0xf, %ecx
andl $0x8, %ecx
orl %ecx, %eax
orb $-0x20, %al
movb %al, (%rdi)
movl %edx, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdi)
movl %edx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rdi)
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x3(%rdi)
pushq $0x4
popq %rax
retq
movq %rdx, %rcx
shrq $0x27, %rcx
andl $0x8, %ecx
orl %ecx, %eax
orb $-0x10, %al
movb %al, (%rdi)
pushq $0x24
popq %rcx
pushq $0x1
popq %rsi
pushq $0x8
popq %rax
cmpq $0x8, %rsi
je 0x134e3
movq %rdx, %r8
shrq %cl, %r8
andb $0x3f, %r8b
orb $-0x80, %r8b
movb %r8b, (%rdi,%rsi)
incq %rsi
addl $-0x6, %ecx
jmp 0x134fd
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rle.c
// Function: rle_split
void rle_split(uint8_t *block, uint8_t *new_block)
{
	int n = *(uint16_t*)block;
	uint8_t *end = block + 2 + n, *q = block + 2 + (n>>1);
	while (*q>>6 == 2) --q;
	memcpy(new_block + 2, q, end - q);
	*(uint16_t*)new_block = end - q;
	*(uint16_t*)block = q - block - 2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rdi), %r15d
movl %r15d, %r12d
shrl %r12d
leaq (%r12,%rdi), %rsi
addq $0x3, %rsi
incq %r12
movb -0x1(%rsi), %al
decq %rsi
andb $-0x40, %al
decq %r12
negb %al
jo 0x1356f
leaq 0x2(%r14), %rdi
subq %r12, %r15
movq %r15, %rdx
callq 0x2170
movw %r15w, (%r14)
movw %r12w, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x2(%rdi), %rax
movzwl (%rdi), %ecx
addq %rdi, %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jae 0x13627
movzbl (%rax), %edx
testb %dl, %dl
js 0x135cc
incq %rax
movl %edx, %edi
shrl $0x3, %edi
andl $0x7, %edx
addq %rdi, (%rsi,%rdx,8)
jmp 0x135af
movl %edx, %edi
andl $-0x20, %edi
cmpl $0xc0, %edi
jne 0x135f1
movl %edx, %edi
andl $0x18, %edi
movzbl 0x1(%rax), %r8d
andl $0x3f, %r8d
leaq (%r8,%rdi,8), %rdi
addq $0x2, %rax
jmp 0x135c3
movl %edx, %r8d
shrl $0x2, %r8d
andl $0x4, %r8d
movl %edx, %edi
shrl $0x3, %edi
andl $0x1, %edi
incq %rax
xorl $-0x3, %r8d
testl %r8d, %r8d
je 0x135c3
shlq $0x6, %rdi
movzbl (%rax), %r9d
andl $0x3f, %r9d
orq %r9, %rdi
incq %rax
incl %r8d
jmp 0x1360b
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
leaq 0x2(%rdi), %r12
movzwl (%rdi), %eax
leaq (%rdi,%rax), %r13
addq $0x2, %r13
leaq 0xd6d(%rip), %rbp       # 0x143b8
cmpq %r13, %r12
jae 0x13704
movzbl (%r12), %r14d
testb %r14b, %r14b
js 0x136a6
incq %r12
movl %r14d, %r15d
shrl $0x3, %r15d
andl $0x7, %r14d
testl %ebx, %ebx
je 0x1368e
testq %r15, %r15
movl $0x0, %eax
cmovleq %rax, %r15
subq $0x1, %r15
jb 0x1364b
movsbl (%r14,%rbp), %edi
callq 0x2050
jmp 0x1367c
movsbl (%r14,%rbp), %esi
leaq 0x191f(%rip), %rdi      # 0x14fb9
movq %r15, %rdx
xorl %eax, %eax
callq 0x20c0
jmp 0x1364b
movl %r14d, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0x136cc
movl %r14d, %eax
andl $0x18, %eax
movzbl 0x1(%r12), %ecx
andl $0x3f, %ecx
leaq (%rcx,%rax,8), %r15
addq $0x2, %r12
jmp 0x13668
movl %r14d, %eax
shrl $0x2, %eax
andl $0x4, %eax
movl %r14d, %r15d
shrl $0x3, %r15d
andl $0x1, %r15d
incq %r12
xorl $-0x3, %eax
testl %eax, %eax
je 0x13668
shlq $0x6, %r15
movzbl (%r12), %ecx
andl $0x3f, %ecx
orq %rcx, %r15
incq %r12
incl %eax
jmp 0x136e6
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rsi
leaq 0xec6(%rip), %rdi       # 0x3154
xorl %eax, %eax
callq 0x1090
leaq 0xed6(%rip), %rdi       # 0x3172
callq 0x1050
leaq 0xf06(%rip), %rdi       # 0x31ae
callq 0x1050
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x1040
leaq 0xf1b(%rip), %rdi       # 0x31d9
callq 0x1050
leaq 0xf43(%rip), %rdi       # 0x320d
callq 0x1050
leaq 0xf6f(%rip), %rdi       # 0x3245
callq 0x1050
leaq 0xf9e(%rip), %rdi       # 0x3280
callq 0x1050
leaq 0xfb6(%rip), %rdi       # 0x32a4
callq 0x1050
movl %ebx, %edi
callq 0x1040
leaq 0xfd1(%rip), %rdi       # 0x32d2
popq %rbx
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0xfe7(%rip), %rdi       # 0x32f6
callq 0x1050
leaq 0xfee(%rip), %rdi       # 0x3309
callq 0x1050
leaq 0xffe(%rip), %rdi       # 0x3325
callq 0x1050
leaq 0x102e(%rip), %rdi      # 0x3361
callq 0x1050
leaq 0x1055(%rip), %rdi      # 0x3394
callq 0x1050
leaq 0x106c(%rip), %rdi      # 0x33b7
callq 0x1050
leaq 0x1091(%rip), %rdi      # 0x33e8
popq %rax
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x19b8
movq 0x8(%rbx), %rdi
callq 0x18bd
movq 0x8(%r15), %r14
leaq -0x64(%rip), %rdx       # 0x2447
movq %r14, %rdi
movq %rax, %rsi
callq 0x13bc
testl %eax, %eax
jne 0x24d3
movq 0x8(%rbx), %rdi
callq 0x1873
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x2, %eax
jne 0x24fd
movq %r15, %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x2258
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
xorl %esi, %esi
callq 0x2410
movq 0x3af4(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xc2a(%rip), %rdi       # 0x3138
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x1160
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
xorl %esi, %esi
callq 0x2258
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x2258
movq %rbx, %rdi
callq 0x1030
pushq $0x1
popq %rdi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movl %esi, %r14d
movq %rdi, 0x20(%rsp)
movl %edx, %eax
imull %esi, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1120
testq %rax, %rax
movq %rax, 0x8(%rsp)
je 0x52d5
xorl %r12d, %r12d
testl %r14d, %r14d
movl $0x0, %ebx
cmovgl %r14d, %ebx
movl %r14d, %r15d
movslq %r14d, %rcx
testl %ebp, %ebp
movl $0x0, %edx
movl %ebp, %r14d
cmovgl %ebp, %edx
movq %rdx, 0x18(%rsp)
shlq $0x2, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, %rbp
cmpq 0x18(%rsp), %r12
je 0x52f0
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x52cb
movq 0x20(%rsp), %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %r13d, %ecx
movl %r12d, %r8d
callq 0x5152
movl %eax, (%rbp,%r13,4)
incq %r13
jmp 0x52a6
incq %r12
addq 0x10(%rsp), %rbp
jmp 0x529c
movq 0x11d1c(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
leaq 0xcff9(%rip), %rsi      # 0x122df
pushq $0x2a
popq %rdx
xorl %eax, %eax
callq 0x10d0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq