LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/unpack.c
// Function: hts_readlines
char **hts_readlines(const char *fn, int64_t *_n)
{
	int64_t m = 0, n = 0;
	int dret;
	char **s = 0;
	gzFile fp;
	if ((fp = gzopen(fn, "r")) != 0) { // read from file
		kstream_t *ks;
		kstring_t str;
		str.s = 0; str.l = str.m = 0;
		ks = ks_init(fp);
		while (ks_getuntil(ks, KS_SEP_LINE, &str, &dret) >= 0) {
			if (str.l == 0) continue;
			if (m == n) {
				m = m? m<<1 : 16;
				s = (char**)realloc(s, m * sizeof(void*));
			}
			s[n++] = strdup(str.s);
		}
		ks_destroy(ks);
		gzclose(fp);
		s = (char**)realloc(s, n * sizeof(void*));
		free(str.s);
	} else if (*fn == ':') { // read from string
		const char *q, *p;
		for (q = p = fn + 1;; ++p)
			if (*p == ',' || *p == 0) {
				if (m == n) {
					m = m? m<<1 : 16;
					s = (char**)realloc(s, m * sizeof(void*));
				}
				s[n] = (char*)calloc(p - q + 1, 1);
				strncpy(s[n++], q, p - q);
				q = p + 1;
				if (*p == 0) break;
			}
	} else return 0;
	s = (char**)realloc(s, n * sizeof(void*));
	*_n = n;
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x15f9a(%rip), %rsi     # 0x1c384
callq 0x22b0
testq %rax, %rax
je 0x6506
movq %rax, %r13
movq %rbx, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq %rax, %rdi
callq 0xd614
movq %rax, %r12
xorl %ebx, %ebx
leaq 0x44(%rsp), %rbp
movq $0x0, 0x8(%rsp)
xorl %r15d, %r15d
movq %r12, %rdi
movl $0x2, %esi
movq %r14, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
callq 0xd675
testl %eax, %eax
js 0x64b0
cmpl $0x0, 0x20(%rsp)
je 0x642a
cmpq %rbx, %r15
jne 0x6486
movq %r13, 0x38(%rsp)
leaq (%r15,%r15), %r13
testq %r15, %r15
movl $0x10, %eax
cmoveq %rax, %r13
leaq (,%r13,8), %rsi
movq 0x8(%rsp), %rdi
callq 0x2260
movq %rax, %r15
movq %r13, 0x10(%rsp)
movq 0x38(%rsp), %r13
jmp 0x6490
movq %r15, 0x10(%rsp)
movq 0x8(%rsp), %r15
movq 0x28(%rsp), %rdi
callq 0x2340
movq %r15, 0x8(%rsp)
movq %rax, (%r15,%rbx,8)
incq %rbx
movq 0x10(%rsp), %r15
jmp 0x642a
movq %r12, %rdi
callq 0xd659
movq %r13, %rdi
callq 0x2030
leaq (,%rbx,8), %rsi
movq 0x8(%rsp), %rdi
callq 0x2260
movq %rax, %r15
movq 0x28(%rsp), %rdi
callq 0x2040
leaq (,%rbx,8), %rsi
movq %r15, %rdi
callq 0x2260
movq 0x18(%rsp), %rcx
movq %rbx, (%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x3a, (%r14)
jne 0x65b0
movq %rbx, 0x18(%rsp)
leaq 0x1(%r14), %rbp
addq $0x2, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
xorl %ecx, %ecx
movq %rbp, %r12
movzbl -0x1(%r14), %eax
cmpl $0x2c, %eax
je 0x6535
testl %eax, %eax
jne 0x65a5
cmpq %rbx, %rcx
jne 0x6564
leaq (%rcx,%rcx), %r13
testq %rcx, %rcx
movl $0x10, %eax
cmoveq %rax, %r13
leaq (,%r13,8), %rsi
movq %r15, %rdi
callq 0x2260
movq %rax, %r15
movq %r13, 0x8(%rsp)
jmp 0x6569
movq %rcx, 0x8(%rsp)
movq %rbp, %r13
subq %r12, %r13
leaq 0x1(%r13), %rdi
movl $0x1, %esi
callq 0x2190
movq %rax, (%r15,%rbx,8)
incq %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2060
cmpb $0x0, -0x1(%r14)
movq %r14, %r12
movq 0x8(%rsp), %rcx
je 0x64df
incq %r14
incq %rbp
jmp 0x6527
xorl %eax, %eax
jmp 0x64f7
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/unpack.c
// Function: main_unpack
int main_unpack(int argc, char *argv[])
{
	int64_t i, n;
	int c;
	rld_t *e;
	kstring_t str = {0,0,0};

	while ((c = getopt(argc, argv, "")) >= 0);
	if (optind == argc) {
		fprintf(stderr, "Usage: fermi2 unpack <reads.rld> [list|file]\n");
		return 1;
	}
	e = rld_restore(argv[optind]);
	if (optind + 1 < argc) {
		char *p, **list;
		list = hts_readlines(argv[optind+1], &n);
		if (list == 0) return 1;
		for (i = 0; i < n; ++i) {
			if (isdigit(list[i][0])) {
				int64_t x = strtol(list[i], &p, 10);
				if (x < e->mcnt[1]) print1(e, x, &str);
			}
			free(list[i]);
		}
		free(list);
	} else for (i = 0; i < e->mcnt[1]; ++i) print1(e, i, &str);
	free(str.s);
	rld_destroy(e);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x16015(%rip), %rbx     # 0x1c5ed
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22f0
testl %eax, %eax
jns 0x65d8
movq 0x1d9e0(%rip), %r15     # 0x23fd0
movslq (%r15), %rax
cmpl %ebp, %eax
je 0x66e2
movq (%r14,%rax,8), %rdi
callq 0x436c
movq %rax, %rbx
movslq (%r15), %rax
leal 0x1(%rax), %ecx
cmpl %ebp, %ecx
jge 0x66a0
movq 0x8(%r14,%rax,8), %rdi
leaq 0x18(%rsp), %rsi
callq 0x63cf
testq %rax, %rax
je 0x66e7
movq %rax, %r14
movq 0x18(%rsp), %r13
testq %r13, %r13
jle 0x6691
xorl %r12d, %r12d
callq 0x2360
movq %rax, %r15
movq (%r15), %rax
movq (%r14,%r12,8), %rbp
movsbq (%rbp), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x6681
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
movl $0xa, %edx
callq 0x21e0
movq 0x28(%rbx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x6681
movq %rbx, %rdi
movl %eax, %esi
movq %rsp, %rdx
callq 0x66fb
movq %rbp, %rdi
callq 0x2040
incq %r12
cmpq %r12, %r13
jne 0x6645
movq %r14, %rdi
callq 0x2040
testq %r14, %r14
jne 0x66cc
jmp 0x66e7
movq 0x28(%rbx), %rax
cmpq $0x0, 0x8(%rax)
je 0x66cc
xorl %r14d, %r14d
movq %rsp, %r15
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x66fb
incq %r14
movq 0x28(%rbx), %rax
cmpq 0x8(%rax), %r14
jb 0x66b1
movq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x38cc
xorl %eax, %eax
jmp 0x66ec
callq 0x2403
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/unpack.c
// Function: print1
static void print1(const rld_t *e, int i, kstring_t *s)
{
	int64_t k;
	int j, tmp;
	k = fm_retrieve(e, i, s);
	for (j = 0; j < s->l; ++j)
		s->s[j] = "$ACGTN"[(int)s->s[j]];
	for (j = 0; j < s->l>>1; ++j) // reverse
		tmp = s->s[j], s->s[j] = s->s[s->l-1-j], s->s[s->l-1-j] = tmp;
	fwrite(s->s, 1, s->l, stdout);
	printf("\t%ld\n", (long)k);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movslq %esi, %rsi
callq 0x62f8
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x6738
xorl %eax, %eax
leaq 0x15c98(%rip), %rcx     # 0x1c3b4
movq 0x8(%r14), %rdx
movsbq (%rdx,%rax), %rsi
movb (%rsi,%rcx), %sil
movb %sil, (%rdx,%rax)
incq %rax
movl (%r14), %edx
cmpq %rdx, %rax
jb 0x671c
movl (%r14), %eax
cmpl $0x2, %eax
jb 0x6775
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
movq 0x8(%r14), %rsi
movb (%rsi,%rdx), %dil
addl %ecx, %eax
movb (%rsi,%rax), %al
movb %al, (%rsi,%rdx)
movq 0x8(%r14), %rax
movl (%r14), %esi
addl %ecx, %esi
movb %dil, (%rax,%rsi)
incq %rdx
movl (%r14), %eax
movl %eax, %esi
shrl %esi
decl %ecx
cmpq %rsi, %rdx
jb 0x6747
movq 0x8(%r14), %rdi
movl %eax, %edx
movq 0x1d83e(%rip), %rax     # 0x23fc0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x2310
leaq 0x1672b(%rip), %rdi     # 0x1cec1
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
nop
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_opt_init
void fmc_opt_init(fmc_opt_t *opt)
{
	memset(opt, 0, sizeof(fmc_opt_t));
	opt->c.k = 17;
	opt->c.suf_len = 1;
	opt->c.min_occ = 3;
	opt->c.q1_depth = 17; // if there q1_depth bases but only one 2nd-best, correct regardless of the quality
	opt->c.max_ec_depth = opt->c.min_occ - 1; // if there are more than max_ec_depth 2nd-best bases, don't correct
	opt->c.a1 = 0.05;
	opt->c.a2 = 10;
	opt->c.err = 0.005;
	opt->c.prior = 0.99;

	opt->n_threads = 1;
	opt->defQ = 17;
	opt->ecQ = 30;
	opt->max_heap_size = 256;
	opt->max_penalty_diff = 60;
	opt->batch_size = (1ULL<<28) - (1ULL<<20);
	opt->max_dist4 = 8;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x40(%rdi)
movl $0x11, 0x8(%rdi)
movabsq $0x2000300010011, %rax  # imm = 0x2000300010011
movq %rax, (%rdi)
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
movq %rax, 0x10(%rdi)
movabsq $0x4024000000000000, %rax # imm = 0x4024000000000000
movq %rax, 0x18(%rdi)
movabsq $0x3f747ae147ae147b, %rax # imm = 0x3F747AE147AE147B
movq %rax, 0x20(%rdi)
movabsq $0x3fefae147ae147ae, %rax # imm = 0x3FEFAE147AE147AE
movq %rax, 0x28(%rdi)
movaps 0x15bb3(%rip), %xmm0    # 0x1c3c0
movups %xmm0, 0x30(%rdi)
movl $0x3c, 0x40(%rdi)
movq $0xff00000, 0x50(%rdi)  # imm = 0xFF00000
movl $0x8, 0x48(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_beta_binomial
double fmc_beta_binomial(int n, int k, double a, double b) // beta-binomial density
{
	double x, y, z;
	x = lgamma(n + 1) - (lgamma(k + 1) + lgamma(n - k + 1));
	y = lgamma(k + a) + lgamma(n - k + b) - lgamma(n + a + b);
	z = lgamma(a + b) - (lgamma(a) + lgamma(b));
	return exp(x + y + z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %r14d
movl %edi, %ebx
leal 0x1(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x21d0
movsd %xmm0, 0x10(%rsp)
leal 0x1(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x21d0
movsd %xmm0, (%rsp)
movl %ebx, %r15d
subl %r14d, %r15d
leal 0x1(%r15), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x21d0
addsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
addsd 0x8(%rsp), %xmm0
callq 0x21d0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
addsd 0x18(%rsp), %xmm0
callq 0x21d0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
addsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
callq 0x21d0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
addsd 0x10(%rsp), %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
callq 0x21d0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x21d0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x21d0
addsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
addsd (%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2350
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_precal_qtab
uint8_t *fmc_precal_qtab(int max, double e1, double e2, double a1, double a2, double prior1)
{ // precalculate a lookup table q(n,k), the consensus quality given n bases with k differences
	int n, k;
	uint8_t *qtab;
	double b1 = a1 * (1 - e1) / e1, b2 = a2 * (1 - e2) / e2;

	assert(FMC_Q_MAX>>1 < FMC_Q_1);
	qtab = calloc(max * max, 1);
	for (n = 1; n < max; ++n) {
		uint8_t *qn = &qtab[n*max];
		//fprintf(stderr, "=> %d <=", n);
		for (k = 0; k < n; ++k) {
			double p1, p2;
			int q;
			p1 = fmc_beta_binomial(n, k, a1, b1);
			p2 = fmc_beta_binomial(n, k, a2, b2);
			q = (int)(-4.343 * log(1. - p1 * prior1 / (p1 * prior1 + p2 * (1-prior1))) + .499);
			qn[k] = (q < FMC_Q_MAX? q : FMC_Q_MAX) >> 1;
			//if (q) fprintf(stderr, "\t%d:%d", k, q);
		}
		//fprintf(stderr, "\n");
	}
	return qtab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %edi, %ebp
imull %edi, %edi
movl $0x1, %ebx
movl $0x1, %esi
callq 0x2190
movq %rax, %r14
cmpl $0x2, %ebp
jl 0x6bd9
movsd 0x1596e(%rip), %xmm0    # 0x1c450
movapd %xmm0, %xmm1
movsd (%rsp), %xmm2
subsd %xmm2, %xmm1
mulsd 0x10(%rsp), %xmm1
divsd %xmm2, %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm3
subsd %xmm3, %xmm2
mulsd 0x18(%rsp), %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, 0x30(%rsp)
subsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl %ebp, %r12d
movq %r14, %r13
addq %r12, %r13
movl $0x29, %ebp
movsd %xmm1, (%rsp)
xorl %r15d, %r15d
movl %ebx, %edi
movl %r15d, %esi
movsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x6965
movsd %xmm0, 0x8(%rsp)
movl %ebx, %edi
movl %r15d, %esi
movsd 0x18(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq 0x6965
movsd 0x8(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm0
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd 0x158c4(%rip), %xmm0    # 0x1c450
subsd %xmm1, %xmm0
callq 0x2160
movsd 0x158eb(%rip), %xmm2    # 0x1c488
mulsd %xmm2, %xmm0
movsd 0x158e7(%rip), %xmm2    # 0x1c490
addsd %xmm2, %xmm0
cvttsd2si %xmm0, %eax
cmpl $0x29, %eax
cmovgel %ebp, %eax
shrl %eax
movb %al, (%r13,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x6b39
incq %rbx
addq %r12, %r13
cmpq %r12, %rbx
jne 0x6b36
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_traverse
rldintv_t *fmc_traverse(const rld_t *e, int depth) // traverse FM-index up to $depth
{
	rldintv_v stack = {0,0,0};
	rldintv_t *p, *ret;
	uint64_t x;

	ret = calloc(1<<depth*2, sizeof(rldintv_t));
	kv_pushp(rldintv_t, stack, &p);
	p->x[0] = p->x[1] = 0, p->x[2] = e->mcnt[0], p->info = 0;
	x = 0;
	while (stack.n) {
		rldintv_t top = kv_pop(stack);
		if (top.info>>2 > 0) {
			int shift = ((top.info>>2) - 1) << 1;
			x = (x & ~(3ULL<<shift)) | (uint64_t)(top.info&3)<<shift;
		}
		if (top.info>>2 != depth) {
			int c;
			rldintv_t t[6];
			rld_extend(e, &top, t, 1);
			for (c = 1; c < 5; ++c) {
				if (t[c].x[2] == 0) continue;
				t[c].info = ((top.info>>2) + 1) << 2 | (c - 1);
				kv_push(rldintv_t, stack, t[c]);
			}
		} else ret[x] = top, ret[x].info = x;
	}
	free(stack.a);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %r12d
movq %rdi, %rbx
leal (%r12,%r12), %ecx
movl $0x1, %edi
shll %cl, %edi
movl $0x20, %esi
callq 0x2190
movq %rax, (%rsp)
movl $0x40, %edi
callq 0x2220
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, 0x10(%rsp)
movq 0x28(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq $0x0, 0x18(%r15)
movslq %r12d, %rdi
movl $0x1, %ebx
xorl %r8d, %r8d
movl $0x2, %r13d
movq %rdi, 0x8(%rsp)
decq %rbx
movq %rbx, %rax
shlq $0x5, %rax
movups (%r15,%rax), %xmm0
movups 0x10(%r15,%rax), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdx
cmpq $0x4, %rdx
jb 0x6ca9
movl %edx, %ecx
shrl %ecx
addb $-0x2, %cl
andb $-0x2, %cl
movl $0x3, %esi
shlq %cl, %rsi
notq %rsi
andq %rsi, %r8
movl %edx, %esi
andl $0x3, %esi
shlq %cl, %rsi
orq %rsi, %r8
shrq $0x2, %rdx
cmpq %rdi, %rdx
jne 0x6cda
addq %r15, %rax
movq %r8, %rcx
shlq $0x5, %rcx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movq (%rsp), %rax
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq %r8, 0x18(%rax,%rcx)
jmp 0x6d83
movq %r8, 0x18(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movl $0x1, %ecx
callq 0x5027
xorl %r14d, %r14d
leaq 0x78(%rsp), %r12
cmpq $0x0, -0x8(%r12)
je 0x6d6c
movq 0x38(%rsp), %rax
andq $-0x4, %rax
addq $0x4, %rax
orq %r14, %rax
movq %rax, (%r12)
cmpq %r13, %rbx
jne 0x6d4a
leaq (,%r13,2), %rbp
testq %r13, %r13
movl $0x2, %eax
cmoveq %rax, %rbp
movq %rbp, %rsi
shlq $0x5, %rsi
movq %r15, %rdi
callq 0x2260
movq %rax, %r15
movq %rbp, %r13
leaq -0x18(%r12), %rax
leaq 0x1(%rbx), %rcx
shlq $0x5, %rbx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%r15,%rbx)
movups %xmm0, (%r15,%rbx)
movq %rcx, %rbx
addq $0x20, %r12
incq %r14
cmpq $0x4, %r14
jne 0x6d00
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r8
testq %rbx, %rbx
jne 0x6c5c
movq %r15, %rdi
callq 0x2040
movq (%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_kmer_write
void fmc_kmer_write(FILE *fp, const fmc_opt_t *opt, const fmc64_v *a)
{
	int i, n = 1<<opt->c.suf_len*2;
	fwrite(FMC_KMER_MAGIC, 1, 4, fp);
	fwrite(&opt->c, sizeof(fmc_collect_opt_t), 1, fp);
	for (i = 0; i < n; ++i) {
		fwrite(&a[i].n, sizeof(size_t), 1, fp);
		fwrite(a[i].a, 8, a[i].n, fp);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movslq (%rsi), %r15
shrq $0xf, %r15
andl $-0x2, %r15d
leaq 0x150f9(%rip), %rdi     # 0x1c5e9
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x2310
movl $0x30, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x2310
movl $0x1, %ebp
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2310
movq (%rbx), %rdx
movq 0x10(%rbx), %rdi
movl $0x8, %esi
movq %r14, %rcx
callq 0x2310
movl %ebp, %eax
movl %r15d, %ecx
shrl %cl, %eax
addq $0x18, %rbx
incl %ebp
testl %eax, %eax
je 0x751c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movl $0x1, %esi
movl $0x4, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2090
cmpl $0x24b4346, (%r15)      # imm = 0x24B4346
jne 0x7638
movl $0x30, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x2090
movslq (%r14), %rcx
sarq $0xf, %rcx
movl %ecx, %ebp
andl $-0x2, %ebp
andb $-0x2, %cl
movl $0x18, %edi
shlq %cl, %rdi
callq 0x2220
movq %rax, %r14
movl $0x1, %r13d
movq %rax, %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2090
movq (%r15), %r12
movq %r12, 0x8(%r15)
leaq (,%r12,8), %rdi
callq 0x2220
movq %rax, 0x10(%r15)
movl $0x8, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2090
movl %r13d, %eax
movl %ebp, %ecx
shrl %cl, %eax
addq $0x18, %r15
incl %r13d
testl %eax, %eax
je 0x75d4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2786
xorl %r14d, %r14d
jmp 0x7626
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_batch_read
fmc_batch_t *fmc_batch_read(kseq_t *ks, int64_t batch_size)
{
	int64_t l = 0;
	fmc_batch_t *b;
	b = calloc(1, sizeof(fmc_batch_t));
	while (l < batch_size && kseq_read(ks) >= 0) {
		if (b->n >= b->m) {
			b->m = b->n + 1;
			kroundup32(b->m);
			b->s = realloc(b->s, b->m * sizeof(void*));
			b->q = realloc(b->q, b->m * sizeof(void*));
			b->name = realloc(b->name, b->m * sizeof(void*));
		}
		b->s[b->n] = strdup(ks->seq.s);
		b->q[b->n] = ks->qual.l? strdup(ks->qual.s) : 0;
		b->name[b->n++] = strdup(ks->name.s);
		l += ks->seq.l;
	}
	if (l == 0) {
		free(b);
		return 0;
	} else return b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x2190
movq %rax, %rbx
testq %r14, %r14
jle 0x7990
xorl %r13d, %r13d
movq %r15, %rdi
callq 0xd991
testl %eax, %eax
js 0x798b
movslq (%rbx), %rbp
cmpl 0x4(%rbx), %ebp
jl 0x7938
movl %ebp, %eax
sarl %eax
orl %ebp, %eax
movl %eax, %ecx
sarl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x10, %eax
orl %ecx, %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
movq 0x8(%rbx), %rdi
cltq
leaq 0x8(,%rax,8), %r12
movq %r12, %rsi
callq 0x2260
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x2260
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0x2260
movq %rax, 0x18(%rbx)
movq 0x28(%r15), %rdi
callq 0x2340
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
cmpl $0x0, 0x30(%r15)
je 0x795b
movq 0x38(%r15), %rdi
callq 0x2340
jmp 0x795d
xorl %eax, %eax
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0x8(%r15), %rdi
callq 0x2340
movq 0x18(%rbx), %rcx
leal 0x1(%rbp), %edx
movl %edx, (%rbx)
movq %rax, (%rcx,%rbp,8)
movl 0x20(%r15), %eax
addq %rax, %r13
cmpq %r14, %r13
jl 0x78be
testq %r13, %r13
jne 0x799a
movq %rbx, %rdi
callq 0x2040
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x79ed
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x79bb
movq 0x18(%rbx), %rdi
callq 0x2040
movq 0x8(%rbx), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_seq_conv
int fmc_seq_conv(const char *s, const char *q, int defQ, ecseq_t *seq)
{
	int i, l;
	l = strlen(s);
	kv_resize(ecbase_t, *seq, l);
	seq->n = l;
	for (i = 0; i < l; ++i) {
		ecbase_t *c = &seq->a[i];
		c->b = c->ob = seq_nt6_table[(int)s[i]] - 1;
		c->q = q? q[i] - 33 : defQ;
		c->q = c->oq = c->q < FMC_Q_MAX? c->q : FMC_Q_MAX;
		c->q = c->q > 5? c->q : 5;
		c->state = STATE_N;
		c->i = i;
		c->f = 0;
		c->min_diff = 0xff;
	}
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
callq 0x20e0
movq %rax, (%rsp)
movslq %eax, %r13
cmpq %r13, 0x8(%rbx)
jae 0x7a95
leaq -0x1(%r13), %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
leaq 0x4(,%rcx,4), %rax
leaq (%rax,%rax,2), %rsi
callq 0x2260
movq %rax, 0x10(%rbx)
movq %r13, (%rbx)
testl %r13d, %r13d
jle 0x7b4d
movq (%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
leaq 0x1c72d(%rip), %rdx     # 0x241e0
movl $0xfffff0f0, %esi       # imm = 0xFFFFF0F0
movl $0x29, %edi
movl $0x5, %r8d
xorl %r9d, %r9d
movq 0x10(%rbx), %r10
movsbq (%r15,%r9), %r11
movb (%rdx,%r11), %r11b
decb %r11b
andb $0xf, %r11b
movzbl %r11b, %r12d
movl %r12d, %r13d
shll $0x8, %r13d
movl (%r10,%rcx), %r11d
andl %esi, %r11d
orl %r13d, %r11d
orl %r12d, %r11d
movw %r11w, (%r10,%rcx)
movl %ebp, %r13d
testq %r14, %r14
je 0x7b08
movzbl (%r14,%r9), %r13d
addl $-0x21, %r13d
movzbl %r13b, %r12d
cmpl $0x29, %r12d
cmovael %edi, %r13d
movb %r13b, 0x3(%r10,%rcx)
cmpb $0x6, %r13b
cmovbl %r8d, %r13d
movb %r13b, 0x2(%r10,%rcx)
movl %r9d, 0x8(%r10,%rcx)
andl $0xf0f, %r11d           # imm = 0xF0F
movw %r11w, (%r10,%rcx)
movb $-0x1, 0x4(%r10,%rcx)
incq %r9
addq $0xc, %rcx
cmpq %r9, %rax
jne 0x7ac6
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rdi)
jae 0x7bc8
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rdi
leaq 0x4(,%rcx,4), %rax
leaq (%rax,%rax,2), %rsi
callq 0x2260
movq %rax, 0x10(%r14)
movq $0x0, (%r14)
movq 0x10(%r14), %rdi
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
callq 0x21f0
cmpq $0x0, (%rbx)
je 0x7c36
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x10(%rbx), %rdx
movzwl (%rdx,%rax), %esi
andl $0xf0, %esi
cmpw $0x30, %si
je 0x7c2a
addq %rax, %rdx
movq (%r14), %rsi
movq 0x10(%r14), %rdi
leaq 0x1(%rsi), %r8
movq %r8, (%r14)
leaq (%rsi,%rsi,2), %rsi
movl 0x8(%rdx), %r8d
movl %r8d, 0x8(%rdi,%rsi,4)
movq (%rdx), %rdx
movq %rdx, (%rdi,%rsi,4)
incq %rcx
addq $0xc, %rax
cmpq %rcx, (%rbx)
ja 0x7bf1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_aux_init
fmc_aux_t *fmc_aux_init()
{
	fmc_aux_t *a;
	a = calloc(1, sizeof(fmc_aux_t));
	a->cache = kh_init(kache);
	return a;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0xb0, %esi
callq 0x2190
movq %rax, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x2190
movq %rax, 0xa8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0x2040
movq 0x40(%rbx), %rdi
callq 0x2040
movq 0x88(%rbx), %rdi
callq 0x2040
movq 0xa0(%rbx), %rdi
callq 0x2040
movq 0xa8(%rbx), %r14
testq %r14, %r14
je 0x8d68
movq 0x18(%r14), %rdi
callq 0x2040
movq 0x10(%r14), %rdi
callq 0x2040
movq 0x20(%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/correct.c
// Function: fmc_cns_ungap
int fmc_cns_ungap(ecseq_t *s1, const ecseq_t *s2)
{
	int i, n = 0;
	assert(s1->n == s2->n);
	for (i = 0; i < s1->n; ++i) {
		ecbase_t *b1 = &s1->a[i];
		const ecbase_t *b2 = &s2->a[i];
		if (b2->state == STATE_N) continue;
		if (b1->state == STATE_N) {
			*b1 = *b2;
		} else if (b1->b == b2->b) { // same correction in both directions
			b1->f = b1->f > b2->f? b1->f : b2->f;
			b1->min_diff = b1->min_diff > b2->min_diff? b1->min_diff : b2->min_diff;
		} else { // conflicting correction; don't make a correction
			b1->f = 0; b1->min_diff = 0;
			b1->b = b1->ob; b1->q = b1->oq;
			++n;
		}
	}
	return n;
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x8e5b
cmpq $0x0, (%rdi)
je 0x8e57
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
movq 0x10(%rsi), %r9
movzwl (%r9,%rcx), %r11d
testb $-0x10, %r11b
je 0x8e45
movq 0x10(%rdi), %r8
leaq (%r8,%rcx), %rbx
movzwl (%rbx), %r10d
testb $-0x10, %r10b
je 0x8df2
movl %r10d, %ebx
xorl %r11d, %ebx
testb $0xf, %bl
je 0x8e05
movb $0x0, 0x4(%r8,%rcx)
movl %r10d, %r9d
shrl $0x8, %r9d
andl $0xf, %r9d
andl $0xff0, %r10d           # imm = 0xFF0
orl %r9d, %r10d
movw %r10w, (%r8,%rcx)
movb 0x3(%r8,%rcx), %r9b
movb %r9b, 0x2(%r8,%rcx)
incl %eax
jmp 0x8e45
addq %rcx, %r9
movl 0x8(%r9), %r8d
movl %r8d, 0x8(%rbx)
movq (%r9), %r8
movq %r8, (%rbx)
jmp 0x8e45
movzwl %r10w, %ebx
shrl $0xc, %ebx
movzwl %r11w, %r11d
shrl $0xc, %r11d
cmpw %r11w, %bx
cmoval %ebx, %r11d
shll $0xc, %r11d
andl $0xfff, %r10d           # imm = 0xFFF
orl %r11d, %r10d
movw %r10w, (%r8,%rcx)
movl 0x4(%r8,%rcx), %r10d
movl 0x4(%r9,%rcx), %r9d
cmpb %r9b, %r10b
cmoval %r10d, %r9d
movb %r9b, 0x4(%r8,%rcx)
incq %rdx
addq $0xc, %rcx
cmpq %rdx, (%rdi)
ja 0x8d94
jmp 0x8e59
xorl %eax, %eax
popq %rbx
retq
leaq 0x1384d(%rip), %rdi     # 0x1c6af
leaq 0x136ea(%rip), %rsi     # 0x1c553
leaq 0x1384e(%rip), %rcx     # 0x1c6be
movl $0x354, %edx            # imm = 0x354
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x38, %rsp
movl %edx, %eax
movq 0x40(%rsp), %r10
movq 0x48(%rsp), %r11
leaq 0x8(%rsp), %rdx
movl %edi, (%rdx)
movq %rsi, 0x10(%rdx)
movq %r11, 0x18(%rdx)
movq %r9, 0x20(%rdx)
movq %r10, 0x28(%rdx)
movl %ecx, 0x4(%rdx)
sarl %ecx
cmpl $0x5, %ecx
movl $0x5, %esi
cmovgel %esi, %ecx
movl %eax, 0xc(%rdx)
movl %ecx, 0x8(%rdx)
addl %ecx, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %r8d, %edi
cmpl %r8d, %eax
cmovll %eax, %edi
leaq 0xd(%rip), %rsi         # 0xc134
movq %rax, %rcx
callq 0x360c
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rcx, %rsi
movl %edx, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movq (%r8,%rcx,8), %r10
movslq 0xc(%rdi), %r11
cmpq %r11, %r10
jae 0xc777
movl $0xfffffffe, %r11d      # imm = 0xFFFFFFFE
roll %cl, %r11d
andl %r11d, (%r9)
addq %r10, %rdx
incq %rcx
cmpq $0x6, %rcx
jne 0xc75e
cmpl %eax, 0x8(%rdi)
jle 0xc789
retq
leaq 0x1072f(%rip), %rdi     # 0x1cebf
xorl %eax, %eax
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movl %esi, 0x8(%rsp)
movq %rdi, %r15
callq 0x5117
movsd %xmm0, 0x10(%rsp)
cmpq $0x0, (%r15)
je 0x13920
xorl %r13d, %r13d
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r8d, %r8d
xorl %esi, %esi
movl 0x8(%rsp), %edx
movl %r12d, 0xc(%rsp)
movq 0x10(%r15), %rbp
movl (%rbp,%r13), %ecx
testl %ecx, %ecx
js 0x13912
cmpq $0x0, 0x20(%rbp,%r13)
je 0x138c4
cmpl %edx, %ecx
jge 0x13912
cmpq $0x0, 0x38(%rbp,%r13)
je 0x138c8
jmp 0x13912
cmpl %edx, %ecx
jge 0x13912
cmpl %r12d, 0x4(%rbp,%r13)
jge 0x13912
cmpq %rsi, %r14
jne 0x13902
leaq (%rsi,%rsi), %r12
testq %rsi, %rsi
movl $0x2, %eax
cmoveq %rax, %r12
leaq (,%r12,8), %rsi
movq %r8, %rdi
callq 0x2260
movl 0x8(%rsp), %edx
movq %r12, %rsi
movl 0xc(%rsp), %r12d
jmp 0x13905
movq %r8, %rax
addq %r13, %rbp
movq %rax, %r8
movq %rbp, (%rax,%r14,8)
incq %r14
incq %rbx
addq $0x68, %r13
cmpq %rbx, (%r15)
ja 0x138a1
jmp 0x13926
xorl %r8d, %r8d
xorl %r14d, %r14d
movq %r14, %rdi
movq %r8, %r13
movq %r8, %rsi
callq 0x12a2c
testq %r14, %r14
je 0x13950
xorl %ebx, %ebx
movq (%r13,%rbx,8), %rsi
movq %r15, %rdi
callq 0x11f5e
incq %rbx
cmpq %rbx, %r14
jne 0x1393b
movq %r13, %rdi
callq 0x2040
leaq 0x10901(%rip), %rax     # 0x24260
cmpl $0x3, (%rax)
jge 0x13976
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1067b(%rip), %rax     # 0x23ff8
movq (%rax), %r15
callq 0x5117
subsd 0x10(%rsp), %xmm0
leaq 0x98a9(%rip), %rsi      # 0x1d23b
leaq 0x98e1(%rip), %rdx      # 0x1d27a
movq %r15, %rdi
movq %r14, %rcx
movl 0x8(%rsp), %r8d
movl %r12d, %r9d
movb $0x1, %al
callq 0x21c0
jmp 0x13964
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x8(%rsp)
movl %edx, %r13d
movl %esi, 0x4(%rsp)
movq %rdi, %r12
callq 0x5117
movsd %xmm0, 0x10(%rsp)
cmpq $0x0, (%r12)
je 0x13a5a
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %eax, %eax
xorl %edi, %edi
movl 0x4(%rsp), %esi
movl %r13d, 0xc(%rsp)
movq 0x10(%r12), %r15
movl (%r15,%rbx), %ecx
testl %ecx, %ecx
sets %dl
cmpl %esi, %ecx
setge %cl
orb %dl, %cl
jne 0x13a4b
cmpl %r13d, 0x4(%r15,%rbx)
jge 0x13a4b
cmpq %rdi, %r14
jne 0x13a41
leaq (%rdi,%rdi), %r13
testq %rdi, %rdi
movl $0x2, %ecx
cmoveq %rcx, %r13
leaq (,%r13,8), %rsi
movq %rax, %rdi
callq 0x2260
movl 0x4(%rsp), %esi
movq %r13, %rdi
movl 0xc(%rsp), %r13d
addq %rbx, %r15
movq %r15, (%rax,%r14,8)
incq %r14
incq %rbp
addq $0x68, %rbx
cmpq %rbp, (%r12)
ja 0x139f2
jmp 0x13a5f
xorl %eax, %eax
xorl %r14d, %r14d
movq %r14, %rdi
movq %rax, %rsi
movq %rax, %r15
callq 0x12a2c
testq %r14, %r14
movl 0x8(%rsp), %ebp
je 0x13a8e
xorl %ebx, %ebx
movq (%r15,%rbx,8), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0x1202b
incq %rbx
cmpq %rbx, %r14
jne 0x13a78
movq %r15, %rdi
callq 0x2040
leaq 0x107c3(%rip), %rax     # 0x24260
cmpl $0x3, (%rax)
jge 0x13ab4
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1053d(%rip), %rax     # 0x23ff8
movq (%rax), %r15
callq 0x5117
subsd 0x10(%rsp), %xmm0
leaq 0x97b8(%rip), %rsi      # 0x1d288
leaq 0x97fd(%rip), %rdx      # 0x1d2d4
movq %r15, %rdi
movq %r14, %rcx
movl 0x4(%rsp), %r8d
movl %r13d, %r9d
movb $0x1, %al
callq 0x21c0
jmp 0x13aa2
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi2/unitig.c
// Function: main_assemble
int main_assemble(int argc, char *argv[])
{
	int c, use_mmap = 0, n_threads = 1, min_match = 31, min_merge_len = 0;
	rld_t *e;
	while ((c = getopt(argc, argv, "Ml:t:r:m:")) >= 0) {
		switch (c) {
			case 'l': min_match = atoi(optarg); break;
			case 'm': min_merge_len = atoi(optarg); break;
			case 'M': use_mmap = 1; break;
			case 't': n_threads = atoi(optarg); break;
		}
	}
	if (optind + 1 > argc) {
		fprintf(stderr, "\n");
		fprintf(stderr, "Usage:   fermi2 assemble [options] <reads.rld>\n\n");
		fprintf(stderr, "Options: -l INT      min match [%d]\n", min_match);
		fprintf(stderr, "         -m INT      min merge length [%d]\n", min_merge_len);
		fprintf(stderr, "         -t INT      number of threads [1]\n");
		fprintf(stderr, "\n");
		return 1;
	}
	e = use_mmap? rld_restore_mmap(argv[optind]) : rld_restore(argv[optind]);
	fm6_unitig(e, min_match, min_merge_len, n_threads);
	rld_destroy(e);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %r12d
leaq 0x7354(%rip), %rdx      # 0x1d9d2
callq 0x22f0
testl %eax, %eax
js 0x16715
movl $0x1, (%rsp)
movl $0x1f, 0x4(%rsp)
xorl %ebp, %ebp
movq 0xd935(%rip), %rbx      # 0x23fd8
leaq 0x7328(%rip), %r13      # 0x1d9d2
xorl %r14d, %r14d
cmpl $0x6c, %eax
jg 0x166ca
cmpl $0x4d, %eax
je 0x166e1
cmpl $0x6c, %eax
jne 0x166f3
movq (%rbx), %rdi
callq 0x2300
movl %eax, 0x4(%rsp)
jmp 0x166f3
cmpl $0x6d, %eax
je 0x166e9
cmpl $0x74, %eax
jne 0x166f3
movq (%rbx), %rdi
callq 0x2300
movl %eax, (%rsp)
jmp 0x166f3
movl $0x1, %r14d
jmp 0x166f3
movq (%rbx), %rdi
callq 0x2300
movl %eax, %ebp
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x22f0
testl %eax, %eax
jns 0x166ad
testl %r14d, %r14d
sete %al
movl 0x4(%rsp), %ebx
movl (%rsp), %r14d
jmp 0x16724
xorl %ebp, %ebp
movl $0x1f, %ebx
movl $0x1, %r14d
movb $0x1, %al
movq 0xd8a5(%rip), %rcx      # 0x23fd0
movslq (%rcx), %rcx
cmpl %r12d, %ecx
jge 0x16772
movq (%r15,%rcx,8), %rdi
testb %al, %al
je 0x16742
callq 0x436c
jmp 0x16747
callq 0x47e9
movq %rax, %r15
movq %rax, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x15f72
movq %r15, %rdi
callq 0x38cc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %edi
movl %ebp, %esi
callq 0x308b
movl $0x1, %eax
jmp 0x16763
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movq %rdi, %rbp
callq 0x5117
movsd %xmm0, 0x18(%rsp)
cmpq $0x0, (%rbp)
je 0x17b20
movl $0x1, %r15d
movl %ebx, 0xc(%rsp)
xorl %ebx, %ebx
xorl %eax, %eax
xorl %r14d, %r14d
movq %rbp, 0x10(%rsp)
movq %rax, 0x20(%rsp)
leaq -0x1(%r15), %rsi
movq %rbp, %rdi
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movl 0xc(%rsp), %r12d
movl %r12d, %edx
callq 0x175fe
xorl %r13d, %r13d
testl %eax, %eax
setg %r13b
xorl %ebp, %ebp
cmpl $0x2, %eax
setge %bpl
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movl %r12d, %edx
callq 0x175fe
xorl %r12d, %r12d
testl %eax, %eax
setg %r12b
addq %r14, %r12
addq %r13, %r12
xorl %r13d, %r13d
cmpl $0x2, %eax
setge %r13b
addq 0x20(%rsp), %r13
addq %rbp, %r13
movq 0x10(%rsp), %rbp
incq %rbx
addq $0x2, %r15
movq %r13, %rax
movq %r12, %r14
cmpq (%rbp), %rbx
jb 0x17a90
jmp 0x17b26
xorl %r12d, %r12d
xorl %r13d, %r13d
leaq 0xc733(%rip), %rax      # 0x24260
cmpl $0x3, (%rax)
jge 0x17b4e
movq %rbp, %rdi
xorl %esi, %esi
movl 0x8(%rsp), %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x119be
movq 0xc4a3(%rip), %rax      # 0x23ff8
movq (%rax), %r15
callq 0x5117
subsd 0x18(%rsp), %xmm0
leaq 0x601e(%rip), %rsi      # 0x1db88
leaq 0x6050(%rip), %rdx      # 0x1dbc1
movq %r15, %rdi
movq %r12, %rcx
movq %r13, %r8
movb $0x1, %al
callq 0x21c0
jmp 0x17b32
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x5117
movsd %xmm0, (%rsp)
cmpq $0x0, (%rbx)
je 0x18023
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rsi
addq %r14, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x17b83
incq %r15
addq $0x68, %r14
cmpq (%rbx), %r15
jb 0x18006
leaq 0xc236(%rip), %rax      # 0x24260
cmpl $0x3, (%rax)
jge 0x18045
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x119be
movsd (%rsp), %xmm0
callq 0x3119
jmp 0x1802f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x2190
movq %rax, %rbx
movl %r12d, 0x4(%rax)
movq 0x28(%r14), %rdx
movq 0x8(%rdx), %r15
movq %r15, 0x8(%rax)
xorl %eax, %eax
incq %rax
movl $0x1, %esi
movl %eax, %ecx
shlq %cl, %rsi
cmpq %r15, %rsi
jl 0x1808b
movl $0x1, %esi
movl %r12d, %ecx
shll %cl, %esi
movl %eax, (%rbx)
movslq %esi, %rax
addq (%rdx), %rax
movq 0x8(%rdx), %r13
notq %r13
addq %rax, %r13
shrq %cl, %r13
movq %r13, 0x10(%rbx)
movl $0x8, %esi
movq %r15, %rdi
callq 0x2190
movq %rax, 0x18(%rbx)
movl $0x8, %esi
movq %r13, %rdi
callq 0x2190
movq %rax, 0x20(%rbx)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2190
movq %rax, %r12
movslq %ebp, %r13
movl $0x18, %esi
movq %r13, %rdi
callq 0x2190
movq %rax, 0x10(%r12)
movq %rbx, 0x8(%r12)
movq %r14, (%r12)
leaq 0x5c(%rip), %rsi        # 0x18175
movl %r13d, %edi
movq %r12, %rdx
movq %r15, %rcx
callq 0x360c
testl %r13d, %r13d
jle 0x18151
movl %ebp, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r14
xorl %r15d, %r15d
movq 0x10(%r12), %rax
movq 0x10(%rax,%r15), %rdi
callq 0x2040
addq $0x18, %r15
cmpq %r15, %r14
jne 0x18139
movq 0x10(%r12), %rdi
callq 0x2040
movq %r12, %rdi
callq 0x2040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r8
movl 0x4(%rsi), %ecx
movzbl 0x1(%rdi), %eax
leal 0xf(,%rax,8), %eax
andl $-0x10, %eax
movq %rsp, %r13
subq %rax, %r13
movq %r13, %rsp
movq $-0x1, (%r8)
movq 0x28(%rdi), %rax
movq $-0x1, %r15
cmpq %rdx, (%rax)
jbe 0x1829c
movq %rsi, %r14
movq %rdi, %r12
movq %r8, -0x30(%rbp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
shll %cl, %ebx
notl %ebx
xorl %r15d, %r15d
movq 0x28(%r12), %rax
movq %rdx, %rsi
subq 0x8(%rax), %rsi
jb 0x18226
testl %ebx, %esi
je 0x18268
incq %r15
incq %rdx
movq %r12, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x4a3f
movq 0x20(%r12), %rcx
cltq
movq (%rcx,%rax,8), %rcx
movq (%r13,%rax,8), %rdx
addq %rcx, %rdx
decq %rdx
testl %eax, %eax
jne 0x18214
movq 0x18(%r14), %rax
movq (%rax,%rdx,8), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
decq %r15
jmp 0x1829c
movb (%r14), %al
movb 0x4(%r14), %cl
shrq %cl, %rsi
movq $-0x1, %rdx
movl %eax, %ecx
shlq %cl, %rdx
movq 0x20(%r14), %rcx
notq %rdx
andq (%rcx,%rsi,8), %rdx
movq -0x30(%rbp), %rdi
movq %rdx, (%rdi)
movq (%rcx,%rsi,8), %rdx
movl %eax, %ecx
shrq %cl, %rdx
addq %rdx, %r15
movq %r15, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x182e6
movq %rsi, %r14
leaq 0x48c4(%rip), %rsi      # 0x1cb8d
movq %r14, %rdi
callq 0x21a0
testl %eax, %eax
je 0x182e6
leaq 0x3d61(%rip), %rsi      # 0x1c03d
movq %r14, %rdi
callq 0x22d0
jmp 0x18303
movq 0xbcd3(%rip), %rax      # 0x23fc0
movq (%rax), %rdi
callq 0x2200
leaq 0x3d41(%rip), %rsi      # 0x1c03d
movl %eax, %edi
callq 0x2270
movq %rax, %r14
testq %rax, %rax
je 0x183ab
movl 0x4(%rbx), %eax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2310
movl (%rbx), %eax
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2310
leaq 0x8(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2310
leaq 0x10(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2310
movq 0x8(%rbx), %rdx
movq 0x18(%rbx), %rdi
movl $0x8, %esi
movq %r14, %rcx
callq 0x2310
movq 0x10(%rbx), %rdx
movq 0x20(%rbx), %rdi
movl $0x8, %esi
movq %r14, %rcx
callq 0x2310
movq %r14, %rdi
callq 0x20d0
xorl %eax, %eax
jmp 0x183b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x183ee
movq %rdi, %rbx
leaq 0x47b9(%rip), %rsi      # 0x1cb8d
callq 0x21a0
testl %eax, %eax
je 0x183ee
leaq 0x3c61(%rip), %rsi      # 0x1c045
movq %rbx, %rdi
callq 0x22d0
jmp 0x1840b
movq 0xbbd3(%rip), %rax      # 0x23fc8
movq (%rax), %rdi
callq 0x2200
leaq 0x3c41(%rip), %rsi      # 0x1c045
movl %eax, %edi
callq 0x2270
movq %rax, %r14
testq %rax, %rax
je 0x184e7
movl $0x1, %edi
movl $0x28, %esi
callq 0x2190
movq %rax, %rbx
leaq 0x4(%rsp), %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2090
movl (%r15), %eax
movl %eax, 0x4(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2090
movl (%r15), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2090
leaq 0x10(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2090
movq 0x8(%rbx), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x2190
movq %rax, %rbp
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x2190
movq %rax, %r13
movq %rax, 0x20(%rbx)
testq %rax, %rax
setne %al
testq %rbp, %rbp
setne %cl
testb %al, %cl
jne 0x184eb
movq %rbp, %rdi
callq 0x2040
movq %r13, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2040
xorl %ebx, %ebx
jmp 0x18519
movl $0x8, %esi
movq %rbp, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2090
movl $0x8, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2090
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq