LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_kmer_read
fmc64_v *fmc_kmer_read(FILE *fp, fmc_opt_t *opt)
{
	int i, n;
	char magic[4];
	fmc64_v *a;
	fread(magic, 1, 4, fp);
	if (strncmp(magic, FMC_KMER_MAGIC, 4) != 0) {
		fprintf(stderr, "[E::%s] invalid file magic\n", __func__);
		return 0;
	}
	fread(&opt->c, sizeof(fmc_collect_opt_t), 1, fp);
	n = 1<<opt->c.suf_len*2;
	a = malloc(sizeof(fmc64_v) * n);
	for (i = 0; i < n; ++i) {
		fread(&a[i].n, sizeof(size_t), 1, fp);
		a[i].m = a[i].n;
		a[i].a = malloc(8 * a[i].n);
		fread(a[i].a, 8, a[i].n, fp);
	}
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x24(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x20a0
leaq -0x24(%rbp), %rdi
leaq 0x23f7f(%rip), %rsi     # 0x2c591
movl $0x4, %edx
callq 0x2070
cmpl $0x0, %eax
je 0x864d
movq 0x2a9d0(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x23f64(%rip), %rsi     # 0x2c596
leaq 0x23f79(%rip), %rdx     # 0x2c5b2
movb $0x0, %al
callq 0x21d0
movq $0x0, -0x8(%rbp)
jmp 0x8766
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x30, %esi
movl $0x1, %edx
callq 0x20a0
movq -0x18(%rbp), %rax
movq (%rax), %rax
shlq $0x20, %rax
sarq $0x30, %rax
movl %eax, %ecx
shll %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rax
imulq $0x18, %rax, %rdi
callq 0x2230
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x875e
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x20a0
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
shlq $0x3, %rdi
callq 0x2230
movq %rax, %rcx
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x8, %esi
callq 0x20a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8699
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_batch_destroy
void fmc_batch_destroy(fmc_batch_t *b)
{
	int i;
	for (i = 0; i < b->n; ++i) {
		free(b->name[i]); free(b->s[i]); free(b->q[i]);
	}
	free(b->name); free(b->s); free(b->q); free(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x9338
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x92e3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_seq_cpy_no_del
void fmc_seq_cpy_no_del(ecseq_t *dst, const ecseq_t *src)
{
	int i;
	kv_resize(ecbase_t, *dst, src->n);
	dst->n = 0;
	memcpy(dst->a, src->a, src->n * sizeof(ecbase_t));
	for (i = 0; i < src->n; ++i)
		if (src->a[i].state != STATE_D)
			dst->a[dst->n++] = src->a[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x96cc
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0xc, 0x8(%rax), %rsi
callq 0x2270
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x96ce
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
imulq $0xc, (%rax), %rdx
callq 0x2200
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x977c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0xf, %ax
movzbl %al, %eax
cmpl $0x3, %eax
je 0x976f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x14(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
jmp 0x9771
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x96fd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_aux_destroy
void fmc_aux_destroy(fmc_aux_t *a)
{
	free(a->seq.a); free(a->ori.a); free(a->tmp[0].a); free(a->tmp[1].a);
	free(a->heap.a); free(a->stack.a);
	kh_destroy(kache, a->cache);
	free(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0xaf60
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: correct_func
static void correct_func(void *data, long i, int tid)
{
	for_correct_t *f = (for_correct_t*)data;
	if (fmc_verbose >= 5)
		fprintf(stderr, ">%s tid:%d heap:%ld stack:%ld kmercache:%d\n",
				f->name[i], tid, f->a[tid]->heap.m, f->a[tid]->stack.m, kh_n_buckets(f->a[tid]->cache));
	fmc_correct1(f->opt, f->h, &f->s[i], &f->q[i], f->a[tid], &f->ecs[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x5, 0x2610e(%rip)     # 0x331e0
jl 0xd149
movq 0x25f1d(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movq 0x80(%rax), %r8
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movq 0x98(%rax), %r9
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movq 0xa8(%rax), %rax
movl (%rax), %eax
leaq 0x1fa8f(%rip), %rsi     # 0x2cbce
movl %eax, (%rsp)
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %r8
movq (%rax,%r8,8), %r8
movq -0x20(%rbp), %rax
movq 0x28(%rax), %r9
imulq $0x28, -0x10(%rbp), %rax
addq %rax, %r9
callq 0xb1d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: path_adjustq
static void path_adjustq(int diff, ecseq_t *s1, const ecseq_t *s2)
{
	int i1 = 0, i2 = 0;
	while (i1 < s1->n && i2 < s2->n) {
		ecbase_t *b1;
		const ecbase_t *b2;
		b1 = &s1->a[i1];
		b2 = &s2->a[i2];
		if (b1->b != b2->b)
			b1->min_diff = b1->min_diff < diff? b1->min_diff : diff;
		if (b1->state == STATE_I && b2->state != STATE_I) ++i1;
		else if (b2->state == STATE_I && b1->state != STATE_I) ++i2;
		else ++i1, ++i2;
	}
	for (; i1 < s1->n; ++i1) {
		ecbase_t *b = &s1->a[i1];
		b->min_diff = b->min_diff < diff? b->min_diff : diff;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x1c(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x39(%rbp)
jae 0xe970
movslq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xe97c
jmp 0xea81
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
andw $0xf, %ax
movzbl %al, %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
andw $0xf, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xe9f6
movq -0x28(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
jge 0xe9e4
movq -0x28(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0xe9ea
movl -0x4(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x28(%rbp), %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0xf, %ax
movzbl %al, %eax
cmpl $0x2, %eax
jne 0xea2f
movq -0x30(%rbp), %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0xf, %ax
movzbl %al, %eax
cmpl $0x2, %eax
je 0xea2f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xea7c
movq -0x30(%rbp), %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0xf, %ax
movzbl %al, %eax
cmpl $0x2, %eax
jne 0xea68
movq -0x28(%rbp), %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0xf, %ax
movzbl %al, %eax
cmpl $0x2, %eax
je 0xea68
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xea7a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xea7c
jmp 0xe94d
jmp 0xea83
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xeade
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
jge 0xeac1
movq -0x38(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0xeac7
movl -0x4(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xea83
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/dfs.c
// Function: fm_dfs
void fm_dfs(int n, rld_t *const*e, int is_half, int max_k, int n_threads, fmdfs_f func, fmdfs2_f func2, void *data)
{
	extern void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n);
	shared_t d;
	int n_suf;
	d.n = n, d.e = e, d.data = data, d.func = func, d.func2 = func2, d.max_k = max_k; d.is_half = is_half;
	d.suf_len = max_k>>1 < DFS_SUF_LEN? max_k>>1 : DFS_SUF_LEN;
	n_suf = 1<<d.suf_len*2;
	n_threads = n_threads < n_suf? n_threads : n_suf;
	kt_for(n_threads, dfs_worker, &d, n_suf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x18(%rbp), %eax
sarl %eax
cmpl $0x5, %eax
jge 0x103fb
movl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x60(%rbp)
jmp 0x10405
movl $0x5, %eax
movl %eax, -0x60(%rbp)
jmp 0x10405
movl -0x60(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %ecx
shll %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x5c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jge 0x1042a
movl -0x1c(%rbp), %eax
movl %eax, -0x64(%rbp)
jmp 0x10430
movl -0x5c(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movslq -0x5c(%rbp), %rcx
leaq 0x1c(%rip), %rsi        # 0x10460
leaq -0x58(%rbp), %rdx
callq 0x2490
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/dfs.c
// Function: dfs_worker
static void dfs_worker(void *data, long suf, int tid)
{
	shared_t *d = (shared_t*)data;
	if (d->func) fm_dfs_core(d->n, d->e, d->is_half, d->max_k, d->suf_len, suf, d->func, d->data, tid);
	if (d->func2) fm_dfs2_core(d->n, d->e, d->is_half, d->max_k, d->suf_len, suf, d->func2, d->data, tid);
	if (dfs_verbose >= 4)
		fprintf(stderr, "[M::%s] processed suffix %ld in thread %d\n", __func__, suf, tid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x104d6
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x10(%rbp), %rax
movl %eax, %r9d
movq -0x20(%rbp), %rax
movq 0x20(%rax), %r11
movq -0x20(%rbp), %rax
movq 0x18(%rax), %r10
movl -0x14(%rbp), %eax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0xf440
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x10531
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x10(%rbp), %rax
movl %eax, %r9d
movq -0x20(%rbp), %rax
movq 0x28(%rax), %r11
movq -0x20(%rbp), %rax
movq 0x18(%rax), %r10
movl -0x14(%rbp), %eax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0xfc70
cmpl $0x4, 0x22cac(%rip)     # 0x331e4
jl 0x10561
movq 0x22ab7(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq 0x1c914(%rip), %rsi     # 0x2ce67
leaq 0x1c938(%rip), %rdx     # 0x2ce92
movb $0x0, %al
callq 0x21d0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/dfs.c
// Function: dfs_count
static void dfs_count(void *data, int tid, int k, char *path, const fmint6_t *size, int *cont)
{
	dfs_count_t *d = (dfs_count_t*)data;
	int c;
	uint64_t sum = 0;
	for (c = 0; c < 6; ++c) {
		if (size->c[c] < d->min_occ) *cont &= ~(1<<c);
		sum += size->c[c];
	}
	if (k < d->len) return;
	printf("%s\t%ld\n", path, (long)sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x6, -0x34(%rbp)
jge 0x10baa
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movslq 0xc(%rcx), %rcx
cmpq %rcx, %rax
jae 0x10b8b
movl -0x34(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
xorl $-0x1, %ecx
movq -0x28(%rbp), %rax
andl (%rax), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10b55
movl -0x10(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x10bb8
jmp 0x10bce
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0x1c2d6(%rip), %rdi     # 0x2ce9d
movb $0x0, %al
callq 0x2120
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/seq.c
// Function: write_seq
static void write_seq(const kseq_t *seq, kstring_t *out)
{
	kputc(seq->qual.l? '@' : '>', out);
	kputsn(seq->name.s, seq->name.l, out);
	if (seq->comment.l) {
		kputc(' ', out);
		kputsn(seq->comment.s, seq->comment.l, out);
	}
	kputc('\n', out);
	kputsn(seq->seq.s, seq->seq.l, out);
	if (seq->qual.l) {
		kputsn("\n+\n", 3, out);
		kputsn(seq->qual.s, seq->qual.l, out);
	}
	kputc('\n', out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movl $0x3e, %edi
movl $0x40, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
movq -0x10(%rbp), %rsi
callq 0x14930
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x14710
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x148b7
movq -0x10(%rbp), %rsi
movl $0x20, %edi
callq 0x14930
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x14710
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x14930
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x14710
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x14914
movq -0x10(%rbp), %rdx
leaq 0x18601(%rip), %rdi     # 0x2cef3
movl $0x3, %esi
callq 0x14710
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x14710
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x14930
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/mag.c
// Function: v128_cap
static inline void v128_cap(ku128_v *r, int max)
{
	int i, thres;
	if (r->n <= max) return;
	ks_introsort(128y, r->n, r->a);
	thres = r->a[max].y;
	for (i = 0; i < r->n; ++i)
		if (r->a[i].y == thres) break;
	r->n = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
ja 0x1ad51
jmp 0x1adcd
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x176b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1adc2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1adb5
jmp 0x1adc2
jmp 0x1adb7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1ad86
movslq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/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;
	double t;
	t = cputime();
	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 in %.3f sec\n", __func__, (long)n, cputime() - t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x4cd0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1b1bc
cmpl $0x0, -0xc(%rbp)
je 0x1b170
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x68, %rax, %rax
addq %rax, %rdi
addq $0x20, %rdi
callq 0x19700
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x68, %rax, %rax
addq %rax, %rdi
addq $0x20, %rdi
addq $0x18, %rdi
callq 0x19700
jmp 0x1b1ac
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x68, %rax, %rax
addq %rax, %rdi
addq $0x20, %rdi
callq 0x19210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x68, %rax, %rax
addq %rax, %rdi
addq $0x20, %rdi
addq $0x18, %rdi
callq 0x19210
jmp 0x1b1ae
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b11b
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1b25b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x1b1f6
jmp 0x1b24d
jmp 0x1b1f8
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x1bee0
cmpl $0x0, %eax
jne 0x1b21b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b1f8
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1bd50
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x1bee0
cmpl $0x0, %eax
jne 0x1b24b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b228
jmp 0x1b24d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b1c3
leaq 0x1805e(%rip), %rax     # 0x332c0
cmpl $0x3, (%rax)
jl 0x1b2a4
movq 0x17d8a(%rip), %rax     # 0x32ff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4cd0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rcx
subsd -0x28(%rbp), %xmm0
leaq 0x11f7d(%rip), %rsi     # 0x2d213
leaq 0x11fb6(%rip), %rdx     # 0x2d253
movb $0x1, %al
callq 0x21d0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/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};
	double t;

	t = cputime();
	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 in %.3f sec (min_len=%d, min_nsr=%d)\n", __func__, a.n, cputime() - t, min_len, min_nsr);
	return a.n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2160
callq 0x4cd0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1eec8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x1ee3a
movq -0x40(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x1ee3c
movq -0x40(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jbe 0x1ee3c
jmp 0x1eeba
movq -0x40(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x1ee53
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
jl 0x1ee55
jmp 0x1eeba
jmp 0x1ee57
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1ee9d
cmpq $0x0, -0x28(%rbp)
je 0x1ee75
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x48(%rbp)
jmp 0x1ee80
movl $0x2, %eax
movq %rax, -0x48(%rbp)
jmp 0x1ee80
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0x2270
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x1eeba
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1edf3
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cef0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x1ef06
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1b990
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1eedc
movq -0x20(%rbp), %rdi
callq 0x2040
leaq 0x143aa(%rip), %rax     # 0x332c0
cmpl $0x3, (%rax)
jl 0x1ef60
movq 0x140d6(%rip), %rax     # 0x32ff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x4cd0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rcx
subsd -0x38(%rbp), %xmm0
movl -0xc(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0xe30d(%rip), %rsi      # 0x2d25f
leaq 0xe345(%rip), %rdx      # 0x2d29e
movb $0x1, %al
callq 0x21d0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/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};
	double t;

	t = cputime();
	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 in %.3f sec (min_len=%d, min_nsr=%d)\n", __func__, a.n, cputime() - t, min_len, min_nsr);
	return a.n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2160
callq 0x4cd0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1f063
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x1f053
movq -0x40(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x1f053
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
jge 0x1f053
jmp 0x1eff0
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1f036
cmpq $0x0, -0x28(%rbp)
je 0x1f00e
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x48(%rbp)
jmp 0x1f019
movl $0x2, %eax
movq %rax, -0x48(%rbp)
jmp 0x1f019
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0x2270
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x1f053
jmp 0x1f055
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1efa6
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cef0
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x1f0a4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x14(%rbp), %edx
callq 0x1bb10
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f077
movq -0x20(%rbp), %rdi
callq 0x2040
leaq 0x1420c(%rip), %rax     # 0x332c0
cmpl $0x3, (%rax)
jl 0x1f0fe
movq 0x13f38(%rip), %rax     # 0x32ff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x4cd0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rcx
subsd -0x38(%rbp), %xmm0
movl -0xc(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0xe1bc(%rip), %rsi      # 0x2d2ac
leaq 0xe201(%rip), %rdx      # 0x2d2f8
movb $0x1, %al
callq 0x21d0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/mag.c
// Function: mag_init_opt
magopt_t *mag_init_opt()
{
	magopt_t *o;

	o = calloc(1, sizeof(magopt_t));
	o->flag = MAG_F_READnMERGE;
	o->max_arc = 512;
	o->min_dratio0 = 0.6;
	o->trim_len = 0;
	o->trim_depth = 6;

	o->min_elen = 300;
	o->min_ovlp = 0;
	o->min_merge_len = 0;
	o->min_ensr = 4;
	o->min_insr = 3;
	o->min_dratio1 = 0.7;

	o->max_bcov = 10.;
	o->max_bfrac = 0.15;
	o->max_bvtx = 64;
	o->max_bdist = 512;
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x3c, %esi
callq 0x21a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x4, (%rax)
movq -0x8(%rbp), %rax
movl $0x200, 0x4(%rax)       # imm = 0x200
movq -0x8(%rbp), %rax
movss 0xd970(%rip), %xmm0     # 0x2cf1c
movss %xmm0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x6, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x14(%rax)
movq -0x8(%rbp), %rax
movss 0xd90e(%rip), %xmm0     # 0x2cf18
movss %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
movss 0xd8f9(%rip), %xmm0     # 0x2cf14
movss %xmm0, 0x34(%rax)
movq -0x8(%rbp), %rax
movss 0xd8e4(%rip), %xmm0     # 0x2cf10
movss %xmm0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x40, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x200, 0x18(%rax)      # imm = 0x200
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/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 aggressive)
{
	int64_t i, n_examined = 0, n_popped = 0;
	int ret;
	double t;

	t = cputime();
	for (i = 0; i < g->v.n; ++i) {
		ret = mag_vh_pop_simple(g, i<<1|0, max_cov, max_frac, aggressive);
		if (ret >= 1) ++n_examined;
		if (ret >= 2) ++n_popped;
		ret = mag_vh_pop_simple(g, i<<1|1, max_cov, max_frac, 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 in %.3f sec\n", __func__, (long)n_examined, (long)n_popped, cputime() - t);
	mag_g_merge(g, 0, min_merge_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
callq 0x4cd0
movsd %xmm0, -0x40(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x25ef2
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq %rsi
orq $0x0, %rsi
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movl -0x18(%rbp), %edx
callq 0x255c0
movl %eax, -0x34(%rbp)
cmpl $0x1, -0x34(%rbp)
jl 0x25e85
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpl $0x2, -0x34(%rbp)
jl 0x25e97
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq %rsi
orq $0x1, %rsi
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movl -0x18(%rbp), %edx
callq 0x255c0
movl %eax, -0x34(%rbp)
cmpl $0x1, -0x34(%rbp)
jl 0x25ecd
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpl $0x2, -0x34(%rbp)
jl 0x25edf
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x25ee1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x25e3e
leaq 0xd3c7(%rip), %rax      # 0x332c0
cmpl $0x3, (%rax)
jl 0x25f47
movq 0xd0f3(%rip), %rax      # 0x32ff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x4cd0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r8
subsd -0x40(%rbp), %xmm0
leaq 0x7ce7(%rip), %rsi      # 0x2dc20
leaq 0x7d19(%rip), %rdx      # 0x2dc59
movb $0x1, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x1b0f0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/bubble.c
// Function: mag_g_pop_open
void mag_g_pop_open(mag_t *g, int min_elen)
{
	int64_t i;
	double t;
	t = cputime();
	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 in %.3f sec\n", __func__, cputime() - t);
	mag_g_merge(g, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x4cd0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x266f8
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
imulq $0x68, -0x18(%rbp), %rax
addq %rax, %rsi
movl -0xc(%rbp), %edx
callq 0x25f60
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x266c1
leaq 0xcbc1(%rip), %rax      # 0x332c0
cmpl $0x3, (%rax)
jl 0x26735
movq 0xc8ed(%rip), %rax      # 0x32ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x4cd0
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
leaq 0x7543(%rip), %rsi      # 0x2dc6a
leaq 0x7564(%rip), %rdx      # 0x2dc92
movb $0x1, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1b0f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sa.c
// Function: fm_sa_gen
fmsa_t *fm_sa_gen(const rld_t *e, int ssa_shift, int n_threads)
{
	extern void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n);
	fmsa_t *sa;
	worker_t *w;
	int i;

	sa = calloc(1, sizeof(fmsa_t));
	sa->ss = ssa_shift;
	sa->m = e->mcnt[1];
	for (sa->ms = 1; 1LL<<sa->ms < sa->m; ++sa->ms);
	sa->n_ssa = (e->mcnt[0] - e->mcnt[1] + (1<<sa->ss) - 1) >> sa->ss;
	sa->r2i = calloc(sa->m, 8);
	sa->ssa = calloc(sa->n_ssa, 8);

	w = calloc(1, sizeof(worker_t));
	w->buf = calloc(n_threads, sizeof(uint64_v));
	w->sa = sa;
	w->e = e;

	kt_for(n_threads, worker, w, sa->m);

	for (i = 0; i < n_threads; ++i) free(w->buf[i].a);
	free(w->buf); free(w);
	return sa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x21a0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x267c6
jmp 0x267b9
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2679d
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq 0x8(%rcx), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
subq $0x1, %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
shrq %cl, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x8, %esi
callq 0x21a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x8, %esi
callq 0x21a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, %edi
movl $0x18, %esi
callq 0x21a0
movq %rax, -0x20(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x21a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x10(%rbp), %edi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x61(%rip), %rsi        # 0x26900
callq 0x2490
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x268da
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2040
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x268ab
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sa.c
// Function: fm_sa
int64_t fm_sa(const rld_t *e, const fmsa_t *sa, int64_t k, int64_t *si)
{
	int c, mask = (1<<sa->ss) - 1;
	int64_t x = 0;
	uint64_t ok[e->asize1];
	*si = -1;
	if (k >= e->mcnt[0]) return -1;
	while (k < e->mcnt[1] || ((k - e->mcnt[1]) & mask)) {
		++x;
		c = rld_rank1a(e, k + 1, ok);
		k = e->cnt[c] + ok[c] - 1;
		if (c == 0) {
			*si = sa->r2i[k];
			return x - 1;
		}
	}
	k = (k - e->mcnt[1]) >> sa->ss;
	*si = sa->ssa[k] & ((1ULL<<sa->ms) - 1);
	return x + (sa->ssa[k] >> sa->ms);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb 0x4(%rax), %cl
movl $0x1, %eax
shll %cl, %eax
decl %eax
movl %eax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %edx
movl %edx, %eax
movq %rsp, %rcx
movq %rcx, -0x40(%rbp)
movl %edx, %ecx
leal 0xf(,%rcx,8), %ecx
andl $-0x10, %ecx
movl %ecx, %edx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rcx, %rsp
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq $-0x1, (%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq (%rcx), %rax
jb 0x26a23
movq $-0x1, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x26b6d
jmp 0x26a25
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
movb $0x1, %al
cmpq 0x8(%rdx), %rcx
movb %al, -0x59(%rbp)
jb 0x26a5d
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq 0x8(%rcx), %rax
movslq -0x30(%rbp), %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x26a69
jmp 0x26aeb
movq -0x58(%rbp), %rdx
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x3f60
movq -0x58(%rbp), %rcx
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movslq -0x2c(%rbp), %rdx
addq (%rcx,%rdx,8), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x26ae6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x26b6d
jmp 0x26a25
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq 0x8(%rcx), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
shrq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq -0x68(%rbp), %rcx
subq $0x1, %rax
andq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rsp
movq -0x8(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sa.c
// Function: fm_sa_dump
int fm_sa_dump(const fmsa_t *sa, const char *fn)
{
	uint32_t y;
	FILE *fp;
	fp = fn && strcmp(fn, "-")? fopen(fn, "wb") : fdopen(fileno(stdout), "wb");
	if (fp == 0) return -1;
	y = sa->ss; fwrite(&y, 4, 1, fp);
	y = sa->ms; fwrite(&y, 4, 1, fp);
	fwrite(&sa->m, 8, 1, fp);
	fwrite(&sa->n_ssa, 8, 1, fp);
	fwrite(sa->r2i, 8, sa->m, fp);
	fwrite(sa->ssa, 8, sa->n_ssa, fp);
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x26bc2
movq -0x18(%rbp), %rdi
leaq 0x5f93(%rip), %rsi      # 0x2cb35
callq 0x21b0
cmpl $0x0, %eax
je 0x26bc2
movq -0x18(%rbp), %rdi
leaq 0x5486(%rip), %rsi      # 0x2c03d
callq 0x22e0
movq %rax, -0x30(%rbp)
jmp 0x26be3
movq 0xc3f7(%rip), %rax      # 0x32fc0
movq (%rax), %rdi
callq 0x2210
movl %eax, %edi
leaq 0x5463(%rip), %rsi      # 0x2c03d
callq 0x2280
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x26bfe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26cc1
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2320
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2320
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2320
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x28(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2320
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rcx
movl $0x8, %esi
callq 0x2320
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x28(%rbp), %rcx
movl $0x8, %esi
callq 0x2320
movq -0x28(%rbp), %rdi
callq 0x20e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sa.c
// Function: fm_sa_restore
fmsa_t *fm_sa_restore(const char *fn)
{
	FILE *fp;
	uint32_t y;
	fmsa_t *sa;
	fp = fn && strcmp(fn, "-")? fopen(fn, "rb") : fdopen(fileno(stdin), "rb");
	if (fp == 0) return 0;
	sa = calloc(1, sizeof(fmsa_t));
	fread(&y, 4, 1, fp); sa->ss = y;
	fread(&y, 4, 1, fp); sa->ms = y;
	fread(&sa->m, 8, 1, fp);
	fread(&sa->n_ssa, 8, 1, fp);
	sa->r2i = calloc(sa->m, 8);
	sa->ssa = calloc(sa->n_ssa, 8);
	if (sa->ssa == 0 || sa->r2i == 0) {
		free(sa->r2i); free(sa->ssa); free(sa);
		return 0;
	}
	fread(sa->r2i, 8, sa->m, fp);
	fread(sa->ssa, 8, sa->n_ssa, fp);
	fclose(fp);
	return sa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x26d0e
movq -0x10(%rbp), %rdi
leaq 0x5e47(%rip), %rsi      # 0x2cb35
callq 0x21b0
cmpl $0x0, %eax
je 0x26d0e
movq -0x10(%rbp), %rdi
leaq 0x5342(%rip), %rsi      # 0x2c045
callq 0x22e0
movq %rax, -0x30(%rbp)
jmp 0x26d2f
movq 0xc2b3(%rip), %rax      # 0x32fc8
movq (%rax), %rdi
callq 0x2210
movl %eax, %edi
leaq 0x531f(%rip), %rsi      # 0x2c045
callq 0x2280
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x26d4b
movq $0x0, -0x8(%rbp)
jmp 0x26e9f
movl $0x1, %edi
movl $0x28, %esi
callq 0x21a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x20a0
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x20a0
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x20a0
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x20a0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x8, %esi
callq 0x21a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x8, %esi
callq 0x21a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x26e25
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x26e52
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x26e9f
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x8, %esi
callq 0x20a0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x8, %esi
callq 0x20a0
movq -0x18(%rbp), %rdi
callq 0x20e0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sa.c
// Function: main_sa
int main_sa(int argc, char *argv[])
{
	int c, n_threads = 1, ssa_shift = 6;
	fmsa_t *sa;
	rld_t *e;
	char *fn = 0;

	while ((c = getopt(argc, argv, "t:s:o:")) >= 0) {
		if (c == 't') n_threads = atoi(optarg);
		else if (c == 's') ssa_shift = atoi(optarg);
		else if (c == 'o') fn = optarg;
	}
	if (argc == optind) {
		fprintf(stderr, "Usage: fermi2 sa [-t nThreads=%d] [-s stepShift=%d] <in.fmd>\n", n_threads, ssa_shift);
		return 1;
	}
	e = rld_restore(argv[optind]);
	if (e == 0) {
		fprintf(stderr, "[E::%s] failed to load the FM-index\n", __func__);
		return 1;
	}
	sa = fm_sa_gen(e, ssa_shift, n_threads);
	//{int64_t i;for (i = 0; i < sa->n_ssa; ++i) fprintf(stderr, "S(%lld)=%lld\n", (i<<sa->ss) + e->mcnt[1], sa->ssa[i]>>sa->ms);}

	fm_sa_dump(sa, fn);
	rld_destroy(e);
	fm_sa_destroy(sa);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x6, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x6dbe(%rip), %rdx      # 0x2dca1
callq 0x2300
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x26f3e
cmpl $0x74, -0x14(%rbp)
jne 0x26f0a
movq 0xc0db(%rip), %rax      # 0x32fd8
movq (%rax), %rdi
callq 0x2310
movl %eax, -0x18(%rbp)
jmp 0x26f3c
cmpl $0x73, -0x14(%rbp)
jne 0x26f24
movq 0xc0c1(%rip), %rax      # 0x32fd8
movq (%rax), %rdi
callq 0x2310
movl %eax, -0x1c(%rbp)
jmp 0x26f3a
cmpl $0x6f, -0x14(%rbp)
jne 0x26f38
movq 0xc0a7(%rip), %rax      # 0x32fd8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x26f3a
jmp 0x26f3c
jmp 0x26ed5
movl -0x8(%rbp), %eax
movq 0xc088(%rip), %rcx      # 0x32fd0
cmpl (%rcx), %eax
jne 0x26f76
movq 0xc0a5(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq 0x6d45(%rip), %rsi      # 0x2dca8
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x4(%rbp)
jmp 0x26ff9
movq -0x10(%rbp), %rax
movq 0xc04f(%rip), %rcx      # 0x32fd0
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x37c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x26fc0
movq 0xc059(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
leaq 0x6d3d(%rip), %rsi      # 0x2dce6
leaq 0x6d5b(%rip), %rdx      # 0x2dd0b
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x4(%rbp)
jmp 0x26ff9
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x26750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x26b80
movq -0x30(%rbp), %rdi
callq 0x28f0
movq -0x28(%rbp), %rdi
callq 0x26950
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)